2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* editor_settings.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2018-01-05 00:50:27 +01: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 "editor_settings.h"
2017-01-16 08:04:19 +01:00
2020-11-07 23:33:38 +01:00
# include "core/config/project_settings.h"
2020-12-07 12:31:51 +01:00
# include "core/input/input_map.h"
2018-09-15 14:45:54 +02:00
# include "core/io/certs_compressed.gen.h"
2017-08-26 17:46:49 +02:00
# include "core/io/compression.h"
# include "core/io/config_file.h"
2021-06-11 14:51:48 +02:00
# include "core/io/dir_access.h"
# include "core/io/file_access.h"
2017-08-26 17:46:49 +02:00
# include "core/io/file_access_memory.h"
2019-12-24 08:17:23 +01:00
# include "core/io/ip.h"
2017-08-26 17:46:49 +02:00
# include "core/io/resource_loader.h"
# include "core/io/resource_saver.h"
# include "core/io/translation_loader_po.h"
# include "core/os/keyboard.h"
# include "core/os/os.h"
# include "core/version.h"
2020-03-18 18:34:36 +01:00
# include "editor/doc_translations.gen.h"
2017-08-26 17:46:49 +02:00
# include "editor/editor_node.h"
2020-03-18 18:34:36 +01:00
# include "editor/editor_translations.gen.h"
2017-03-05 16:44:50 +01:00
# include "scene/main/node.h"
2017-06-27 03:58:03 +02:00
# include "scene/main/scene_tree.h"
2020-03-04 02:51:12 +01:00
# include "scene/main/window.h"
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
// PRIVATE METHODS
2014-02-10 02:10:30 +01:00
2020-04-02 01:20:12 +02:00
Ref < EditorSettings > EditorSettings : : singleton = nullptr ;
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
// Properties
2014-02-10 02:10:30 +01:00
2018-01-06 12:40:43 +01:00
bool EditorSettings : : _set ( const StringName & p_name , const Variant & p_value ) {
_THREAD_SAFE_METHOD_
bool changed = _set_only ( p_name , p_value ) ;
if ( changed ) {
2021-07-17 23:22:52 +02:00
emit_signal ( SNAME ( " settings_changed " ) ) ;
2018-01-06 12:40:43 +01:00
}
return true ;
}
bool EditorSettings : : _set_only ( const StringName & p_name , const Variant & p_value ) {
2014-02-10 02:10:30 +01:00
_THREAD_SAFE_METHOD_
2016-06-05 02:31:29 +02:00
2020-12-07 12:31:51 +01:00
if ( p_name = = " shortcuts " ) {
2017-03-05 16:44:50 +01:00
Array arr = p_value ;
ERR_FAIL_COND_V ( arr . size ( ) & & arr . size ( ) & 1 , true ) ;
for ( int i = 0 ; i < arr . size ( ) ; i + = 2 ) {
2016-06-05 02:31:29 +02:00
String name = arr [ i ] ;
2017-05-20 17:38:03 +02:00
Ref < InputEvent > shortcut = arr [ i + 1 ] ;
2016-06-05 02:31:29 +02:00
2020-09-09 21:53:24 +02:00
Ref < Shortcut > sc ;
2021-06-18 00:03:09 +02:00
sc . instantiate ( ) ;
2021-08-03 17:27:45 +02:00
sc - > set_event ( shortcut ) ;
2017-03-05 16:44:50 +01:00
add_shortcut ( name , sc ) ;
2016-06-05 02:31:29 +02:00
}
2020-12-07 12:31:51 +01:00
return false ;
} else if ( p_name = = " builtin_action_overrides " ) {
Array actions_arr = p_value ;
for ( int i = 0 ; i < actions_arr . size ( ) ; i + + ) {
Dictionary action_dict = actions_arr [ i ] ;
String name = action_dict [ " name " ] ;
Array events = action_dict [ " events " ] ;
InputMap * im = InputMap : : get_singleton ( ) ;
im - > action_erase_events ( name ) ;
builtin_action_overrides [ name ] . clear ( ) ;
for ( int ev_idx = 0 ; ev_idx < events . size ( ) ; ev_idx + + ) {
im - > action_add_event ( name , events [ ev_idx ] ) ;
builtin_action_overrides [ name ] . push_back ( events [ ev_idx ] ) ;
}
}
2018-01-06 12:40:43 +01:00
return false ;
2016-06-05 02:31:29 +02:00
}
2017-12-29 11:03:29 +01:00
bool changed = false ;
2017-11-30 04:11:53 +01:00
if ( p_value . get_type ( ) = = Variant : : NIL ) {
2017-12-29 11:03:29 +01:00
if ( props . has ( p_name ) ) {
props . erase ( p_name ) ;
changed = true ;
}
2017-11-30 04:11:53 +01:00
} else {
2017-12-29 11:03:29 +01:00
if ( props . has ( p_name ) ) {
if ( p_value ! = props [ p_name ] . variant ) {
props [ p_name ] . variant = p_value ;
changed = true ;
}
} else {
2017-03-05 16:44:50 +01:00
props [ p_name ] = VariantContainer ( p_value , last_order + + ) ;
2017-12-29 11:03:29 +01:00
changed = true ;
}
2016-06-12 02:16:14 +02:00
if ( save_changed_setting ) {
2019-06-26 15:08:25 +02:00
if ( ! props [ p_name ] . save ) {
2017-12-29 11:03:29 +01:00
props [ p_name ] . save = true ;
changed = true ;
}
2016-06-12 02:16:14 +02:00
}
2014-02-10 02:10:30 +01:00
}
2018-01-06 12:40:43 +01:00
return changed ;
2014-02-10 02:10:30 +01:00
}
2017-08-26 17:46:49 +02:00
2017-03-05 16:44:50 +01:00
bool EditorSettings : : _get ( const StringName & p_name , Variant & r_ret ) const {
2014-02-10 02:10:30 +01:00
_THREAD_SAFE_METHOD_
2020-12-07 12:31:51 +01:00
if ( p_name = = " shortcuts " ) {
2016-06-05 02:31:29 +02:00
Array arr ;
2020-09-09 21:53:24 +02:00
for ( const Map < String , Ref < Shortcut > > : : Element * E = shortcuts . front ( ) ; E ; E = E - > next ( ) ) {
Ref < Shortcut > sc = E - > get ( ) ;
2016-06-05 02:31:29 +02:00
2020-12-07 12:31:51 +01:00
if ( builtin_action_overrides . has ( E - > key ( ) ) ) {
// This shortcut was auto-generated from built in actions: don't save.
continue ;
}
2016-07-04 00:13:45 +02:00
if ( optimize_save ) {
if ( ! sc - > has_meta ( " original " ) ) {
continue ; //this came from settings but is not any longer used
}
2017-05-20 17:38:03 +02:00
Ref < InputEvent > original = sc - > get_meta ( " original " ) ;
2021-08-03 17:27:45 +02:00
if ( sc - > matches_event ( original ) | | ( original . is_null ( ) & & sc - > get_event ( ) . is_null ( ) ) ) {
2016-07-04 00:13:45 +02:00
continue ; //not changed from default, don't save
2020-05-14 16:41:43 +02:00
}
2016-07-04 00:13:45 +02:00
}
2016-06-05 02:31:29 +02:00
arr . push_back ( E - > key ( ) ) ;
2021-08-03 17:27:45 +02:00
arr . push_back ( sc - > get_event ( ) ) ;
2016-06-05 02:31:29 +02:00
}
2017-03-05 16:44:50 +01:00
r_ret = arr ;
2016-06-05 02:31:29 +02:00
return true ;
2020-12-07 12:31:51 +01:00
} else if ( p_name = = " builtin_action_overrides " ) {
Array actions_arr ;
for ( Map < String , List < Ref < InputEvent > > > : : Element * E = builtin_action_overrides . front ( ) ; E ; E = E - > next ( ) ) {
List < Ref < InputEvent > > events = E - > get ( ) ;
// TODO: skip actions which are the same as the builtin.
Dictionary action_dict ;
action_dict [ " name " ] = E - > key ( ) ;
Array events_arr ;
for ( List < Ref < InputEvent > > : : Element * I = events . front ( ) ; I ; I = I - > next ( ) ) {
events_arr . push_back ( I - > get ( ) ) ;
}
action_dict [ " events " ] = events_arr ;
actions_arr . push_back ( action_dict ) ;
}
r_ret = actions_arr ;
return true ;
2016-06-05 02:31:29 +02:00
}
2017-03-05 16:44:50 +01:00
const VariantContainer * v = props . getptr ( p_name ) ;
2017-01-05 23:41:36 +01:00
if ( ! v ) {
2019-11-07 09:44:15 +01:00
WARN_PRINT ( " EditorSettings::_get - Property not found: " + String ( p_name ) ) ;
2014-02-10 02:10:30 +01:00
return false ;
2017-01-05 23:41:36 +01:00
}
2014-02-10 02:10:30 +01:00
r_ret = v - > variant ;
return true ;
}
2017-09-25 05:26:41 +02:00
void EditorSettings : : _initial_set ( const StringName & p_name , const Variant & p_value ) {
set ( p_name , p_value ) ;
props [ p_name ] . initial = p_value ;
2017-11-20 18:34:13 +01:00
props [ p_name ] . has_default_value = true ;
2017-09-25 05:26:41 +02:00
}
2014-02-10 02:10:30 +01:00
struct _EVCSort {
String name ;
2020-11-24 10:12:55 +01:00
Variant : : Type type = Variant : : Type : : NIL ;
int order = 0 ;
bool save = false ;
bool restart_if_changed = false ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
bool operator < ( const _EVCSort & p_vcs ) const { return order < p_vcs . order ; }
2014-02-10 02:10:30 +01:00
} ;
void EditorSettings : : _get_property_list ( List < PropertyInfo > * p_list ) const {
_THREAD_SAFE_METHOD_
2020-04-02 01:20:12 +02:00
const String * k = nullptr ;
2014-02-10 02:10:30 +01:00
Set < _EVCSort > vclist ;
2017-03-05 16:44:50 +01:00
while ( ( k = props . next ( k ) ) ) {
const VariantContainer * v = props . getptr ( * k ) ;
2014-02-10 02:10:30 +01:00
2020-05-14 16:41:43 +02:00
if ( v - > hide_from_editor ) {
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
_EVCSort vc ;
2017-03-05 16:44:50 +01:00
vc . name = * k ;
vc . order = v - > order ;
vc . type = v - > variant . get_type ( ) ;
vc . save = v - > save ;
2019-03-06 16:10:36 +01:00
/*if (vc.save) { this should be implemented, but lets do after 3.1 is out.
if ( v - > initial . get_type ( ) ! = Variant : : NIL & & v - > initial = = v - > variant ) {
vc . save = false ;
}
} */
2018-07-19 23:58:15 +02:00
vc . restart_if_changed = v - > restart_if_changed ;
2014-02-10 02:10:30 +01:00
vclist . insert ( vc ) ;
}
2017-03-05 16:44:50 +01:00
for ( Set < _EVCSort > : : Element * E = vclist . front ( ) ; E ; E = E - > next ( ) ) {
2021-07-01 03:24:34 +02:00
uint32_t pusage = PROPERTY_USAGE_NONE ;
2016-07-04 00:13:45 +02:00
if ( E - > get ( ) . save | | ! optimize_save ) {
2021-07-01 03:24:34 +02:00
pusage | = PROPERTY_USAGE_STORAGE ;
2016-06-12 02:16:14 +02:00
}
2016-06-12 20:34:58 +02:00
if ( ! E - > get ( ) . name . begins_with ( " _ " ) & & ! E - > get ( ) . name . begins_with ( " projects/ " ) ) {
2021-07-01 03:24:34 +02:00
pusage | = PROPERTY_USAGE_EDITOR ;
2016-06-12 02:16:14 +02:00
} else {
2021-07-01 03:24:34 +02:00
pusage | = PROPERTY_USAGE_STORAGE ; //hiddens must always be saved
2016-06-12 02:16:14 +02:00
}
2014-02-10 02:10:30 +01:00
PropertyInfo pi ( E - > get ( ) . type , E - > get ( ) . name ) ;
2021-07-01 03:24:34 +02:00
pi . usage = pusage ;
2020-05-14 16:41:43 +02:00
if ( hints . has ( E - > get ( ) . name ) ) {
2017-03-05 16:44:50 +01:00
pi = hints [ E - > get ( ) . name ] ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2018-07-19 23:58:15 +02:00
if ( E - > get ( ) . restart_if_changed ) {
pi . usage | = PROPERTY_USAGE_RESTART_IF_CHANGED ;
}
2017-03-05 16:44:50 +01:00
p_list - > push_back ( pi ) ;
2014-02-10 02:10:30 +01:00
}
2016-06-05 02:31:29 +02:00
2018-01-11 23:35:12 +01:00
p_list - > push_back ( PropertyInfo ( Variant : : ARRAY , " shortcuts " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL ) ) ; //do not edit
2020-12-07 12:31:51 +01:00
p_list - > push_back ( PropertyInfo ( Variant : : ARRAY , " builtin_action_overrides " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL ) ) ;
2014-02-10 02:10:30 +01:00
}
2017-10-28 15:40:55 +02:00
void EditorSettings : : _add_property_info_bind ( const Dictionary & p_info ) {
ERR_FAIL_COND ( ! p_info . has ( " name " ) ) ;
ERR_FAIL_COND ( ! p_info . has ( " type " ) ) ;
2017-10-05 20:34:34 +02:00
2017-10-28 15:40:55 +02:00
PropertyInfo pinfo ;
pinfo . name = p_info [ " name " ] ;
ERR_FAIL_COND ( ! props . has ( pinfo . name ) ) ;
pinfo . type = Variant : : Type ( p_info [ " type " ] . operator int ( ) ) ;
ERR_FAIL_INDEX ( pinfo . type , Variant : : VARIANT_MAX ) ;
2014-02-10 02:10:30 +01:00
2020-05-14 16:41:43 +02:00
if ( p_info . has ( " hint " ) ) {
2017-10-28 15:40:55 +02:00
pinfo . hint = PropertyHint ( p_info [ " hint " ] . operator int ( ) ) ;
2020-05-14 16:41:43 +02:00
}
if ( p_info . has ( " hint_string " ) ) {
2017-10-28 15:40:55 +02:00
pinfo . hint_string = p_info [ " hint_string " ] ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
add_property_hint ( pinfo ) ;
2014-02-10 02:10:30 +01:00
}
2017-10-28 15:40:55 +02:00
// Default configs
2017-10-28 23:25:28 +02:00
bool EditorSettings : : has_default_value ( const String & p_setting ) const {
_THREAD_SAFE_METHOD_
2020-05-14 16:41:43 +02:00
if ( ! props . has ( p_setting ) ) {
2017-10-28 23:25:28 +02:00
return false ;
2020-05-14 16:41:43 +02:00
}
2017-11-20 18:34:13 +01:00
return props [ p_setting ] . has_default_value ;
2017-10-28 23:25:28 +02:00
}
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
void EditorSettings : : _load_defaults ( Ref < ConfigFile > p_extra_config ) {
2014-02-10 02:10:30 +01:00
_THREAD_SAFE_METHOD_
2018-12-12 08:18:24 +01:00
/* Languages */
2017-10-28 15:40:55 +02:00
{
String lang_hint = " en " ;
String host_lang = OS : : get_singleton ( ) - > get_locale ( ) ;
host_lang = TranslationServer : : standardize_locale ( host_lang ) ;
2014-02-10 02:10:30 +01:00
2020-09-03 13:22:16 +02:00
// Skip locales if Text server lack required features.
Vector < String > locales_to_skip ;
if ( ! TS - > has_feature ( TextServer : : FEATURE_BIDI_LAYOUT ) | | ! TS - > has_feature ( TextServer : : FEATURE_SHAPING ) ) {
locales_to_skip . push_back ( " ar " ) ; // Arabic
locales_to_skip . push_back ( " fa " ) ; // Persian
locales_to_skip . push_back ( " ur " ) ; // Urdu
}
if ( ! TS - > has_feature ( TextServer : : FEATURE_BIDI_LAYOUT ) ) {
locales_to_skip . push_back ( " he " ) ; // Hebrew
}
if ( ! TS - > has_feature ( TextServer : : FEATURE_SHAPING ) ) {
locales_to_skip . push_back ( " bn " ) ; // Bengali
locales_to_skip . push_back ( " hi " ) ; // Hindi
locales_to_skip . push_back ( " ml " ) ; // Malayalam
locales_to_skip . push_back ( " si " ) ; // Sinhala
locales_to_skip . push_back ( " ta " ) ; // Tamil
locales_to_skip . push_back ( " te " ) ; // Telugu
}
2019-05-21 14:32:01 +02:00
2020-12-15 13:04:21 +01:00
if ( ! locales_to_skip . is_empty ( ) ) {
2020-09-03 13:22:16 +02:00
WARN_PRINT ( " Some locales are not properly supported by selected Text Server and are disabled. " ) ;
}
2017-09-25 05:26:41 +02:00
2020-09-03 13:22:16 +02:00
String best ;
2018-01-06 13:17:12 +01:00
EditorTranslationList * etl = _editor_translations ;
while ( etl - > data ) {
const String & locale = etl - > lang ;
2019-05-21 14:32:01 +02:00
// Skip locales which we can't render properly (see above comment).
// Test against language code without regional variants (e.g. ur_PK).
String lang_code = locale . get_slice ( " _ " , 0 ) ;
if ( locales_to_skip . find ( lang_code ) ! = - 1 ) {
etl + + ;
continue ;
}
2017-10-28 15:40:55 +02:00
lang_hint + = " , " ;
lang_hint + = locale ;
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
if ( host_lang = = locale ) {
best = locale ;
}
2017-08-26 05:40:45 +02:00
2017-10-28 15:40:55 +02:00
if ( best = = String ( ) & & host_lang . begins_with ( locale ) ) {
best = locale ;
}
2018-01-06 13:17:12 +01:00
etl + + ;
2017-10-28 15:40:55 +02:00
}
2017-08-26 05:40:45 +02:00
2017-10-28 15:40:55 +02:00
if ( best = = String ( ) ) {
best = " en " ;
}
2017-08-03 18:23:46 +02:00
2017-10-28 15:40:55 +02:00
_initial_set ( " interface/editor/editor_language " , best ) ;
2018-07-19 23:58:15 +02:00
set_restart_if_changed ( " interface/editor/editor_language " , true ) ;
2017-10-28 15:40:55 +02:00
hints [ " interface/editor/editor_language " ] = PropertyInfo ( Variant : : STRING , " interface/editor/editor_language " , PROPERTY_HINT_ENUM , lang_hint , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
}
2017-08-03 18:23:46 +02:00
2018-12-12 08:18:24 +01:00
/* Interface */
// Editor
2018-03-22 20:20:42 +01:00
_initial_set ( " interface/editor/display_scale " , 0 ) ;
2021-01-18 02:39:46 +01:00
// Display what the Auto display scale setting effectively corresponds to.
2021-06-16 14:36:09 +02:00
float scale = get_auto_display_scale ( ) ;
2021-08-08 17:07:57 +02:00
_initial_set ( " interface/editor/enable_debugging_pseudolocalization " , false ) ;
set_restart_if_changed ( " interface/editor/enable_debugging_pseudolocalization " , true ) ;
// Use pseudolocalization in editor.
2021-01-18 02:39:46 +01:00
hints [ " interface/editor/display_scale " ] = PropertyInfo ( Variant : : INT , " interface/editor/display_scale " , PROPERTY_HINT_ENUM , vformat ( " Auto (%d%%),75%%,100%%,125%%,150%%,175%%,200%%,Custom " , Math : : round ( scale * 100 ) ) , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2018-03-22 20:20:42 +01:00
_initial_set ( " interface/editor/custom_display_scale " , 1.0f ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " interface/editor/custom_display_scale " ] = PropertyInfo ( Variant : : FLOAT , " interface/editor/custom_display_scale " , PROPERTY_HINT_RANGE , " 0.5,3,0.01 " , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2018-01-07 20:07:47 +01:00
_initial_set ( " interface/editor/main_font_size " , 14 ) ;
2019-06-14 14:23:49 +02:00
hints [ " interface/editor/main_font_size " ] = PropertyInfo ( Variant : : INT , " interface/editor/main_font_size " , PROPERTY_HINT_RANGE , " 8,48,1 " , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2019-07-28 01:10:51 +02:00
_initial_set ( " interface/editor/code_font_size " , 14 ) ;
hints [ " interface/editor/code_font_size " ] = PropertyInfo ( Variant : : INT , " interface/editor/code_font_size " , PROPERTY_HINT_RANGE , " 8,48,1 " , PROPERTY_USAGE_DEFAULT ) ;
2020-09-03 13:22:16 +02:00
_initial_set ( " interface/editor/code_font_contextual_ligatures " , 0 ) ;
2021-01-18 03:00:42 +01:00
hints [ " interface/editor/code_font_contextual_ligatures " ] = PropertyInfo ( Variant : : INT , " interface/editor/code_font_contextual_ligatures " , PROPERTY_HINT_ENUM , " Default,Disable Contextual Alternates (Coding Ligatures),Use Custom OpenType Feature Set " , PROPERTY_USAGE_DEFAULT ) ;
2020-09-03 13:22:16 +02:00
_initial_set ( " interface/editor/code_font_custom_opentype_features " , " " ) ;
2020-10-22 18:40:18 +02:00
_initial_set ( " interface/editor/code_font_custom_variations " , " " ) ;
2019-07-28 01:10:51 +02:00
_initial_set ( " interface/editor/font_antialiased " , true ) ;
2019-08-14 14:51:13 +02:00
_initial_set ( " interface/editor/font_hinting " , 0 ) ;
2021-01-18 02:39:46 +01:00
# ifdef OSX_ENABLED
hints [ " interface/editor/font_hinting " ] = PropertyInfo ( Variant : : INT , " interface/editor/font_hinting " , PROPERTY_HINT_ENUM , " Auto (None),None,Light,Normal " , PROPERTY_USAGE_DEFAULT ) ;
# else
hints [ " interface/editor/font_hinting " ] = PropertyInfo ( Variant : : INT , " interface/editor/font_hinting " , PROPERTY_HINT_ENUM , " Auto (Light),None,Light,Normal " , PROPERTY_USAGE_DEFAULT ) ;
# endif
2018-01-07 20:07:47 +01:00
_initial_set ( " interface/editor/main_font " , " " ) ;
2018-07-20 10:19:20 +02:00
hints [ " interface/editor/main_font " ] = PropertyInfo ( Variant : : STRING , " interface/editor/main_font " , PROPERTY_HINT_GLOBAL_FILE , " *.ttf,*.otf " , PROPERTY_USAGE_DEFAULT ) ;
2018-05-11 03:38:16 +02:00
_initial_set ( " interface/editor/main_font_bold " , " " ) ;
2018-07-20 10:19:20 +02:00
hints [ " interface/editor/main_font_bold " ] = PropertyInfo ( Variant : : STRING , " interface/editor/main_font_bold " , PROPERTY_HINT_GLOBAL_FILE , " *.ttf,*.otf " , PROPERTY_USAGE_DEFAULT ) ;
2018-01-07 20:07:47 +01:00
_initial_set ( " interface/editor/code_font " , " " ) ;
2018-07-20 10:19:20 +02:00
hints [ " interface/editor/code_font " ] = PropertyInfo ( Variant : : STRING , " interface/editor/code_font " , PROPERTY_HINT_GLOBAL_FILE , " *.ttf,*.otf " , PROPERTY_USAGE_DEFAULT ) ;
2019-05-29 23:12:19 +02:00
_initial_set ( " interface/editor/low_processor_mode_sleep_usec " , 6900 ) ; // ~144 FPS
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " interface/editor/low_processor_mode_sleep_usec " ] = PropertyInfo ( Variant : : FLOAT , " interface/editor/low_processor_mode_sleep_usec " , PROPERTY_HINT_RANGE , " 1,100000,1 " , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2021-04-12 00:01:26 +02:00
_initial_set ( " interface/editor/unfocused_low_processor_mode_sleep_usec " , 100000 ) ; // 10 FPS
// Allow an unfocused FPS limit as low as 1 FPS for those who really need low power usage
// (but don't need to preview particles or shaders while the editor is unfocused).
// With very low FPS limits, the editor can take a small while to become usable after being focused again,
// so this should be used at the user's discretion.
hints [ " interface/editor/unfocused_low_processor_mode_sleep_usec " ] = PropertyInfo ( Variant : : FLOAT , " interface/editor/unfocused_low_processor_mode_sleep_usec " , PROPERTY_HINT_RANGE , " 1,1000000,1 " , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " interface/editor/separate_distraction_mode " , false ) ;
2019-07-23 07:05:29 +02:00
_initial_set ( " interface/editor/automatically_open_screenshots " , true ) ;
2020-03-28 21:56:50 +01:00
_initial_set ( " interface/editor/single_window_mode " , false ) ;
hints [ " interface/editor/single_window_mode " ] = PropertyInfo ( Variant : : BOOL , " interface/editor/single_window_mode " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2020-08-17 18:05:48 +02:00
_initial_set ( " interface/editor/hide_console_window " , false ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " interface/editor/save_each_scene_on_quit " , true ) ; // Regression
2017-07-12 20:46:08 +02:00
2021-01-01 19:41:11 +01:00
// Inspector
_initial_set ( " interface/inspector/max_array_dictionary_items_per_page " , 20 ) ;
hints [ " interface/inspector/max_array_dictionary_items_per_page " ] = PropertyInfo ( Variant : : INT , " interface/inspector/max_array_dictionary_items_per_page " , PROPERTY_HINT_RANGE , " 10,100,1 " , PROPERTY_USAGE_DEFAULT ) ;
2018-12-12 08:18:24 +01:00
// Theme
2018-06-23 11:05:12 +02:00
_initial_set ( " interface/theme/preset " , " Default " ) ;
2019-03-23 01:57:28 +01:00
hints [ " interface/theme/preset " ] = PropertyInfo ( Variant : : STRING , " interface/theme/preset " , PROPERTY_HINT_ENUM , " Default,Breeze Dark,Godot 2,Grey,Light,Solarized (Dark),Solarized (Light),Custom " , PROPERTY_USAGE_DEFAULT ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " interface/theme/icon_and_font_color " , 0 ) ;
2018-10-04 14:18:34 +02:00
hints [ " interface/theme/icon_and_font_color " ] = PropertyInfo ( Variant : : INT , " interface/theme/icon_and_font_color " , PROPERTY_HINT_ENUM , " Auto,Dark,Light " , PROPERTY_USAGE_DEFAULT ) ;
2019-07-08 20:03:06 +02:00
_initial_set ( " interface/theme/base_color " , Color ( 0.2 , 0.23 , 0.31 ) ) ;
2018-10-04 14:18:34 +02:00
hints [ " interface/theme/base_color " ] = PropertyInfo ( Variant : : COLOR , " interface/theme/base_color " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_DEFAULT ) ;
2019-07-08 20:03:06 +02:00
_initial_set ( " interface/theme/accent_color " , Color ( 0.41 , 0.61 , 0.91 ) ) ;
2019-03-16 18:59:48 +01:00
hints [ " interface/theme/accent_color " ] = PropertyInfo ( Variant : : COLOR , " interface/theme/accent_color " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_DEFAULT ) ;
2021-05-07 15:32:29 +02:00
_initial_set ( " interface/theme/contrast " , 0.3 ) ;
hints [ " interface/theme/contrast " ] = PropertyInfo ( Variant : : FLOAT , " interface/theme/contrast " , PROPERTY_HINT_RANGE , " -1, 1, 0.01 " ) ;
2021-02-12 16:16:37 +01:00
_initial_set ( " interface/theme/icon_saturation " , 1.0 ) ;
hints [ " interface/theme/icon_saturation " ] = PropertyInfo ( Variant : : FLOAT , " interface/theme/icon_saturation " , PROPERTY_HINT_RANGE , " 0,2,0.01 " , PROPERTY_USAGE_DEFAULT ) ;
2019-03-06 16:10:36 +01:00
_initial_set ( " interface/theme/relationship_line_opacity " , 0.1 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " interface/theme/relationship_line_opacity " ] = PropertyInfo ( Variant : : FLOAT , " interface/theme/relationship_line_opacity " , PROPERTY_HINT_RANGE , " 0.00, 1, 0.01 " ) ;
2019-03-23 01:57:28 +01:00
_initial_set ( " interface/theme/border_size " , 0 ) ;
2018-10-04 14:18:34 +02:00
hints [ " interface/theme/border_size " ] = PropertyInfo ( Variant : : INT , " interface/theme/border_size " , PROPERTY_HINT_RANGE , " 0,2,1 " , PROPERTY_USAGE_DEFAULT ) ;
2019-03-23 01:57:28 +01:00
_initial_set ( " interface/theme/corner_radius " , 3 ) ;
hints [ " interface/theme/corner_radius " ] = PropertyInfo ( Variant : : INT , " interface/theme/corner_radius " , PROPERTY_HINT_RANGE , " 0,6,1 " , PROPERTY_USAGE_DEFAULT ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " interface/theme/additional_spacing " , 0 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " interface/theme/additional_spacing " ] = PropertyInfo ( Variant : : FLOAT , " interface/theme/additional_spacing " , PROPERTY_HINT_RANGE , " 0,5,0.1 " , PROPERTY_USAGE_DEFAULT ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " interface/theme/custom_theme " , " " ) ;
2021-05-07 16:24:37 +02:00
hints [ " interface/theme/custom_theme " ] = PropertyInfo ( Variant : : STRING , " interface/theme/custom_theme " , PROPERTY_HINT_GLOBAL_FILE , " *.res,*.tres,*.theme " , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2017-08-03 18:23:46 +02:00
2018-12-12 08:18:24 +01:00
// Scene tabs
2017-10-28 15:40:55 +02:00
_initial_set ( " interface/scene_tabs/show_thumbnail_on_hover " , true ) ;
_initial_set ( " interface/scene_tabs/resize_if_many_tabs " , true ) ;
_initial_set ( " interface/scene_tabs/minimum_width " , 50 ) ;
hints [ " interface/scene_tabs/minimum_width " ] = PropertyInfo ( Variant : : INT , " interface/scene_tabs/minimum_width " , PROPERTY_HINT_RANGE , " 50,500,1 " , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2018-12-12 08:18:24 +01:00
_initial_set ( " interface/scene_tabs/show_script_button " , false ) ;
2017-08-03 18:23:46 +02:00
2018-12-12 08:18:24 +01:00
/* Filesystem */
// Directories
2017-10-28 15:40:55 +02:00
_initial_set ( " filesystem/directories/autoscan_project_path " , " " ) ;
hints [ " filesystem/directories/autoscan_project_path " ] = PropertyInfo ( Variant : : STRING , " filesystem/directories/autoscan_project_path " , PROPERTY_HINT_GLOBAL_DIR ) ;
_initial_set ( " filesystem/directories/default_project_path " , OS : : get_singleton ( ) - > has_environment ( " HOME " ) ? OS : : get_singleton ( ) - > get_environment ( " HOME " ) : OS : : get_singleton ( ) - > get_system_dir ( OS : : SYSTEM_DIR_DOCUMENTS ) ) ;
hints [ " filesystem/directories/default_project_path " ] = PropertyInfo ( Variant : : STRING , " filesystem/directories/default_project_path " , PROPERTY_HINT_GLOBAL_DIR ) ;
2017-07-12 20:46:08 +02:00
2018-12-12 08:18:24 +01:00
// On save
_initial_set ( " filesystem/on_save/compress_binary_resources " , true ) ;
_initial_set ( " filesystem/on_save/safe_save_on_backup_then_rename " , true ) ;
// File dialog
_initial_set ( " filesystem/file_dialog/show_hidden_files " , false ) ;
_initial_set ( " filesystem/file_dialog/display_mode " , 0 ) ;
hints [ " filesystem/file_dialog/display_mode " ] = PropertyInfo ( Variant : : INT , " filesystem/file_dialog/display_mode " , PROPERTY_HINT_ENUM , " Thumbnails,List " ) ;
_initial_set ( " filesystem/file_dialog/thumbnail_size " , 64 ) ;
hints [ " filesystem/file_dialog/thumbnail_size " ] = PropertyInfo ( Variant : : INT , " filesystem/file_dialog/thumbnail_size " , PROPERTY_HINT_RANGE , " 32,128,16 " ) ;
/* Docks */
// SceneTree
_initial_set ( " docks/scene_tree/start_create_dialog_fully_expanded " , false ) ;
// FileSystem
_initial_set ( " docks/filesystem/thumbnail_size " , 64 ) ;
hints [ " docks/filesystem/thumbnail_size " ] = PropertyInfo ( Variant : : INT , " docks/filesystem/thumbnail_size " , PROPERTY_HINT_RANGE , " 32,128,16 " ) ;
_initial_set ( " docks/filesystem/always_show_folders " , true ) ;
// Property editor
2021-02-10 21:18:45 +01:00
_initial_set ( " docks/property_editor/auto_refresh_interval " , 0.2 ) ; //update 5 times per second by default
2021-02-11 22:01:56 +01:00
_initial_set ( " docks/property_editor/subresource_hue_tint " , 0.75 ) ;
hints [ " docks/property_editor/subresource_hue_tint " ] = PropertyInfo ( Variant : : FLOAT , " docks/property_editor/subresource_hue_tint " , PROPERTY_HINT_RANGE , " 0,1,0.01 " , PROPERTY_USAGE_DEFAULT ) ;
2018-12-12 08:18:24 +01:00
/* Text editor */
// Theme
2021-05-27 10:22:36 +02:00
_initial_set ( " text_editor/theme/color_theme " , " Default " ) ;
hints [ " text_editor/theme/color_theme " ] = PropertyInfo ( Variant : : STRING , " text_editor/theme/color_theme " , PROPERTY_HINT_ENUM , " Default,Godot 2,Custom " ) ;
2018-10-14 21:38:35 +02:00
_initial_set ( " text_editor/theme/line_spacing " , 6 ) ;
2019-04-11 18:29:07 +02:00
hints [ " text_editor/theme/line_spacing " ] = PropertyInfo ( Variant : : INT , " text_editor/theme/line_spacing " , PROPERTY_HINT_RANGE , " 0,50,1 " ) ;
2014-02-10 02:10:30 +01:00
2021-05-27 10:22:36 +02:00
_load_godot2_text_editor_theme ( ) ;
2014-02-10 02:10:30 +01:00
2018-12-12 08:18:24 +01:00
// Highlighting
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/highlighting/highlight_all_occurrences " , true ) ;
_initial_set ( " text_editor/highlighting/highlight_current_line " , true ) ;
2018-06-05 18:50:21 +02:00
_initial_set ( " text_editor/highlighting/highlight_type_safe_lines " , true ) ;
2017-01-11 20:52:21 +01:00
2018-12-12 08:18:24 +01:00
// Indent
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/indent/type " , 0 ) ;
hints [ " text_editor/indent/type " ] = PropertyInfo ( Variant : : INT , " text_editor/indent/type " , PROPERTY_HINT_ENUM , " Tabs,Spaces " ) ;
_initial_set ( " text_editor/indent/size " , 4 ) ;
hints [ " text_editor/indent/size " ] = PropertyInfo ( Variant : : INT , " text_editor/indent/size " , PROPERTY_HINT_RANGE , " 1, 64, 1 " ) ; // size of 0 crashes.
_initial_set ( " text_editor/indent/auto_indent " , true ) ;
2019-10-14 21:35:17 +02:00
_initial_set ( " text_editor/indent/convert_indent_on_save " , true ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/indent/draw_tabs " , true ) ;
2019-04-24 01:33:20 +02:00
_initial_set ( " text_editor/indent/draw_spaces " , false ) ;
2014-02-10 02:10:30 +01:00
2019-09-01 13:28:57 +02:00
// Navigation
_initial_set ( " text_editor/navigation/smooth_scrolling " , true ) ;
_initial_set ( " text_editor/navigation/v_scroll_speed " , 80 ) ;
_initial_set ( " text_editor/navigation/show_minimap " , true ) ;
_initial_set ( " text_editor/navigation/minimap_width " , 80 ) ;
hints [ " text_editor/navigation/minimap_width " ] = PropertyInfo ( Variant : : INT , " text_editor/navigation/minimap_width " , PROPERTY_HINT_RANGE , " 50,250,1 " ) ;
// Appearance
_initial_set ( " text_editor/appearance/show_line_numbers " , true ) ;
_initial_set ( " text_editor/appearance/line_numbers_zero_padded " , false ) ;
_initial_set ( " text_editor/appearance/show_bookmark_gutter " , true ) ;
_initial_set ( " text_editor/appearance/show_info_gutter " , true ) ;
_initial_set ( " text_editor/appearance/code_folding " , true ) ;
_initial_set ( " text_editor/appearance/word_wrap " , false ) ;
2020-02-15 02:59:59 +01:00
_initial_set ( " text_editor/appearance/show_line_length_guidelines " , true ) ;
_initial_set ( " text_editor/appearance/line_length_guideline_soft_column " , 80 ) ;
hints [ " text_editor/appearance/line_length_guideline_soft_column " ] = PropertyInfo ( Variant : : INT , " text_editor/appearance/line_length_guideline_soft_column " , PROPERTY_HINT_RANGE , " 20, 160, 1 " ) ;
_initial_set ( " text_editor/appearance/line_length_guideline_hard_column " , 100 ) ;
hints [ " text_editor/appearance/line_length_guideline_hard_column " ] = PropertyInfo ( Variant : : INT , " text_editor/appearance/line_length_guideline_hard_column " , PROPERTY_HINT_RANGE , " 20, 160, 1 " ) ;
2019-09-01 13:28:57 +02:00
// Script list
_initial_set ( " text_editor/script_list/show_members_overview " , true ) ;
2016-02-19 08:41:08 +01:00
2018-12-12 08:18:24 +01:00
// Files
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/files/trim_trailing_whitespace_on_save " , false ) ;
2018-12-12 08:18:24 +01:00
_initial_set ( " text_editor/files/autosave_interval_secs " , 0 ) ;
_initial_set ( " text_editor/files/restore_scripts_on_load " , true ) ;
// Tools
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/tools/create_signal_callbacks " , true ) ;
2018-04-30 14:27:00 +02:00
_initial_set ( " text_editor/tools/sort_members_outline_alphabetically " , false ) ;
2014-02-10 02:10:30 +01:00
2018-12-12 08:18:24 +01:00
// Cursor
_initial_set ( " text_editor/cursor/scroll_past_end_of_file " , false ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/cursor/block_caret " , false ) ;
2017-12-05 10:28:00 +01:00
_initial_set ( " text_editor/cursor/caret_blink " , true ) ;
2018-08-02 21:01:45 +02:00
_initial_set ( " text_editor/cursor/caret_blink_speed " , 0.5 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " text_editor/cursor/caret_blink_speed " ] = PropertyInfo ( Variant : : FLOAT , " text_editor/cursor/caret_blink_speed " , PROPERTY_HINT_RANGE , " 0.1, 10, 0.01 " ) ;
2017-12-20 02:36:47 +01:00
_initial_set ( " text_editor/cursor/right_click_moves_caret " , true ) ;
2014-02-10 02:10:30 +01:00
2018-12-12 08:18:24 +01:00
// Completion
2019-04-25 23:48:59 +02:00
_initial_set ( " text_editor/completion/idle_parse_delay " , 2.0 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " text_editor/completion/idle_parse_delay " ] = PropertyInfo ( Variant : : FLOAT , " text_editor/completion/idle_parse_delay " , PROPERTY_HINT_RANGE , " 0.1, 10, 0.01 " ) ;
2019-07-18 21:34:28 +02:00
_initial_set ( " text_editor/completion/auto_brace_complete " , true ) ;
_initial_set ( " text_editor/completion/code_complete_delay " , 0.3 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " text_editor/completion/code_complete_delay " ] = PropertyInfo ( Variant : : FLOAT , " text_editor/completion/code_complete_delay " , PROPERTY_HINT_RANGE , " 0.01, 5, 0.01 " ) ;
2018-01-06 12:40:43 +01:00
_initial_set ( " text_editor/completion/put_callhint_tooltip_below_current_line " , true ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/completion/complete_file_paths " , true ) ;
2018-05-30 04:16:59 +02:00
_initial_set ( " text_editor/completion/add_type_hints " , false ) ;
2018-12-18 02:53:54 +01:00
_initial_set ( " text_editor/completion/use_single_quotes " , false ) ;
2014-02-10 02:10:30 +01:00
2018-12-12 08:18:24 +01:00
// Help
_initial_set ( " text_editor/help/show_help_index " , true ) ;
2019-06-14 14:23:49 +02:00
_initial_set ( " text_editor/help/help_font_size " , 15 ) ;
hints [ " text_editor/help/help_font_size " ] = PropertyInfo ( Variant : : INT , " text_editor/help/help_font_size " , PROPERTY_HINT_RANGE , " 8,48,1 " ) ;
_initial_set ( " text_editor/help/help_source_font_size " , 14 ) ;
hints [ " text_editor/help/help_source_font_size " ] = PropertyInfo ( Variant : : INT , " text_editor/help/help_source_font_size " , PROPERTY_HINT_RANGE , " 8,48,1 " ) ;
_initial_set ( " text_editor/help/help_title_font_size " , 23 ) ;
hints [ " text_editor/help/help_title_font_size " ] = PropertyInfo ( Variant : : INT , " text_editor/help/help_title_font_size " , PROPERTY_HINT_RANGE , " 8,48,1 " ) ;
2020-07-22 22:41:10 +02:00
_initial_set ( " text_editor/help/class_reference_examples " , 0 ) ;
hints [ " text_editor/help/class_reference_examples " ] = PropertyInfo ( Variant : : INT , " text_editor/help/class_reference_examples " , PROPERTY_HINT_ENUM , " GDScript,C#,GDScript and C# " ) ;
2018-12-12 08:18:24 +01:00
/* Editors */
2014-02-10 02:10:30 +01:00
2018-12-12 08:18:24 +01:00
// GridMap
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/grid_map/pick_distance " , 5000.0 ) ;
2014-02-10 02:10:30 +01:00
2018-12-12 08:18:24 +01:00
// 3D
2019-04-21 12:15:45 +02:00
_initial_set ( " editors/3d/primary_grid_color " , Color ( 0.56 , 0.56 , 0.56 , 0.5 ) ) ;
hints [ " editors/3d/primary_grid_color " ] = PropertyInfo ( Variant : : COLOR , " editors/3d/primary_grid_color " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_DEFAULT ) ;
2018-04-30 01:43:20 +02:00
2019-04-21 12:15:45 +02:00
_initial_set ( " editors/3d/secondary_grid_color " , Color ( 0.38 , 0.38 , 0.38 , 0.5 ) ) ;
hints [ " editors/3d/secondary_grid_color " ] = PropertyInfo ( Variant : : COLOR , " editors/3d/secondary_grid_color " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_DEFAULT ) ;
2018-04-30 01:43:20 +02:00
2020-12-29 07:35:59 +01:00
// Use a similar color to the 2D editor selection.
_initial_set ( " editors/3d/selection_box_color " , Color ( 1.0 , 0.5 , 0 ) ) ;
hints [ " editors/3d/selection_box_color " ] = PropertyInfo ( Variant : : COLOR , " editors/3d/selection_box_color " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED ) ;
2019-04-21 12:15:45 +02:00
// If a line is a multiple of this, it uses the primary grid color.
2020-11-21 21:35:23 +01:00
// Use a power of 2 value by default as it's more common to use powers of 2 in level design.
_initial_set ( " editors/3d/primary_grid_steps " , 8 ) ;
2019-04-21 12:15:45 +02:00
hints [ " editors/3d/primary_grid_steps " ] = PropertyInfo ( Variant : : INT , " editors/3d/primary_grid_steps " , PROPERTY_HINT_RANGE , " 1,100,1 " , PROPERTY_USAGE_DEFAULT ) ;
// At 1000, the grid mostly looks like it has no edge.
_initial_set ( " editors/3d/grid_size " , 200 ) ;
hints [ " editors/3d/grid_size " ] = PropertyInfo ( Variant : : INT , " editors/3d/grid_size " , PROPERTY_HINT_RANGE , " 1,2000,1 " , PROPERTY_USAGE_DEFAULT ) ;
// Default largest grid size is 100m, 10^2 (primary grid lines are 1km apart when primary_grid_steps is 10).
_initial_set ( " editors/3d/grid_division_level_max " , 2 ) ;
// Higher values produce graphical artifacts when far away unless View Z-Far
// is increased significantly more than it really should need to be.
hints [ " editors/3d/grid_division_level_max " ] = PropertyInfo ( Variant : : INT , " editors/3d/grid_division_level_max " , PROPERTY_HINT_RANGE , " -1,3,1 " , PROPERTY_USAGE_DEFAULT ) ;
2021-03-18 01:20:08 +01:00
// Default smallest grid size is 1m, 10^0.
_initial_set ( " editors/3d/grid_division_level_min " , 0 ) ;
2019-04-21 12:15:45 +02:00
// Lower values produce graphical artifacts regardless of view clipping planes, so limit to -2 as a lower bound.
hints [ " editors/3d/grid_division_level_min " ] = PropertyInfo ( Variant : : INT , " editors/3d/grid_division_level_min " , PROPERTY_HINT_RANGE , " -2,2,1 " , PROPERTY_USAGE_DEFAULT ) ;
// -0.2 seems like a sensible default. -1.0 gives Blender-like behavior, 0.5 gives huge grids.
_initial_set ( " editors/3d/grid_division_level_bias " , - 0.2 ) ;
hints [ " editors/3d/grid_division_level_bias " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/grid_division_level_bias " , PROPERTY_HINT_RANGE , " -1.0,0.5,0.1 " , PROPERTY_USAGE_DEFAULT ) ;
_initial_set ( " editors/3d/grid_xz_plane " , true ) ;
_initial_set ( " editors/3d/grid_xy_plane " , false ) ;
_initial_set ( " editors/3d/grid_yz_plane " , false ) ;
2014-02-10 02:10:30 +01:00
2019-10-31 14:32:46 +01:00
// Use a lower default FOV for the 3D camera compared to the
// Camera3D node as the 3D viewport doesn't span the whole screen.
// This means it's technically viewed from a further distance, which warrants a narrower FOV.
2017-11-25 23:03:26 +01:00
_initial_set ( " editors/3d/default_fov " , 70.0 ) ;
2019-10-31 14:32:46 +01:00
hints [ " editors/3d/default_fov " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/default_fov " , PROPERTY_HINT_RANGE , " 1,179,0.1 " ) ;
2017-11-25 23:03:26 +01:00
_initial_set ( " editors/3d/default_z_near " , 0.05 ) ;
2019-10-31 14:32:46 +01:00
hints [ " editors/3d/default_z_near " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/default_z_near " , PROPERTY_HINT_RANGE , " 0.01,10,0.01,or_greater " ) ;
_initial_set ( " editors/3d/default_z_far " , 4000.0 ) ;
hints [ " editors/3d/default_z_far " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/default_z_far " , PROPERTY_HINT_RANGE , " 0.1,4000,0.1,or_greater " ) ;
2017-10-28 15:40:55 +02:00
2018-12-12 08:18:24 +01:00
// 3D: Navigation
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/navigation/navigation_scheme " , 0 ) ;
2018-11-17 16:24:34 +01:00
_initial_set ( " editors/3d/navigation/invert_y_axis " , false ) ;
2020-08-15 13:18:01 +02:00
_initial_set ( " editors/3d/navigation/invert_x_axis " , false ) ;
2017-10-28 15:40:55 +02:00
hints [ " editors/3d/navigation/navigation_scheme " ] = PropertyInfo ( Variant : : INT , " editors/3d/navigation/navigation_scheme " , PROPERTY_HINT_ENUM , " Godot,Maya,Modo " ) ;
_initial_set ( " editors/3d/navigation/zoom_style " , 0 ) ;
hints [ " editors/3d/navigation/zoom_style " ] = PropertyInfo ( Variant : : INT , " editors/3d/navigation/zoom_style " , PROPERTY_HINT_ENUM , " Vertical, Horizontal " ) ;
2021-07-02 09:27:12 +02:00
_initial_set ( " editors/3d/navigation/emulate_numpad " , false ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/navigation/emulate_3_button_mouse " , false ) ;
_initial_set ( " editors/3d/navigation/orbit_modifier " , 0 ) ;
hints [ " editors/3d/navigation/orbit_modifier " ] = PropertyInfo ( Variant : : INT , " editors/3d/navigation/orbit_modifier " , PROPERTY_HINT_ENUM , " None,Shift,Alt,Meta,Ctrl " ) ;
_initial_set ( " editors/3d/navigation/pan_modifier " , 1 ) ;
hints [ " editors/3d/navigation/pan_modifier " ] = PropertyInfo ( Variant : : INT , " editors/3d/navigation/pan_modifier " , PROPERTY_HINT_ENUM , " None,Shift,Alt,Meta,Ctrl " ) ;
_initial_set ( " editors/3d/navigation/zoom_modifier " , 4 ) ;
hints [ " editors/3d/navigation/zoom_modifier " ] = PropertyInfo ( Variant : : INT , " editors/3d/navigation/zoom_modifier " , PROPERTY_HINT_ENUM , " None,Shift,Alt,Meta,Ctrl " ) ;
_initial_set ( " editors/3d/navigation/warped_mouse_panning " , true ) ;
2018-12-12 08:18:24 +01:00
// 3D: Navigation feel
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/navigation_feel/orbit_sensitivity " , 0.4 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " editors/3d/navigation_feel/orbit_sensitivity " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/navigation_feel/orbit_sensitivity " , PROPERTY_HINT_RANGE , " 0.0, 2, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/navigation_feel/orbit_inertia " , 0.05 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " editors/3d/navigation_feel/orbit_inertia " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/navigation_feel/orbit_inertia " , PROPERTY_HINT_RANGE , " 0.0, 1, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/navigation_feel/translation_inertia " , 0.15 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " editors/3d/navigation_feel/translation_inertia " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/navigation_feel/translation_inertia " , PROPERTY_HINT_RANGE , " 0.0, 1, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/navigation_feel/zoom_inertia " , 0.075 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " editors/3d/navigation_feel/zoom_inertia " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/navigation_feel/zoom_inertia " , PROPERTY_HINT_RANGE , " 0.0, 1, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/navigation_feel/manipulation_orbit_inertia " , 0.075 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " editors/3d/navigation_feel/manipulation_orbit_inertia " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/navigation_feel/manipulation_orbit_inertia " , PROPERTY_HINT_RANGE , " 0.0, 1, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/navigation_feel/manipulation_translation_inertia " , 0.075 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " editors/3d/navigation_feel/manipulation_translation_inertia " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/navigation_feel/manipulation_translation_inertia " , PROPERTY_HINT_RANGE , " 0.0, 1, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
2018-12-12 08:18:24 +01:00
// 3D: Freelook
2020-04-18 16:20:35 +02:00
_initial_set ( " editors/3d/freelook/freelook_navigation_scheme " , false ) ;
hints [ " editors/3d/freelook/freelook_navigation_scheme " ] = PropertyInfo ( Variant : : INT , " editors/3d/freelook/freelook_navigation_scheme " , PROPERTY_HINT_ENUM , " Default,Partially Axis-Locked (id Tech),Fully Axis-Locked (Minecraft) " ) ;
2020-04-02 16:47:15 +02:00
_initial_set ( " editors/3d/freelook/freelook_sensitivity " , 0.4 ) ;
hints [ " editors/3d/freelook/freelook_sensitivity " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/freelook/freelook_sensitivity " , PROPERTY_HINT_RANGE , " 0.0, 2, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/freelook/freelook_inertia " , 0.1 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " editors/3d/freelook/freelook_inertia " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/freelook/freelook_inertia " , PROPERTY_HINT_RANGE , " 0.0, 1, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/freelook/freelook_base_speed " , 5.0 ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
hints [ " editors/3d/freelook/freelook_base_speed " ] = PropertyInfo ( Variant : : FLOAT , " editors/3d/freelook/freelook_base_speed " , PROPERTY_HINT_RANGE , " 0.0, 10, 0.01 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/3d/freelook/freelook_activation_modifier " , 0 ) ;
hints [ " editors/3d/freelook/freelook_activation_modifier " ] = PropertyInfo ( Variant : : INT , " editors/3d/freelook/freelook_activation_modifier " , PROPERTY_HINT_ENUM , " None,Shift,Alt,Meta,Ctrl " ) ;
_initial_set ( " editors/3d/freelook/freelook_speed_zoom_link " , false ) ;
2018-12-12 08:18:24 +01:00
// 2D
2018-08-18 17:32:09 +02:00
_initial_set ( " editors/2d/grid_color " , Color ( 1.0 , 1.0 , 1.0 , 0.07 ) ) ;
2017-12-05 21:42:33 +01:00
_initial_set ( " editors/2d/guides_color " , Color ( 0.6 , 0.0 , 0.8 ) ) ;
2019-04-05 10:18:21 +02:00
_initial_set ( " editors/2d/smart_snapping_line_color " , Color ( 0.9 , 0.1 , 0.1 ) ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/2d/bone_width " , 5 ) ;
New and improved IK system for Skeleton2D
This PR and commit adds a new IK system for 2D with the Skeleton2D node
that adds several new IK solvers, a way to control bones in a Skeleton2D
node similar to that in Skeleton3D. It also adds additional changes
and functionality.
This work was sponsored by GSoC 2020 and TwistedTwigleg.
Full list of changes:
* Adds a SkeletonModifier2D resource
* This resource is the base where all IK code is written and executed
* Has a function for clamping angles, since it is so commonly used
* Modifiers are unique when duplicated so it works with instancing
* Adds a SkeletonModifierStack2D resource
* This resource manages a series of SkeletonModification2Ds
* This is what the Skeleton2D directly interfaces with to make IK possible
* Adds SkeletonModifier2D resources for LookAt, CCDIK, FABRIK, Jiggle, and TwoBoneIK
* Each modification is in its own file
* There is also a SkeletonModifier2D resource that acts as a stack for using multiple stacks together
* Adds a PhysicalBone2D node
* Works similar to the PhysicalBone3D node, but uses a RigidBody2D node
* Changes to Skeleton2D listed below:
* Skeleton2D now holds a single SkeletonModificationStack2D for IK
* Skeleton2D now has a local_pose_override, which overrides the Bone2D position similar to how the overrides work in Skeleton3D
* Changes to Bone2D listed below:
* The default_length property has been changed to length. Length is the length of the bone to its child bone node
* New bone_angle property, which is the angle the bone has to its first child bone node
* Bone2D caches its transform when not modified by IK for IK interpolation purposes
* Bone2D draws its own editor gizmo, though this is stated to change in the future
* Changes to CanvasItemEditor listed below:
* Bone2D gizmo drawing code removed
* The 2D IK code is removed. Now Bone2D is the only bone system for 2D
* Transform2D now has a looking_at function for rotating to face a position
* Two new node notifications: NOTIFICATION_EDITOR_PRE_SAVE and NOTIFICATION_EDITOR_POST_SAVE
* These notifications only are called in the editor right before and after saving a scene
* Needed for not saving the IK position when executing IK in the editor
* Documentation for all the changes listed above.
2020-08-03 20:02:24 +02:00
_initial_set ( " editors/2d/bone_color1 " , Color ( 1.0 , 1.0 , 1.0 , 0.7 ) ) ;
_initial_set ( " editors/2d/bone_color2 " , Color ( 0.6 , 0.6 , 0.6 , 0.7 ) ) ;
_initial_set ( " editors/2d/bone_selected_color " , Color ( 0.9 , 0.45 , 0.45 , 0.7 ) ) ;
_initial_set ( " editors/2d/bone_ik_color " , Color ( 0.9 , 0.9 , 0.45 , 0.7 ) ) ;
_initial_set ( " editors/2d/bone_outline_color " , Color ( 0.35 , 0.35 , 0.35 , 0.5 ) ) ;
2018-05-04 16:54:04 +02:00
_initial_set ( " editors/2d/bone_outline_size " , 2 ) ;
2018-09-24 15:16:40 +02:00
_initial_set ( " editors/2d/viewport_border_color " , Color ( 0.4 , 0.4 , 1.0 , 0.4 ) ) ;
2019-06-24 21:15:26 +02:00
_initial_set ( " editors/2d/constrain_editor_view " , true ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/2d/warped_mouse_panning " , true ) ;
2019-06-05 22:35:07 +02:00
_initial_set ( " editors/2d/simple_panning " , false ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/2d/scroll_to_pan " , false ) ;
_initial_set ( " editors/2d/pan_speed " , 20 ) ;
2021-05-21 17:28:28 +02:00
// Tiles editor
_initial_set ( " editors/tiles_editor/display_grid " , true ) ;
_initial_set ( " editors/tiles_editor/grid_color " , Color ( 1.0 , 0.5 , 0.2 , 0.5 ) ) ;
2018-12-12 08:18:24 +01:00
// Polygon editor
2017-10-28 15:40:55 +02:00
_initial_set ( " editors/poly_editor/point_grab_radius " , 8 ) ;
_initial_set ( " editors/poly_editor/show_previous_outline " , true ) ;
2018-12-12 08:18:24 +01:00
// Animation
_initial_set ( " editors/animation/autorename_animation_tracks " , true ) ;
_initial_set ( " editors/animation/confirm_insert_track " , true ) ;
2020-12-20 11:46:44 +01:00
_initial_set ( " editors/animation/default_create_bezier_tracks " , false ) ;
_initial_set ( " editors/animation/default_create_reset_tracks " , true ) ;
2018-12-12 08:18:24 +01:00
_initial_set ( " editors/animation/onion_layers_past_color " , Color ( 1 , 0 , 0 ) ) ;
_initial_set ( " editors/animation/onion_layers_future_color " , Color ( 0 , 1 , 0 ) ) ;
2021-01-25 15:37:05 +01:00
// Visual editors
_initial_set ( " editors/visual_editors/minimap_opacity " , 0.85 ) ;
hints [ " editors/visual_editors/minimap_opacity " ] = PropertyInfo ( Variant : : FLOAT , " editors/visual_editors/minimap_opacity " , PROPERTY_HINT_RANGE , " 0.0,1.0,0.01 " , PROPERTY_USAGE_DEFAULT ) ;
2018-12-12 08:18:24 +01:00
/* Run */
// Window placement
2017-10-28 15:40:55 +02:00
_initial_set ( " run/window_placement/rect " , 1 ) ;
hints [ " run/window_placement/rect " ] = PropertyInfo ( Variant : : INT , " run/window_placement/rect " , PROPERTY_HINT_ENUM , " Top Left,Centered,Custom Position,Force Maximized,Force Fullscreen " ) ;
2018-08-18 15:30:00 +02:00
String screen_hints = " Same as Editor,Previous Monitor,Next Monitor " ;
2020-03-03 14:36:29 +01:00
for ( int i = 0 ; i < DisplayServer : : get_singleton ( ) - > get_screen_count ( ) ; i + + ) {
2017-10-28 15:40:55 +02:00
screen_hints + = " ,Monitor " + itos ( i + 1 ) ;
}
_initial_set ( " run/window_placement/rect_custom_position " , Vector2 ( ) ) ;
_initial_set ( " run/window_placement/screen " , 0 ) ;
hints [ " run/window_placement/screen " ] = PropertyInfo ( Variant : : INT , " run/window_placement/screen " , PROPERTY_HINT_ENUM , screen_hints ) ;
2018-12-12 08:18:24 +01:00
// Auto save
2017-10-28 15:40:55 +02:00
_initial_set ( " run/auto_save/save_before_running " , true ) ;
2018-12-12 08:18:24 +01:00
// Output
2019-06-14 14:23:49 +02:00
_initial_set ( " run/output/font_size " , 13 ) ;
hints [ " run/output/font_size " ] = PropertyInfo ( Variant : : INT , " run/output/font_size " , PROPERTY_HINT_RANGE , " 8,48,1 " ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " run/output/always_clear_output_on_play " , true ) ;
_initial_set ( " run/output/always_open_output_on_play " , true ) ;
_initial_set ( " run/output/always_close_output_on_stop " , false ) ;
2019-08-21 17:05:06 +02:00
/* Network */
// Debug
_initial_set ( " network/debug/remote_host " , " 127.0.0.1 " ) ; // Hints provided in setup_network
_initial_set ( " network/debug/remote_port " , 6007 ) ;
hints [ " network/debug/remote_port " ] = PropertyInfo ( Variant : : INT , " network/debug/remote_port " , PROPERTY_HINT_RANGE , " 1,65535,1 " ) ;
// SSL
_initial_set ( " network/ssl/editor_ssl_certificates " , _SYSTEM_CERTS_PATH ) ;
hints [ " network/ssl/editor_ssl_certificates " ] = PropertyInfo ( Variant : : STRING , " network/ssl/editor_ssl_certificates " , PROPERTY_HINT_GLOBAL_FILE , " *.crt,*.pem " ) ;
2018-12-12 08:18:24 +01:00
/* Extra config */
2017-10-28 15:40:55 +02:00
2018-12-12 21:12:41 +01:00
_initial_set ( " project_manager/sorting_order " , 0 ) ;
2020-02-12 18:13:32 +01:00
hints [ " project_manager/sorting_order " ] = PropertyInfo ( Variant : : INT , " project_manager/sorting_order " , PROPERTY_HINT_ENUM , " Name,Path,Last Edited " ) ;
2018-12-12 21:12:41 +01:00
2017-10-28 15:40:55 +02:00
if ( p_extra_config . is_valid ( ) ) {
if ( p_extra_config - > has_section ( " init_projects " ) & & p_extra_config - > has_section_key ( " init_projects " , " list " ) ) {
Vector < String > list = p_extra_config - > get_value ( " init_projects " , " list " ) ;
for ( int i = 0 ; i < list . size ( ) ; i + + ) {
String name = list [ i ] . replace ( " / " , " :: " ) ;
set ( " projects/ " + name , list [ i ] ) ;
2021-06-09 10:47:32 +02:00
}
}
2017-10-28 15:40:55 +02:00
if ( p_extra_config - > has_section ( " presets " ) ) {
List < String > keys ;
p_extra_config - > get_section_keys ( " presets " , & keys ) ;
2021-07-24 15:46:25 +02:00
for ( const String & key : keys ) {
2017-10-28 15:40:55 +02:00
Variant val = p_extra_config - > get_value ( " presets " , key ) ;
set ( key , val ) ;
2021-06-09 10:47:32 +02:00
}
}
}
2017-10-28 15:40:55 +02:00
}
2021-05-27 10:22:36 +02:00
void EditorSettings : : _load_godot2_text_editor_theme ( ) {
// Godot 2 is only a dark theme; it doesn't have a light theme counterpart.
2019-07-08 20:03:06 +02:00
_initial_set ( " text_editor/highlighting/symbol_color " , Color ( 0.73 , 0.87 , 1.0 ) ) ;
_initial_set ( " text_editor/highlighting/keyword_color " , Color ( 1.0 , 1.0 , 0.7 ) ) ;
2021-04-08 16:12:22 +02:00
_initial_set ( " text_editor/highlighting/control_flow_keyword_color " , Color ( 1.0 , 0.85 , 0.7 ) ) ;
2019-07-08 20:03:06 +02:00
_initial_set ( " text_editor/highlighting/base_type_color " , Color ( 0.64 , 1.0 , 0.83 ) ) ;
_initial_set ( " text_editor/highlighting/engine_type_color " , Color ( 0.51 , 0.83 , 1.0 ) ) ;
2019-09-28 12:11:06 +02:00
_initial_set ( " text_editor/highlighting/user_type_color " , Color ( 0.42 , 0.67 , 0.93 ) ) ;
2019-07-08 20:03:06 +02:00
_initial_set ( " text_editor/highlighting/comment_color " , Color ( 0.4 , 0.4 , 0.4 ) ) ;
_initial_set ( " text_editor/highlighting/string_color " , Color ( 0.94 , 0.43 , 0.75 ) ) ;
2021-05-27 10:22:36 +02:00
_initial_set ( " text_editor/highlighting/background_color " , Color ( 0.13 , 0.12 , 0.15 ) ) ;
2019-07-08 20:03:06 +02:00
_initial_set ( " text_editor/highlighting/completion_background_color " , Color ( 0.17 , 0.16 , 0.2 ) ) ;
_initial_set ( " text_editor/highlighting/completion_selected_color " , Color ( 0.26 , 0.26 , 0.27 ) ) ;
_initial_set ( " text_editor/highlighting/completion_existing_color " , Color ( 0.13 , 0.87 , 0.87 , 0.87 ) ) ;
_initial_set ( " text_editor/highlighting/completion_scroll_color " , Color ( 1 , 1 , 1 ) ) ;
_initial_set ( " text_editor/highlighting/completion_font_color " , Color ( 0.67 , 0.67 , 0.67 ) ) ;
_initial_set ( " text_editor/highlighting/text_color " , Color ( 0.67 , 0.67 , 0.67 ) ) ;
_initial_set ( " text_editor/highlighting/line_number_color " , Color ( 0.67 , 0.67 , 0.67 , 0.4 ) ) ;
_initial_set ( " text_editor/highlighting/safe_line_number_color " , Color ( 0.67 , 0.78 , 0.67 , 0.6 ) ) ;
_initial_set ( " text_editor/highlighting/caret_color " , Color ( 0.67 , 0.67 , 0.67 ) ) ;
_initial_set ( " text_editor/highlighting/caret_background_color " , Color ( 0 , 0 , 0 ) ) ;
_initial_set ( " text_editor/highlighting/text_selected_color " , Color ( 0 , 0 , 0 ) ) ;
_initial_set ( " text_editor/highlighting/selection_color " , Color ( 0.41 , 0.61 , 0.91 , 0.35 ) ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/highlighting/brace_mismatch_color " , Color ( 1 , 0.2 , 0.2 ) ) ;
_initial_set ( " text_editor/highlighting/current_line_color " , Color ( 0.3 , 0.5 , 0.8 , 0.15 ) ) ;
_initial_set ( " text_editor/highlighting/line_length_guideline_color " , Color ( 0.3 , 0.5 , 0.8 , 0.1 ) ) ;
2018-06-10 16:30:49 +02:00
_initial_set ( " text_editor/highlighting/word_highlighted_color " , Color ( 0.8 , 0.9 , 0.9 , 0.15 ) ) ;
2019-07-08 20:03:06 +02:00
_initial_set ( " text_editor/highlighting/number_color " , Color ( 0.92 , 0.58 , 0.2 ) ) ;
_initial_set ( " text_editor/highlighting/function_color " , Color ( 0.4 , 0.64 , 0.81 ) ) ;
_initial_set ( " text_editor/highlighting/member_variable_color " , Color ( 0.9 , 0.31 , 0.35 ) ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/highlighting/mark_color " , Color ( 1.0 , 0.4 , 0.4 , 0.4 ) ) ;
2019-04-20 01:51:25 +02:00
_initial_set ( " text_editor/highlighting/bookmark_color " , Color ( 0.08 , 0.49 , 0.98 ) ) ;
2020-07-26 16:57:23 +02:00
_initial_set ( " text_editor/highlighting/breakpoint_color " , Color ( 0.9 , 0.29 , 0.3 ) ) ;
_initial_set ( " text_editor/highlighting/executing_line_color " , Color ( 0.98 , 0.89 , 0.27 ) ) ;
2017-12-04 22:48:20 +01:00
_initial_set ( " text_editor/highlighting/code_folding_color " , Color ( 0.8 , 0.8 , 0.8 , 0.8 ) ) ;
2017-10-28 15:40:55 +02:00
_initial_set ( " text_editor/highlighting/search_result_color " , Color ( 0.05 , 0.25 , 0.05 , 1 ) ) ;
2019-03-15 18:15:24 +01:00
_initial_set ( " text_editor/highlighting/search_result_border_color " , Color ( 0.41 , 0.61 , 0.91 , 0.38 ) ) ;
2017-10-28 15:40:55 +02:00
}
bool EditorSettings : : _save_text_editor_theme ( String p_file ) {
String theme_section = " color_theme " ;
Ref < ConfigFile > cf = memnew ( ConfigFile ) ; // hex is better?
2018-06-10 14:06:24 +02:00
List < String > keys ;
props . get_key_list ( & keys ) ;
keys . sort ( ) ;
2021-07-16 05:45:57 +02:00
for ( const String & key : keys ) {
2018-06-10 14:06:24 +02:00
if ( key . begins_with ( " text_editor/highlighting/ " ) & & key . find ( " color " ) > = 0 ) {
cf - > set_value ( theme_section , key . replace ( " text_editor/highlighting/ " , " " ) , ( ( Color ) props [ key ] . variant ) . to_html ( ) ) ;
}
}
2018-04-12 23:26:15 +02:00
2017-10-28 15:40:55 +02:00
Error err = cf - > save ( p_file ) ;
2019-06-26 15:08:25 +02:00
return err = = OK ;
2017-10-28 15:40:55 +02:00
}
2019-05-23 17:18:24 +02:00
bool EditorSettings : : _is_default_text_editor_theme ( String p_theme_name ) {
2021-05-27 10:22:36 +02:00
return p_theme_name = = " default " | | p_theme_name = = " godot 2 " | | p_theme_name = = " custom " ;
2019-05-23 17:18:24 +02:00
}
2017-10-28 15:40:55 +02:00
static Dictionary _get_builtin_script_templates ( ) {
Dictionary templates ;
2019-04-05 23:15:12 +02:00
// No Comments
2017-10-28 15:40:55 +02:00
templates [ " no_comments.gd " ] =
" extends %BASE% \n "
" \n "
2019-11-17 12:54:43 +01:00
" \n "
2019-04-05 23:15:12 +02:00
" func _ready()%VOID_RETURN%: \n "
2017-10-28 15:40:55 +02:00
" %TS%pass \n " ;
2019-04-05 23:15:12 +02:00
// Empty
2017-10-28 15:40:55 +02:00
templates [ " empty.gd " ] =
" extends %BASE% "
" \n "
" \n " ;
return templates ;
}
static void _create_script_templates ( const String & p_path ) {
Dictionary templates = _get_builtin_script_templates ( ) ;
List < Variant > keys ;
templates . get_key_list ( & keys ) ;
2021-06-09 10:47:32 +02:00
FileAccessRef file = FileAccess : : create ( FileAccess : : ACCESS_FILESYSTEM ) ;
DirAccessRef dir = DirAccess : : create ( DirAccess : : ACCESS_FILESYSTEM ) ;
2017-10-28 15:40:55 +02:00
dir - > change_dir ( p_path ) ;
for ( int i = 0 ; i < keys . size ( ) ; i + + ) {
if ( ! dir - > file_exists ( keys [ i ] ) ) {
Error err = file - > reopen ( p_path . plus_file ( ( String ) keys [ i ] ) , FileAccess : : WRITE ) ;
ERR_FAIL_COND ( err ! = OK ) ;
file - > store_string ( templates [ keys [ i ] ] ) ;
file - > close ( ) ;
}
}
}
// PUBLIC METHODS
EditorSettings * EditorSettings : : get_singleton ( ) {
return singleton . ptr ( ) ;
}
void EditorSettings : : create ( ) {
2021-06-09 10:47:32 +02:00
// IMPORTANT: create() *must* create a valid EditorSettings singleton,
// as the rest of the engine code will assume it. As such, it should never
// return (incl. via ERR_FAIL) without initializing the singleton member.
2020-05-14 16:41:43 +02:00
if ( singleton . ptr ( ) ) {
2021-06-09 10:47:32 +02:00
ERR_PRINT ( " Can't recreate EditorSettings as it already exists. " ) ;
return ;
2020-05-14 16:41:43 +02:00
}
2017-10-28 15:40:55 +02:00
2021-07-12 00:30:33 +02:00
GDREGISTER_CLASS ( EditorSettings ) ; // Otherwise it can't be unserialized.
2021-06-09 10:47:32 +02:00
String config_file_path ;
2017-10-28 15:40:55 +02:00
Ref < ConfigFile > extra_config = memnew ( ConfigFile ) ;
2021-06-09 10:47:32 +02:00
if ( ! EditorPaths : : get_singleton ( ) ) {
ERR_PRINT ( " Bug (please report): EditorPaths haven't been initialized, EditorSettings cannot be created properly. " ) ;
goto fail ;
}
2021-05-25 02:25:11 +02:00
if ( EditorPaths : : get_singleton ( ) - > is_self_contained ( ) ) {
Error err = extra_config - > load ( EditorPaths : : get_singleton ( ) - > get_self_contained_file ( ) ) ;
2019-08-07 12:54:30 +02:00
if ( err ! = OK ) {
2021-06-09 10:47:32 +02:00
ERR_PRINT ( " Can't load extra config from path: " + EditorPaths : : get_singleton ( ) - > get_self_contained_file ( ) ) ;
2019-08-07 12:54:30 +02:00
}
2017-10-28 15:40:55 +02:00
}
2021-05-25 02:25:11 +02:00
if ( EditorPaths : : get_singleton ( ) - > are_paths_valid ( ) ) {
2021-06-09 10:47:32 +02:00
_create_script_templates ( EditorPaths : : get_singleton ( ) - > get_config_dir ( ) . plus_file ( " script_templates " ) ) ;
2014-02-10 02:10:30 +01:00
2021-06-09 10:47:32 +02:00
// Validate editor config file.
2016-06-05 02:31:29 +02:00
2021-06-09 10:47:32 +02:00
DirAccessRef dir = DirAccess : : open ( EditorPaths : : get_singleton ( ) - > get_config_dir ( ) ) ;
2017-11-20 07:40:06 +01:00
String config_file_name = " editor_settings- " + itos ( VERSION_MAJOR ) + " .tres " ;
2021-05-25 02:25:11 +02:00
config_file_path = EditorPaths : : get_singleton ( ) - > get_config_dir ( ) . plus_file ( config_file_name ) ;
2017-01-11 22:38:00 +01:00
if ( ! dir - > file_exists ( config_file_name ) ) {
2017-01-05 23:41:36 +01:00
goto fail ;
2014-02-10 02:10:30 +01:00
}
2017-11-17 15:50:18 +01:00
singleton = ResourceLoader : : load ( config_file_path , " EditorSettings " ) ;
2016-06-05 02:31:29 +02:00
2014-02-10 02:10:30 +01:00
if ( singleton . is_null ( ) ) {
2021-06-09 10:47:32 +02:00
ERR_PRINT ( " Could not load editor settings from path: " + config_file_path ) ;
2014-02-10 02:10:30 +01:00
goto fail ;
}
2017-03-05 16:44:50 +01:00
singleton - > save_changed_setting = true ;
singleton - > config_file_path = config_file_path ;
2014-02-10 02:10:30 +01:00
2018-08-24 08:47:34 +02:00
print_verbose ( " EditorSettings: Load OK! " ) ;
2014-02-10 02:10:30 +01:00
2016-05-28 00:58:28 +02:00
singleton - > setup_language ( ) ;
2015-08-06 07:37:40 +02:00
singleton - > setup_network ( ) ;
2015-06-06 14:44:38 +02:00
singleton - > load_favorites ( ) ;
2016-04-12 16:45:31 +02:00
singleton - > list_text_editor_themes ( ) ;
2014-02-10 02:10:30 +01:00
return ;
}
2017-10-28 15:40:55 +02:00
fail :
// patch init projects
2021-05-25 02:25:11 +02:00
String exe_path = OS : : get_singleton ( ) - > get_executable_path ( ) . get_base_dir ( ) ;
2017-10-28 15:40:55 +02:00
if ( extra_config - > has_section ( " init_projects " ) ) {
Vector < String > list = extra_config - > get_value ( " init_projects " , " list " ) ;
for ( int i = 0 ; i < list . size ( ) ; i + + ) {
2019-06-16 14:31:57 +02:00
list . write [ i ] = exe_path . plus_file ( list [ i ] ) ;
2021-06-09 10:47:32 +02:00
}
2017-10-28 15:40:55 +02:00
extra_config - > set_value ( " init_projects " , " list " , list ) ;
2021-06-09 10:47:32 +02:00
}
2017-01-05 23:41:36 +01:00
2017-10-28 15:40:55 +02:00
singleton = Ref < EditorSettings > ( memnew ( EditorSettings ) ) ;
singleton - > save_changed_setting = true ;
singleton - > config_file_path = config_file_path ;
singleton - > _load_defaults ( extra_config ) ;
singleton - > setup_language ( ) ;
singleton - > setup_network ( ) ;
singleton - > list_text_editor_themes ( ) ;
}
2017-01-05 23:41:36 +01:00
2017-10-28 15:40:55 +02:00
void EditorSettings : : setup_language ( ) {
2021-08-08 17:07:57 +02:00
TranslationServer : : get_singleton ( ) - > set_editor_pseudolocalization ( get ( " interface/editor/enable_debugging_pseudolocalization " ) ) ;
2017-10-28 15:40:55 +02:00
String lang = get ( " interface/editor/editor_language " ) ;
2020-05-14 16:41:43 +02:00
if ( lang = = " en " ) {
2020-03-18 18:34:36 +01:00
return ; // Default, nothing to do.
2020-05-14 16:41:43 +02:00
}
2020-03-18 18:34:36 +01:00
// Load editor translation for configured/detected locale.
2018-01-06 13:17:12 +01:00
EditorTranslationList * etl = _editor_translations ;
while ( etl - > data ) {
if ( etl - > lang = = lang ) {
Vector < uint8_t > data ;
data . resize ( etl - > uncomp_size ) ;
Compression : : decompress ( data . ptrw ( ) , etl - > uncomp_size , etl - > data , etl - > comp_size , Compression : : MODE_DEFLATE ) ;
FileAccessMemory * fa = memnew ( FileAccessMemory ) ;
fa - > open_custom ( data . ptr ( ) , data . size ( ) ) ;
2020-03-18 18:34:36 +01:00
Ref < Translation > tr = TranslationLoaderPO : : load_translation ( fa ) ;
2018-01-06 13:17:12 +01:00
if ( tr . is_valid ( ) ) {
tr - > set_locale ( etl - > lang ) ;
TranslationServer : : get_singleton ( ) - > set_tool_translation ( tr ) ;
break ;
}
2017-10-28 15:40:55 +02:00
}
2018-01-06 13:17:12 +01:00
etl + + ;
2017-10-28 15:40:55 +02:00
}
2020-03-18 18:34:36 +01:00
// Load class reference translation.
DocTranslationList * dtl = _doc_translations ;
while ( dtl - > data ) {
if ( dtl - > lang = = lang ) {
Vector < uint8_t > data ;
data . resize ( dtl - > uncomp_size ) ;
Compression : : decompress ( data . ptrw ( ) , dtl - > uncomp_size , dtl - > data , dtl - > comp_size , Compression : : MODE_DEFLATE ) ;
FileAccessMemory * fa = memnew ( FileAccessMemory ) ;
fa - > open_custom ( data . ptr ( ) , data . size ( ) ) ;
Ref < Translation > tr = TranslationLoaderPO : : load_translation ( fa ) ;
if ( tr . is_valid ( ) ) {
tr - > set_locale ( dtl - > lang ) ;
TranslationServer : : get_singleton ( ) - > set_doc_translation ( tr ) ;
break ;
}
}
dtl + + ;
}
2017-10-28 15:40:55 +02:00
}
2017-09-19 02:30:48 +02:00
2017-10-28 15:40:55 +02:00
void EditorSettings : : setup_network ( ) {
2021-05-06 02:48:18 +02:00
List < IPAddress > local_ip ;
2017-10-28 15:40:55 +02:00
IP : : get_singleton ( ) - > get_local_addresses ( & local_ip ) ;
String hint ;
String current = has_setting ( " network/debug/remote_host " ) ? get ( " network/debug/remote_host " ) : " " ;
2019-08-21 17:05:06 +02:00
String selected = " 127.0.0.1 " ;
2017-01-05 23:41:36 +01:00
2019-08-21 17:05:06 +02:00
// Check that current remote_host is a valid interface address and populate hints.
2021-07-24 15:46:25 +02:00
for ( const IPAddress & ip : local_ip ) {
2017-10-28 15:40:55 +02:00
// link-local IPv6 addresses don't work, skipping them
2021-07-16 05:45:57 +02:00
if ( String ( ip ) . begins_with ( " fe80:0:0:0: " ) ) { // fe80::/64
2017-10-28 15:40:55 +02:00
continue ;
2020-05-14 16:41:43 +02:00
}
2019-03-31 16:57:23 +02:00
// Same goes for IPv4 link-local (APIPA) addresses.
2021-07-16 05:45:57 +02:00
if ( String ( ip ) . begins_with ( " 169.254. " ) ) { // 169.254.0.0/16
2019-03-31 16:57:23 +02:00
continue ;
2020-05-14 16:41:43 +02:00
}
2019-08-21 17:05:06 +02:00
// Select current IP (found)
2020-05-14 16:41:43 +02:00
if ( ip = = current ) {
2019-08-21 17:05:06 +02:00
selected = ip ;
2020-05-14 16:41:43 +02:00
}
if ( hint ! = " " ) {
2017-10-28 15:40:55 +02:00
hint + = " , " ;
2020-05-14 16:41:43 +02:00
}
2017-10-28 15:40:55 +02:00
hint + = ip ;
}
2017-05-01 20:57:35 +02:00
2019-08-21 17:05:06 +02:00
// Add hints with valid IP addresses to remote_host property.
2017-10-28 15:40:55 +02:00
add_property_hint ( PropertyInfo ( Variant : : STRING , " network/debug/remote_host " , PROPERTY_HINT_ENUM , hint ) ) ;
2019-08-21 17:05:06 +02:00
// Fix potentially invalid remote_host due to network change.
set ( " network/debug/remote_host " , selected ) ;
2017-10-28 15:40:55 +02:00
}
2017-04-25 14:18:08 +02:00
2017-10-28 15:40:55 +02:00
void EditorSettings : : save ( ) {
//_THREAD_SAFE_METHOD_
2014-02-10 02:10:30 +01:00
2020-05-14 16:41:43 +02:00
if ( ! singleton . ptr ( ) ) {
2017-10-28 15:40:55 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
if ( singleton - > config_file_path = = " " ) {
ERR_PRINT ( " Cannot save EditorSettings config, no valid path " ) ;
return ;
}
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
Error err = ResourceSaver : : save ( singleton - > config_file_path , singleton ) ;
2016-08-16 18:25:42 +02:00
2017-10-28 15:40:55 +02:00
if ( err ! = OK ) {
2019-11-06 17:03:04 +01:00
ERR_PRINT ( " Error saving editor settings to " + singleton - > config_file_path ) ;
2018-08-24 08:47:34 +02:00
} else {
print_verbose ( " EditorSettings: Save OK! " ) ;
2017-10-28 15:40:55 +02:00
}
}
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
void EditorSettings : : destroy ( ) {
2020-05-14 16:41:43 +02:00
if ( ! singleton . ptr ( ) ) {
2017-10-28 15:40:55 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2017-10-28 15:40:55 +02:00
save ( ) ;
singleton = Ref < EditorSettings > ( ) ;
}
2014-02-10 02:10:30 +01:00
2017-10-28 15:40:55 +02:00
void EditorSettings : : set_optimize_save ( bool p_optimize ) {
optimize_save = p_optimize ;
}
2016-05-27 19:18:40 +02:00
2017-10-28 15:40:55 +02:00
// Properties
2016-02-22 00:15:47 +01:00
2017-10-28 15:40:55 +02:00
void EditorSettings : : set_setting ( const String & p_setting , const Variant & p_value ) {
_THREAD_SAFE_METHOD_
set ( p_setting , p_value ) ;
}
2016-02-27 16:11:40 +01:00
2017-10-28 15:40:55 +02:00
Variant EditorSettings : : get_setting ( const String & p_setting ) const {
_THREAD_SAFE_METHOD_
return get ( p_setting ) ;
}
2016-02-27 16:11:40 +01:00
2017-10-31 15:24:35 +01:00
bool EditorSettings : : has_setting ( const String & p_setting ) const {
2017-10-28 15:40:55 +02:00
_THREAD_SAFE_METHOD_
2016-02-27 16:11:40 +01:00
2017-10-31 15:24:35 +01:00
return props . has ( p_setting ) ;
2017-10-28 15:40:55 +02:00
}
2016-02-27 16:11:40 +01:00
2017-10-31 15:24:35 +01:00
void EditorSettings : : erase ( const String & p_setting ) {
2017-10-28 15:40:55 +02:00
_THREAD_SAFE_METHOD_
2017-10-31 15:24:35 +01:00
props . erase ( p_setting ) ;
2016-04-12 16:45:31 +02:00
}
2017-10-31 15:24:35 +01:00
void EditorSettings : : raise_order ( const String & p_setting ) {
2017-10-28 15:40:55 +02:00
_THREAD_SAFE_METHOD_
2017-10-31 15:24:35 +01:00
ERR_FAIL_COND ( ! props . has ( p_setting ) ) ;
props [ p_setting ] . order = + + last_order ;
2014-02-10 02:10:30 +01:00
}
2018-07-19 23:58:15 +02:00
void EditorSettings : : set_restart_if_changed ( const StringName & p_setting , bool p_restart ) {
_THREAD_SAFE_METHOD_
2020-05-14 16:41:43 +02:00
if ( ! props . has ( p_setting ) ) {
2018-07-19 23:58:15 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-07-19 23:58:15 +02:00
props [ p_setting ] . restart_if_changed = p_restart ;
}
2018-01-09 16:52:46 +01:00
void EditorSettings : : set_initial_value ( const StringName & p_setting , const Variant & p_value , bool p_update_current ) {
2017-11-30 04:11:53 +01:00
_THREAD_SAFE_METHOD_
2020-05-14 16:41:43 +02:00
if ( ! props . has ( p_setting ) ) {
2017-11-17 21:22:27 +01:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-01-07 20:39:38 +01:00
props [ p_setting ] . initial = p_value ;
props [ p_setting ] . has_default_value = true ;
2018-01-09 16:52:46 +01:00
if ( p_update_current ) {
2018-01-07 20:39:38 +01:00
set ( p_setting , p_value ) ;
}
2017-10-28 15:40:55 +02:00
}
2014-02-10 02:10:30 +01:00
2018-07-19 23:58:15 +02:00
Variant _EDITOR_DEF ( const String & p_setting , const Variant & p_default , bool p_restart_if_changed ) {
2017-10-28 23:25:28 +02:00
Variant ret = p_default ;
2018-07-19 23:58:15 +02:00
if ( EditorSettings : : get_singleton ( ) - > has_setting ( p_setting ) ) {
2017-10-28 23:25:28 +02:00
ret = EditorSettings : : get_singleton ( ) - > get ( p_setting ) ;
2018-07-19 23:58:15 +02:00
} else {
2017-11-30 04:11:53 +01:00
EditorSettings : : get_singleton ( ) - > set_manually ( p_setting , p_default ) ;
2018-07-19 23:58:15 +02:00
EditorSettings : : get_singleton ( ) - > set_restart_if_changed ( p_setting , p_restart_if_changed ) ;
}
2017-11-30 04:11:53 +01:00
2018-07-19 23:58:15 +02:00
if ( ! EditorSettings : : get_singleton ( ) - > has_default_value ( p_setting ) ) {
2017-11-20 18:34:13 +01:00
EditorSettings : : get_singleton ( ) - > set_initial_value ( p_setting , p_default ) ;
2018-07-19 23:58:15 +02:00
}
2014-02-10 02:10:30 +01:00
2017-10-28 23:25:28 +02:00
return ret ;
2017-10-28 15:40:55 +02:00
}
2014-02-10 02:10:30 +01:00
2017-10-31 15:24:35 +01:00
Variant _EDITOR_GET ( const String & p_setting ) {
2019-06-11 14:49:34 +02:00
ERR_FAIL_COND_V ( ! EditorSettings : : get_singleton ( ) - > has_setting ( p_setting ) , Variant ( ) ) ;
2017-10-31 15:24:35 +01:00
return EditorSettings : : get_singleton ( ) - > get ( p_setting ) ;
2014-02-10 02:10:30 +01:00
}
2017-10-31 15:24:35 +01:00
bool EditorSettings : : property_can_revert ( const String & p_setting ) {
2020-05-14 16:41:43 +02:00
if ( ! props . has ( p_setting ) ) {
2017-10-28 15:40:55 +02:00
return false ;
2020-05-14 16:41:43 +02:00
}
2016-08-16 22:10:53 +02:00
2020-05-14 16:41:43 +02:00
if ( ! props [ p_setting ] . has_default_value ) {
2017-11-30 04:11:53 +01:00
return false ;
2020-05-14 16:41:43 +02:00
}
2017-11-30 04:11:53 +01:00
2017-10-31 15:24:35 +01:00
return props [ p_setting ] . initial ! = props [ p_setting ] . variant ;
2017-10-28 15:40:55 +02:00
}
2016-08-16 22:10:53 +02:00
2017-10-31 15:24:35 +01:00
Variant EditorSettings : : property_get_revert ( const String & p_setting ) {
2020-05-14 16:41:43 +02:00
if ( ! props . has ( p_setting ) | | ! props [ p_setting ] . has_default_value ) {
2017-10-28 15:40:55 +02:00
return Variant ( ) ;
2020-05-14 16:41:43 +02:00
}
2017-10-28 15:40:55 +02:00
2017-10-31 15:24:35 +01:00
return props [ p_setting ] . initial ;
2016-08-16 22:10:53 +02:00
}
2017-03-05 16:44:50 +01:00
void EditorSettings : : add_property_hint ( const PropertyInfo & p_hint ) {
2014-02-10 02:10:30 +01:00
_THREAD_SAFE_METHOD_
2017-03-05 16:44:50 +01:00
hints [ p_hint . name ] = p_hint ;
2014-02-10 02:10:30 +01:00
}
2021-06-09 10:47:32 +02:00
// Editor data and config directories
// EditorPaths::create() is responsible for the creation of these directories.
Add initial support for the XDG Base Directory spec
Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html
(latest as of this commit).
Three virtual methods are added to OS for the various XDG paths we will use:
- OS::get_data_path gives XDG_DATA_HOME, or if missing:
~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_config_path gives XDG_CONFIG_HOME, or if missing:
~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_cache_path gives XDG_CACHE_HOME, or if missing:
~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows
So for Windows there are no changes, for Linux we follow the full split spec
and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot.
Support for system-wide installation of templates on Unix was removed for now,
as it's a bit hackish and I don't think anyone uses it.
user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by
default, but when using the application/config/use_shared_user_dir option
it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame.
For now everything still goes in EditorSettings::get_settings_dir(), but
this will be changed in a later commit to make use of the new splitting
where relevant.
Part of #3513.
2017-11-17 17:11:41 +01:00
String EditorSettings : : get_templates_dir ( ) const {
2021-05-25 02:25:11 +02:00
return EditorPaths : : get_singleton ( ) - > get_data_dir ( ) . plus_file ( " templates " ) ;
Add initial support for the XDG Base Directory spec
Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html
(latest as of this commit).
Three virtual methods are added to OS for the various XDG paths we will use:
- OS::get_data_path gives XDG_DATA_HOME, or if missing:
~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_config_path gives XDG_CONFIG_HOME, or if missing:
~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_cache_path gives XDG_CACHE_HOME, or if missing:
~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows
So for Windows there are no changes, for Linux we follow the full split spec
and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot.
Support for system-wide installation of templates on Unix was removed for now,
as it's a bit hackish and I don't think anyone uses it.
user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by
default, but when using the application/config/use_shared_user_dir option
it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame.
For now everything still goes in EditorSettings::get_settings_dir(), but
this will be changed in a later commit to make use of the new splitting
where relevant.
Part of #3513.
2017-11-17 17:11:41 +01:00
}
2017-11-17 15:50:18 +01:00
String EditorSettings : : get_project_settings_dir ( ) const {
2021-06-09 10:47:32 +02:00
return EditorPaths : : get_singleton ( ) - > get_project_data_dir ( ) . plus_file ( " editor " ) ;
2017-10-28 15:40:55 +02:00
}
Add initial support for the XDG Base Directory spec
Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html
(latest as of this commit).
Three virtual methods are added to OS for the various XDG paths we will use:
- OS::get_data_path gives XDG_DATA_HOME, or if missing:
~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_config_path gives XDG_CONFIG_HOME, or if missing:
~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_cache_path gives XDG_CACHE_HOME, or if missing:
~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows
So for Windows there are no changes, for Linux we follow the full split spec
and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot.
Support for system-wide installation of templates on Unix was removed for now,
as it's a bit hackish and I don't think anyone uses it.
user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by
default, but when using the application/config/use_shared_user_dir option
it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame.
For now everything still goes in EditorSettings::get_settings_dir(), but
this will be changed in a later commit to make use of the new splitting
where relevant.
Part of #3513.
2017-11-17 17:11:41 +01:00
String EditorSettings : : get_text_editor_themes_dir ( ) const {
2021-06-03 17:24:07 +02:00
return EditorPaths : : get_singleton ( ) - > get_config_dir ( ) . plus_file ( " text_editor_themes " ) ;
Add initial support for the XDG Base Directory spec
Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html
(latest as of this commit).
Three virtual methods are added to OS for the various XDG paths we will use:
- OS::get_data_path gives XDG_DATA_HOME, or if missing:
~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_config_path gives XDG_CONFIG_HOME, or if missing:
~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_cache_path gives XDG_CACHE_HOME, or if missing:
~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows
So for Windows there are no changes, for Linux we follow the full split spec
and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot.
Support for system-wide installation of templates on Unix was removed for now,
as it's a bit hackish and I don't think anyone uses it.
user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by
default, but when using the application/config/use_shared_user_dir option
it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame.
For now everything still goes in EditorSettings::get_settings_dir(), but
this will be changed in a later commit to make use of the new splitting
where relevant.
Part of #3513.
2017-11-17 17:11:41 +01:00
}
2017-10-28 15:40:55 +02:00
Add initial support for the XDG Base Directory spec
Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html
(latest as of this commit).
Three virtual methods are added to OS for the various XDG paths we will use:
- OS::get_data_path gives XDG_DATA_HOME, or if missing:
~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_config_path gives XDG_CONFIG_HOME, or if missing:
~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_cache_path gives XDG_CACHE_HOME, or if missing:
~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows
So for Windows there are no changes, for Linux we follow the full split spec
and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot.
Support for system-wide installation of templates on Unix was removed for now,
as it's a bit hackish and I don't think anyone uses it.
user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by
default, but when using the application/config/use_shared_user_dir option
it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame.
For now everything still goes in EditorSettings::get_settings_dir(), but
this will be changed in a later commit to make use of the new splitting
where relevant.
Part of #3513.
2017-11-17 17:11:41 +01:00
String EditorSettings : : get_script_templates_dir ( ) const {
2021-06-03 17:24:07 +02:00
return EditorPaths : : get_singleton ( ) - > get_config_dir ( ) . plus_file ( " script_templates " ) ;
2017-10-28 15:40:55 +02:00
}
2019-08-22 17:59:43 +02:00
String EditorSettings : : get_project_script_templates_dir ( ) const {
2021-02-17 17:44:49 +01:00
return ProjectSettings : : get_singleton ( ) - > get ( " editor/script/templates_search_path " ) ;
2019-08-22 17:59:43 +02:00
}
2019-04-09 00:18:03 +02:00
String EditorSettings : : get_feature_profiles_dir ( ) const {
2021-06-03 17:24:07 +02:00
return EditorPaths : : get_singleton ( ) - > get_config_dir ( ) . plus_file ( " feature_profiles " ) ;
2019-04-09 00:18:03 +02:00
}
Add initial support for the XDG Base Directory spec
Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html
(latest as of this commit).
Three virtual methods are added to OS for the various XDG paths we will use:
- OS::get_data_path gives XDG_DATA_HOME, or if missing:
~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_config_path gives XDG_CONFIG_HOME, or if missing:
~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows
- OS::get_cache_path gives XDG_CACHE_HOME, or if missing:
~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows
So for Windows there are no changes, for Linux we follow the full split spec
and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot.
Support for system-wide installation of templates on Unix was removed for now,
as it's a bit hackish and I don't think anyone uses it.
user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by
default, but when using the application/config/use_shared_user_dir option
it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame.
For now everything still goes in EditorSettings::get_settings_dir(), but
this will be changed in a later commit to make use of the new splitting
where relevant.
Part of #3513.
2017-11-17 17:11:41 +01:00
// Metadata
2017-10-28 15:40:55 +02:00
void EditorSettings : : set_project_metadata ( const String & p_section , const String & p_key , Variant p_data ) {
Ref < ConfigFile > cf = memnew ( ConfigFile ) ;
2017-11-17 15:50:18 +01:00
String path = get_project_settings_dir ( ) . plus_file ( " project_metadata.cfg " ) ;
2019-08-07 12:54:30 +02:00
Error err ;
err = cf - > load ( path ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( err ! = OK & & err ! = ERR_FILE_NOT_FOUND , " Cannot load editor settings from file ' " + path + " '. " ) ;
2017-10-28 15:40:55 +02:00
cf - > set_value ( p_section , p_key , p_data ) ;
2019-08-07 12:54:30 +02:00
err = cf - > save ( path ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( err ! = OK , " Cannot save editor settings to file ' " + path + " '. " ) ;
2017-10-28 15:40:55 +02:00
}
2018-05-16 17:23:20 +02:00
Variant EditorSettings : : get_project_metadata ( const String & p_section , const String & p_key , Variant p_default ) const {
2017-10-28 15:40:55 +02:00
Ref < ConfigFile > cf = memnew ( ConfigFile ) ;
2017-11-17 15:50:18 +01:00
String path = get_project_settings_dir ( ) . plus_file ( " project_metadata.cfg " ) ;
2017-10-28 15:40:55 +02:00
Error err = cf - > load ( path ) ;
if ( err ! = OK ) {
return p_default ;
}
return cf - > get_value ( p_section , p_key , p_default ) ;
}
2018-09-18 14:02:59 +02:00
void EditorSettings : : set_favorites ( const Vector < String > & p_favorites ) {
favorites = p_favorites ;
FileAccess * f = FileAccess : : open ( get_project_settings_dir ( ) . plus_file ( " favorites " ) , FileAccess : : WRITE ) ;
2015-06-06 14:44:38 +02:00
if ( f ) {
2020-05-14 16:41:43 +02:00
for ( int i = 0 ; i < favorites . size ( ) ; i + + ) {
2018-09-18 14:02:59 +02:00
f - > store_line ( favorites [ i ] ) ;
2020-05-14 16:41:43 +02:00
}
2015-06-06 14:44:38 +02:00
memdelete ( f ) ;
}
}
2018-09-18 14:02:59 +02:00
Vector < String > EditorSettings : : get_favorites ( ) const {
return favorites ;
2015-06-06 14:44:38 +02:00
}
2017-08-12 18:52:50 +02:00
void EditorSettings : : set_recent_dirs ( const Vector < String > & p_recent_dirs ) {
recent_dirs = p_recent_dirs ;
2017-11-17 15:50:18 +01:00
FileAccess * f = FileAccess : : open ( get_project_settings_dir ( ) . plus_file ( " recent_dirs " ) , FileAccess : : WRITE ) ;
2015-06-06 14:44:38 +02:00
if ( f ) {
2020-05-14 16:41:43 +02:00
for ( int i = 0 ; i < recent_dirs . size ( ) ; i + + ) {
2015-06-06 14:44:38 +02:00
f - > store_line ( recent_dirs [ i ] ) ;
2020-05-14 16:41:43 +02:00
}
2015-06-06 14:44:38 +02:00
memdelete ( f ) ;
}
}
Vector < String > EditorSettings : : get_recent_dirs ( ) const {
return recent_dirs ;
}
void EditorSettings : : load_favorites ( ) {
2018-09-18 14:02:59 +02:00
FileAccess * f = FileAccess : : open ( get_project_settings_dir ( ) . plus_file ( " favorites " ) , FileAccess : : READ ) ;
2015-06-06 14:44:38 +02:00
if ( f ) {
String line = f - > get_line ( ) . strip_edges ( ) ;
2017-03-05 16:44:50 +01:00
while ( line ! = " " ) {
2018-09-18 14:02:59 +02:00
favorites . push_back ( line ) ;
2015-06-06 14:44:38 +02:00
line = f - > get_line ( ) . strip_edges ( ) ;
}
memdelete ( f ) ;
}
2017-11-17 15:50:18 +01:00
f = FileAccess : : open ( get_project_settings_dir ( ) . plus_file ( " recent_dirs " ) , FileAccess : : READ ) ;
2015-06-06 14:44:38 +02:00
if ( f ) {
String line = f - > get_line ( ) . strip_edges ( ) ;
2017-03-05 16:44:50 +01:00
while ( line ! = " " ) {
2015-06-06 14:44:38 +02:00
recent_dirs . push_back ( line ) ;
line = f - > get_line ( ) . strip_edges ( ) ;
}
memdelete ( f ) ;
}
}
2018-06-10 16:30:49 +02:00
bool EditorSettings : : is_dark_theme ( ) {
int AUTO_COLOR = 0 ;
int LIGHT_COLOR = 2 ;
Color base_color = get ( " interface/theme/base_color " ) ;
int icon_font_color_setting = get ( " interface/theme/icon_and_font_color " ) ;
return ( icon_font_color_setting = = AUTO_COLOR & & ( ( base_color . r + base_color . g + base_color . b ) / 3.0 ) < 0.5 ) | | icon_font_color_setting = = LIGHT_COLOR ;
}
2016-04-12 16:45:31 +02:00
void EditorSettings : : list_text_editor_themes ( ) {
2021-05-27 10:22:36 +02:00
String themes = " Default,Godot 2,Custom " ;
2018-09-22 10:02:20 +02:00
2017-11-17 21:48:24 +01:00
DirAccess * d = DirAccess : : open ( get_text_editor_themes_dir ( ) ) ;
2016-04-12 16:45:31 +02:00
if ( d ) {
2018-09-22 10:02:20 +02:00
List < String > custom_themes ;
2016-04-12 16:45:31 +02:00
d - > list_dir_begin ( ) ;
String file = d - > get_next ( ) ;
2017-03-05 16:44:50 +01:00
while ( file ! = String ( ) ) {
2019-05-23 17:18:24 +02:00
if ( file . get_extension ( ) = = " tet " & & ! _is_default_text_editor_theme ( file . get_basename ( ) . to_lower ( ) ) ) {
2018-09-22 10:02:20 +02:00
custom_themes . push_back ( file . get_basename ( ) ) ;
2016-04-12 16:45:31 +02:00
}
file = d - > get_next ( ) ;
}
d - > list_dir_end ( ) ;
memdelete ( d ) ;
2018-09-22 10:02:20 +02:00
custom_themes . sort ( ) ;
2021-07-24 15:46:25 +02:00
for ( const String & E : custom_themes ) {
2021-07-16 05:45:57 +02:00
themes + = " , " + E ;
2018-09-22 10:02:20 +02:00
}
2016-04-12 16:45:31 +02:00
}
2017-03-05 16:44:50 +01:00
add_property_hint ( PropertyInfo ( Variant : : STRING , " text_editor/theme/color_theme " , PROPERTY_HINT_ENUM , themes ) ) ;
2016-04-12 16:45:31 +02:00
}
void EditorSettings : : load_text_editor_theme ( ) {
2019-05-23 17:18:24 +02:00
String p_file = get ( " text_editor/theme/color_theme " ) ;
if ( _is_default_text_editor_theme ( p_file . get_file ( ) . to_lower ( ) ) ) {
2021-05-27 10:22:36 +02:00
if ( p_file = = " Godot 2 " ) {
_load_godot2_text_editor_theme ( ) ;
2018-01-06 12:40:43 +01:00
}
return ; // sorry for "Settings changed" console spam
2016-04-12 16:45:31 +02:00
}
2019-05-23 17:18:24 +02:00
String theme_path = get_text_editor_themes_dir ( ) . plus_file ( p_file + " .tet " ) ;
2016-04-12 16:45:31 +02:00
2017-03-05 16:44:50 +01:00
Ref < ConfigFile > cf = memnew ( ConfigFile ) ;
2016-04-12 16:45:31 +02:00
Error err = cf - > load ( theme_path ) ;
if ( err ! = OK ) {
return ;
}
List < String > keys ;
cf - > get_section_keys ( " color_theme " , & keys ) ;
2021-07-24 15:46:25 +02:00
for ( const String & key : keys ) {
2016-04-12 16:45:31 +02:00
String val = cf - > get_value ( " color_theme " , key ) ;
// don't load if it's not already there!
2017-10-05 20:34:34 +02:00
if ( has_setting ( " text_editor/highlighting/ " + key ) ) {
2016-04-12 16:45:31 +02:00
// make sure it is actually a color
if ( val . is_valid_html_color ( ) & & key . find ( " color " ) > = 0 ) {
2017-03-05 16:44:50 +01:00
props [ " text_editor/highlighting/ " + key ] . variant = Color : : html ( val ) ; // change manually to prevent "Settings changed" console spam
2016-04-12 16:45:31 +02:00
}
}
}
2021-07-17 23:22:52 +02:00
emit_signal ( SNAME ( " settings_changed " ) ) ;
2016-04-12 16:45:31 +02:00
// if it doesn't load just use what is currently loaded
}
bool EditorSettings : : import_text_editor_theme ( String p_file ) {
if ( ! p_file . ends_with ( " .tet " ) ) {
return false ;
} else {
if ( p_file . get_file ( ) . to_lower ( ) = = " default.tet " ) {
return false ;
}
2017-11-17 21:48:24 +01:00
DirAccess * d = DirAccess : : open ( get_text_editor_themes_dir ( ) ) ;
2016-04-12 16:45:31 +02:00
if ( d ) {
2017-11-17 21:48:24 +01:00
d - > copy ( p_file , get_text_editor_themes_dir ( ) . plus_file ( p_file . get_file ( ) ) ) ;
2016-04-12 16:45:31 +02:00
memdelete ( d ) ;
return true ;
}
}
return false ;
}
bool EditorSettings : : save_text_editor_theme ( ) {
2017-01-05 23:41:36 +01:00
String p_file = get ( " text_editor/theme/color_theme " ) ;
2016-04-12 16:45:31 +02:00
2019-05-23 17:18:24 +02:00
if ( _is_default_text_editor_theme ( p_file . get_file ( ) . to_lower ( ) ) ) {
2016-04-12 16:45:31 +02:00
return false ;
}
2017-11-17 21:48:24 +01:00
String theme_path = get_text_editor_themes_dir ( ) . plus_file ( p_file + " .tet " ) ;
2016-04-12 16:45:31 +02:00
return _save_text_editor_theme ( theme_path ) ;
}
bool EditorSettings : : save_text_editor_theme_as ( String p_file ) {
if ( ! p_file . ends_with ( " .tet " ) ) {
p_file + = " .tet " ;
}
2019-05-23 17:18:24 +02:00
if ( _is_default_text_editor_theme ( p_file . get_file ( ) . to_lower ( ) . trim_suffix ( " .tet " ) ) ) {
2016-04-12 16:45:31 +02:00
return false ;
}
2017-03-05 16:44:50 +01:00
if ( _save_text_editor_theme ( p_file ) ) {
2016-04-12 16:45:31 +02:00
// switch to theme is saved in the theme directory
list_text_editor_themes ( ) ;
String theme_name = p_file . substr ( 0 , p_file . length ( ) - 4 ) . get_file ( ) ;
2017-11-17 21:48:24 +01:00
if ( p_file . get_base_dir ( ) = = get_text_editor_themes_dir ( ) ) {
2017-09-25 05:26:41 +02:00
_initial_set ( " text_editor/theme/color_theme " , theme_name ) ;
2016-04-12 16:45:31 +02:00
load_text_editor_theme ( ) ;
}
return true ;
}
return false ;
}
2019-05-23 17:18:24 +02:00
bool EditorSettings : : is_default_text_editor_theme ( ) {
String p_file = get ( " text_editor/theme/color_theme " ) ;
return _is_default_text_editor_theme ( p_file . get_file ( ) . to_lower ( ) ) ;
}
2019-08-22 17:59:43 +02:00
Vector < String > EditorSettings : : get_script_templates ( const String & p_extension , const String & p_custom_path ) {
2017-06-13 22:03:08 +02:00
Vector < String > templates ;
2019-08-22 17:59:43 +02:00
String template_dir = get_script_templates_dir ( ) ;
2020-12-15 13:04:21 +01:00
if ( ! p_custom_path . is_empty ( ) ) {
2019-08-22 17:59:43 +02:00
template_dir = p_custom_path ;
}
DirAccess * d = DirAccess : : open ( template_dir ) ;
2017-06-13 22:03:08 +02:00
if ( d ) {
d - > list_dir_begin ( ) ;
String file = d - > get_next ( ) ;
while ( file ! = String ( ) ) {
if ( file . get_extension ( ) = = p_extension ) {
templates . push_back ( file . get_basename ( ) ) ;
}
file = d - > get_next ( ) ;
}
d - > list_dir_end ( ) ;
memdelete ( d ) ;
}
return templates ;
}
2017-11-17 21:48:24 +01:00
String EditorSettings : : get_editor_layouts_config ( ) const {
2021-06-03 17:24:07 +02:00
return EditorPaths : : get_singleton ( ) - > get_config_dir ( ) . plus_file ( " editor_layouts.cfg " ) ;
2017-11-17 21:48:24 +01:00
}
2021-06-16 14:36:09 +02:00
float EditorSettings : : get_auto_display_scale ( ) const {
# ifdef OSX_ENABLED
return DisplayServer : : get_singleton ( ) - > screen_get_max_scale ( ) ;
# else
const int screen = DisplayServer : : get_singleton ( ) - > window_get_current_screen ( ) ;
Fix various typos with codespell
Found via `codespell -q 3 -S ./thirdparty,*.po,./DONORS.md -L ackward,ang,ans,ba,beng,cas,childs,childrens,dof,doubleclick,fave,findn,hist,inout,leapyear,lod,nd,numer,ois,ony,paket,seeked,sinc,switchs,te,uint`
2021-07-07 17:17:32 +02:00
// Use the smallest dimension to use a correct display scale on portrait displays.
2021-06-16 14:36:09 +02:00
const int smallest_dimension = MIN ( DisplayServer : : get_singleton ( ) - > screen_get_size ( screen ) . x , DisplayServer : : get_singleton ( ) - > screen_get_size ( screen ) . y ) ;
if ( DisplayServer : : get_singleton ( ) - > screen_get_dpi ( screen ) > = 192 & & smallest_dimension > = 1400 ) {
// hiDPI display.
return 2.0 ;
} else if ( smallest_dimension > = 1700 ) {
// Likely a hiDPI display, but we aren't certain due to the returned DPI.
// Use an intermediate scale to handle this situation.
return 1.5 ;
} else if ( smallest_dimension < = 800 ) {
// Small loDPI display. Use a smaller display scale so that editor elements fit more easily.
// Icons won't look great, but this is better than having editor elements overflow from its window.
return 0.75 ;
}
return 1.0 ;
# endif
}
2017-10-28 15:40:55 +02:00
// Shortcuts
2014-02-10 02:10:30 +01:00
2020-09-09 21:53:24 +02:00
void EditorSettings : : add_shortcut ( const String & p_name , Ref < Shortcut > & p_shortcut ) {
2017-03-05 16:44:50 +01:00
shortcuts [ p_name ] = p_shortcut ;
2016-06-05 02:31:29 +02:00
}
2017-05-20 17:38:03 +02:00
bool EditorSettings : : is_shortcut ( const String & p_name , const Ref < InputEvent > & p_event ) const {
2020-09-09 21:53:24 +02:00
const Map < String , Ref < Shortcut > > : : Element * E = shortcuts . find ( p_name ) ;
2019-08-15 04:57:49 +02:00
ERR_FAIL_COND_V_MSG ( ! E , false , " Unknown Shortcut: " + p_name + " . " ) ;
2016-06-05 02:31:29 +02:00
2021-08-03 17:27:45 +02:00
return E - > get ( ) - > matches_event ( p_event ) ;
2016-06-05 02:31:29 +02:00
}
2020-09-09 21:53:24 +02:00
Ref < Shortcut > EditorSettings : : get_shortcut ( const String & p_name ) const {
2020-12-07 12:31:51 +01:00
const Map < String , Ref < Shortcut > > : : Element * SC = shortcuts . find ( p_name ) ;
if ( SC ) {
return SC - > get ( ) ;
}
// If no shortcut with the provided name is found in the list, check the built-in shortcuts.
// Use the first item in the action list for the shortcut event, since a shortcut can only have 1 linked event.
Ref < Shortcut > sc ;
const Map < String , List < Ref < InputEvent > > > : : Element * builtin_override = builtin_action_overrides . find ( p_name ) ;
if ( builtin_override ) {
2021-06-18 00:03:09 +02:00
sc . instantiate ( ) ;
2021-08-03 17:27:45 +02:00
sc - > set_event ( builtin_override - > get ( ) . front ( ) - > get ( ) ) ;
2020-12-07 12:31:51 +01:00
sc - > set_name ( InputMap : : get_singleton ( ) - > get_builtin_display_name ( p_name ) ) ;
}
// If there was no override, check the default builtins to see if it has an InputEvent for the provided name.
if ( sc . is_null ( ) ) {
const OrderedHashMap < String , List < Ref < InputEvent > > > : : ConstElement builtin_default = InputMap : : get_singleton ( ) - > get_builtins ( ) . find ( p_name ) ;
if ( builtin_default ) {
2021-06-18 00:03:09 +02:00
sc . instantiate ( ) ;
2021-08-03 17:27:45 +02:00
sc - > set_event ( builtin_default . get ( ) . front ( ) - > get ( ) ) ;
2020-12-07 12:31:51 +01:00
sc - > set_name ( InputMap : : get_singleton ( ) - > get_builtin_display_name ( p_name ) ) ;
}
}
if ( sc . is_valid ( ) ) {
// Add the shortcut to the list.
shortcuts [ p_name ] = sc ;
return sc ;
2020-05-14 16:41:43 +02:00
}
2016-06-05 02:31:29 +02:00
2020-12-07 12:31:51 +01:00
return Ref < Shortcut > ( ) ;
2016-06-05 02:31:29 +02:00
}
void EditorSettings : : get_shortcut_list ( List < String > * r_shortcuts ) {
2020-09-09 21:53:24 +02:00
for ( const Map < String , Ref < Shortcut > > : : Element * E = shortcuts . front ( ) ; E ; E = E - > next ( ) ) {
2016-06-05 02:31:29 +02:00
r_shortcuts - > push_back ( E - > key ( ) ) ;
}
}
2020-09-09 21:53:24 +02:00
Ref < Shortcut > ED_GET_SHORTCUT ( const String & p_path ) {
2019-06-01 15:42:22 +02:00
if ( ! EditorSettings : : get_singleton ( ) ) {
2020-04-02 01:20:12 +02:00
return nullptr ;
2019-06-01 15:42:22 +02:00
}
2020-09-09 21:53:24 +02:00
Ref < Shortcut > sc = EditorSettings : : get_singleton ( ) - > get_shortcut ( p_path ) ;
2019-08-15 04:57:49 +02:00
ERR_FAIL_COND_V_MSG ( ! sc . is_valid ( ) , sc , " Used ED_GET_SHORTCUT with invalid shortcut: " + p_path + " . " ) ;
2017-10-28 15:40:55 +02:00
return sc ;
2016-07-04 00:13:45 +02:00
}
2016-06-05 02:31:29 +02:00
2020-09-09 21:53:24 +02:00
Ref < Shortcut > ED_SHORTCUT ( const String & p_path , const String & p_name , uint32_t p_keycode ) {
2017-12-26 07:30:36 +01:00
# ifdef OSX_ENABLED
2018-06-11 07:53:25 +02:00
// Use Cmd+Backspace as a general replacement for Delete shortcuts on macOS
2017-12-26 07:30:36 +01:00
if ( p_keycode = = KEY_DELETE ) {
p_keycode = KEY_MASK_CMD | KEY_BACKSPACE ;
}
# endif
2017-10-28 15:40:55 +02:00
Ref < InputEventKey > ie ;
if ( p_keycode ) {
2021-06-18 00:03:09 +02:00
ie . instantiate ( ) ;
2017-10-28 15:40:55 +02:00
ie - > set_unicode ( p_keycode & KEY_CODE_MASK ) ;
2018-04-05 19:59:35 +02:00
ie - > set_keycode ( p_keycode & KEY_CODE_MASK ) ;
2021-04-24 22:33:50 +02:00
ie - > set_shift_pressed ( bool ( p_keycode & KEY_MASK_SHIFT ) ) ;
ie - > set_alt_pressed ( bool ( p_keycode & KEY_MASK_ALT ) ) ;
ie - > set_ctrl_pressed ( bool ( p_keycode & KEY_MASK_CTRL ) ) ;
ie - > set_meta_pressed ( bool ( p_keycode & KEY_MASK_META ) ) ;
2016-10-12 22:23:48 +02:00
}
2019-06-01 15:42:22 +02:00
if ( ! EditorSettings : : get_singleton ( ) ) {
2020-09-09 21:53:24 +02:00
Ref < Shortcut > sc ;
2021-06-18 00:03:09 +02:00
sc . instantiate ( ) ;
2019-06-01 15:42:22 +02:00
sc - > set_name ( p_name ) ;
2021-08-03 17:27:45 +02:00
sc - > set_event ( ie ) ;
2019-06-01 15:42:22 +02:00
sc - > set_meta ( " original " , ie ) ;
return sc ;
}
2020-09-09 21:53:24 +02:00
Ref < Shortcut > sc = EditorSettings : : get_singleton ( ) - > get_shortcut ( p_path ) ;
2017-10-28 15:40:55 +02:00
if ( sc . is_valid ( ) ) {
sc - > set_name ( p_name ) ; //keep name (the ones that come from disk have no name)
sc - > set_meta ( " original " , ie ) ; //to compare against changes
return sc ;
}
2017-09-25 05:26:41 +02:00
2021-06-18 00:03:09 +02:00
sc . instantiate ( ) ;
2017-10-28 15:40:55 +02:00
sc - > set_name ( p_name ) ;
2021-08-03 17:27:45 +02:00
sc - > set_event ( ie ) ;
2017-10-28 15:40:55 +02:00
sc - > set_meta ( " original " , ie ) ; //to compare against changes
EditorSettings : : get_singleton ( ) - > add_shortcut ( p_path , sc ) ;
2017-09-25 05:26:41 +02:00
2017-10-28 15:40:55 +02:00
return sc ;
2017-09-25 05:26:41 +02:00
}
2020-12-07 12:31:51 +01:00
void EditorSettings : : set_builtin_action_override ( const String & p_name , const Array & p_events ) {
List < Ref < InputEvent > > event_list ;
// Override the whole list, since events may have their order changed or be added, removed or edited.
InputMap : : get_singleton ( ) - > action_erase_events ( p_name ) ;
for ( int i = 0 ; i < p_events . size ( ) ; i + + ) {
event_list . push_back ( p_events [ i ] ) ;
InputMap : : get_singleton ( ) - > action_add_event ( p_name , p_events [ i ] ) ;
}
// Check if the provided event array is same as built-in. If it is, it does not need to be added to the overrides.
// Note that event order must also be the same.
bool same_as_builtin = true ;
OrderedHashMap < String , List < Ref < InputEvent > > > : : ConstElement builtin_default = InputMap : : get_singleton ( ) - > get_builtins ( ) . find ( p_name ) ;
if ( builtin_default ) {
List < Ref < InputEvent > > builtin_events = builtin_default . get ( ) ;
if ( p_events . size ( ) = = builtin_events . size ( ) ) {
int event_idx = 0 ;
// Check equality of each event.
2021-07-26 17:50:35 +02:00
for ( const Ref < InputEvent > & E : builtin_events ) {
2021-07-16 05:45:57 +02:00
if ( ! E - > is_match ( p_events [ event_idx ] ) ) {
2020-12-07 12:31:51 +01:00
same_as_builtin = false ;
break ;
}
event_idx + + ;
}
} else {
same_as_builtin = false ;
}
}
if ( same_as_builtin & & builtin_action_overrides . has ( p_name ) ) {
builtin_action_overrides . erase ( p_name ) ;
} else {
builtin_action_overrides [ p_name ] = event_list ;
}
// Update the shortcut (if it is used somewhere in the editor) to be the first event of the new list.
if ( shortcuts . has ( p_name ) ) {
2021-08-03 17:27:45 +02:00
shortcuts [ p_name ] - > set_event ( event_list . front ( ) - > get ( ) ) ;
2020-12-07 12:31:51 +01:00
}
}
const Array EditorSettings : : get_builtin_action_overrides ( const String & p_name ) const {
const Map < String , List < Ref < InputEvent > > > : : Element * AO = builtin_action_overrides . find ( p_name ) ;
if ( AO ) {
Array event_array ;
List < Ref < InputEvent > > events_list = AO - > get ( ) ;
2021-07-26 17:50:35 +02:00
for ( const Ref < InputEvent > & E : events_list ) {
2021-07-16 05:45:57 +02:00
event_array . push_back ( E ) ;
2020-12-07 12:31:51 +01:00
}
return event_array ;
}
return Array ( ) ;
}
2017-10-28 15:40:55 +02:00
void EditorSettings : : notify_changes ( ) {
_THREAD_SAFE_METHOD_
2017-09-25 05:26:41 +02:00
2017-10-28 15:40:55 +02:00
SceneTree * sml = Object : : cast_to < SceneTree > ( OS : : get_singleton ( ) - > get_main_loop ( ) ) ;
2017-09-25 05:26:41 +02:00
2017-10-28 15:40:55 +02:00
if ( ! sml ) {
return ;
}
2017-09-25 05:26:41 +02:00
2017-10-28 15:40:55 +02:00
Node * root = sml - > get_root ( ) - > get_child ( 0 ) ;
if ( ! root ) {
return ;
}
root - > propagate_notification ( NOTIFICATION_EDITOR_SETTINGS_CHANGED ) ;
2017-09-25 05:26:41 +02:00
}
2014-02-10 02:10:30 +01:00
void EditorSettings : : _bind_methods ( ) {
2017-10-05 20:34:34 +02:00
ClassDB : : bind_method ( D_METHOD ( " has_setting " , " name " ) , & EditorSettings : : has_setting ) ;
ClassDB : : bind_method ( D_METHOD ( " set_setting " , " name " , " value " ) , & EditorSettings : : set_setting ) ;
ClassDB : : bind_method ( D_METHOD ( " get_setting " , " name " ) , & EditorSettings : : get_setting ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " erase " , " property " ) , & EditorSettings : : erase ) ;
2018-01-09 16:52:46 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_initial_value " , " name " , " value " , " update_current " ) , & EditorSettings : : set_initial_value ) ;
2017-10-28 15:40:55 +02:00
ClassDB : : bind_method ( D_METHOD ( " property_can_revert " , " name " ) , & EditorSettings : : property_can_revert ) ;
ClassDB : : bind_method ( D_METHOD ( " property_get_revert " , " name " ) , & EditorSettings : : property_get_revert ) ;
ClassDB : : bind_method ( D_METHOD ( " add_property_info " , " info " ) , & EditorSettings : : _add_property_info_bind ) ;
2017-11-17 15:50:18 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_project_settings_dir " ) , & EditorSettings : : get_project_settings_dir ) ;
2016-02-27 04:32:00 +01:00
2018-05-16 17:23:20 +02:00
ClassDB : : bind_method ( D_METHOD ( " set_project_metadata " , " section " , " key " , " data " ) , & EditorSettings : : set_project_metadata ) ;
ClassDB : : bind_method ( D_METHOD ( " get_project_metadata " , " section " , " key " , " default " ) , & EditorSettings : : get_project_metadata , DEFVAL ( Variant ( ) ) ) ;
2018-09-18 14:02:59 +02:00
ClassDB : : bind_method ( D_METHOD ( " set_favorites " , " dirs " ) , & EditorSettings : : set_favorites ) ;
ClassDB : : bind_method ( D_METHOD ( " get_favorites " ) , & EditorSettings : : get_favorites ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_recent_dirs " , " dirs " ) , & EditorSettings : : set_recent_dirs ) ;
ClassDB : : bind_method ( D_METHOD ( " get_recent_dirs " ) , & EditorSettings : : get_recent_dirs ) ;
2016-02-27 04:32:00 +01:00
2020-12-07 12:31:51 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_builtin_action_override " , " name " , " actions_list " ) , & EditorSettings : : set_builtin_action_override ) ;
2014-02-10 02:10:30 +01:00
ADD_SIGNAL ( MethodInfo ( " settings_changed " ) ) ;
2019-07-03 09:44:53 +02:00
BIND_CONSTANT ( NOTIFICATION_EDITOR_SETTINGS_CHANGED ) ;
2014-02-10 02:10:30 +01:00
}
EditorSettings : : EditorSettings ( ) {
2017-03-05 16:44:50 +01:00
last_order = 0 ;
optimize_save = true ;
save_changed_setting = true ;
2016-05-28 00:58:28 +02:00
2014-02-10 02:10:30 +01:00
_load_defaults ( ) ;
}
EditorSettings : : ~ EditorSettings ( ) {
}