summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--core/object.h2
-rw-r--r--drivers/dummy/rasterizer_dummy.h156
-rw-r--r--drivers/dummy/texture_loader_dummy.cpp87
-rw-r--r--drivers/dummy/texture_loader_dummy.h47
-rw-r--r--editor/animation_editor.cpp1
-rw-r--r--editor/code_editor.cpp1
-rw-r--r--editor/doc/doc_data.cpp3
-rw-r--r--editor/editor_inspector.cpp1797
-rw-r--r--editor/editor_inspector.h283
-rw-r--r--editor/editor_node.cpp74
-rw-r--r--editor/editor_node.h6
-rw-r--r--editor/editor_properties.cpp2411
-rw-r--r--editor/editor_properties.h490
-rw-r--r--editor/editor_settings.cpp1
-rw-r--r--editor/editor_spin_slider.cpp315
-rw-r--r--editor/editor_spin_slider.h57
-rw-r--r--editor/icons/icon_GUI_slider_grabber.svg85
-rw-r--r--editor/icons/icon_GUI_slider_grabber_hl.svg84
-rw-r--r--editor/multi_node_edit.cpp4
-rw-r--r--editor/plugins/animation_player_editor_plugin.cpp4
-rw-r--r--editor/plugins/canvas_item_editor_plugin.cpp11
-rw-r--r--editor/plugins/cube_grid_theme_editor_plugin.cpp2
-rw-r--r--editor/plugins/item_list_editor_plugin.cpp2
-rw-r--r--editor/project_settings_editor.cpp4
-rw-r--r--editor/property_editor.cpp4
-rw-r--r--editor/property_editor.h3
-rw-r--r--editor/scene_tree_dock.cpp2
-rw-r--r--editor/scene_tree_editor.cpp42
-rw-r--r--editor/scene_tree_editor.h2
-rw-r--r--editor/script_editor_debugger.cpp4
-rw-r--r--main/main.cpp234
-rw-r--r--main/timer_sync.cpp193
-rw-r--r--main/timer_sync.h71
-rw-r--r--modules/mono/csharp_script.cpp2
-rw-r--r--modules/visual_script/visual_script_editor.cpp2
-rw-r--r--platform/server/os_server.cpp6
-rw-r--r--platform/server/os_server.h3
-rw-r--r--scene/2d/audio_stream_player_2d.cpp2
-rw-r--r--scene/3d/light.cpp12
-rw-r--r--scene/gui/color_picker.cpp49
-rw-r--r--scene/gui/color_picker.h6
-rw-r--r--scene/gui/container.cpp6
-rw-r--r--scene/gui/control.cpp58
-rw-r--r--scene/gui/control.h8
-rw-r--r--scene/gui/range.cpp8
-rw-r--r--scene/gui/scroll_container.cpp16
-rw-r--r--scene/gui/text_edit.cpp1503
-rw-r--r--scene/gui/text_edit.h59
-rw-r--r--scene/main/node.cpp3
-rw-r--r--scene/main/node.h1
-rw-r--r--scene/main/viewport.cpp2
-rw-r--r--scene/resources/default_theme/default_theme.cpp5
52 files changed, 7265 insertions, 968 deletions
diff --git a/core/object.h b/core/object.h
index c405e22557..7963a43fd6 100644
--- a/core/object.h
+++ b/core/object.h
@@ -55,7 +55,7 @@ enum PropertyHint {
PROPERTY_HINT_RANGE, ///< hint_text = "min,max,step,slider; //slider is optional"
PROPERTY_HINT_EXP_RANGE, ///< hint_text = "min,max,step", exponential edit
PROPERTY_HINT_ENUM, ///< hint_text= "val1,val2,val3,etc"
- PROPERTY_HINT_EXP_EASING, /// exponential easing function (Math::ease)
+ PROPERTY_HINT_EXP_EASING, /// exponential easing function (Math::ease) use "attenuation" hint string to revert (flip h), "full" to also include in/out. (ie: "attenuation,inout")
PROPERTY_HINT_LENGTH, ///< hint_text= "length" (as integer)
PROPERTY_HINT_SPRITE_FRAME,
PROPERTY_HINT_KEY_ACCEL, ///< hint_text= "length" (as integer)
diff --git a/drivers/dummy/rasterizer_dummy.h b/drivers/dummy/rasterizer_dummy.h
index 54d803f13c..312d5aa378 100644
--- a/drivers/dummy/rasterizer_dummy.h
+++ b/drivers/dummy/rasterizer_dummy.h
@@ -127,7 +127,26 @@ public:
String path;
};
+ struct DummySurface {
+ uint32_t format;
+ VS::PrimitiveType primitive;
+ PoolVector<uint8_t> array;
+ int vertex_count;
+ PoolVector<uint8_t> index_array;
+ int index_count;
+ AABB aabb;
+ Vector<PoolVector<uint8_t> > blend_shapes;
+ Vector<AABB> bone_aabbs;
+ };
+
+ struct DummyMesh : public RID_Data {
+ Vector<DummySurface> surfaces;
+ int blend_shape_count;
+ VS::BlendShapeMode blend_shape_mode;
+ };
+
mutable RID_Owner<DummyTexture> texture_owner;
+ mutable RID_Owner<DummyMesh> mesh_owner;
RID texture_create() {
@@ -256,46 +275,128 @@ public:
/* MESH API */
- RID mesh_create() { return RID(); }
-
- void mesh_add_surface_from_arrays(RID p_mesh, VS::PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes = Array(), uint32_t p_compress_format = Mesh::ARRAY_COMPRESS_DEFAULT) {}
- void mesh_add_surface(RID p_mesh, uint32_t p_format, VS::PrimitiveType p_primitive, const PoolVector<uint8_t> &p_array, int p_vertex_count, const PoolVector<uint8_t> &p_index_array, int p_index_count, const AABB &p_aabb, const Vector<PoolVector<uint8_t> > &p_blend_shapes = Vector<PoolVector<uint8_t> >(), const Vector<AABB> &p_bone_aabbs = Vector<AABB>()) {}
+ RID mesh_create() {
+ DummyMesh *mesh = memnew(DummyMesh);
+ ERR_FAIL_COND_V(!mesh, RID());
+ mesh->blend_shape_count = 0;
+ mesh->blend_shape_mode = VS::BLEND_SHAPE_MODE_NORMALIZED;
+ return mesh_owner.make_rid(mesh);
+ }
- void mesh_add_surface_from_mesh_data(RID p_mesh, const Geometry::MeshData &p_mesh_data) {}
- void mesh_add_surface_from_planes(RID p_mesh, const PoolVector<Plane> &p_planes) {}
+ void mesh_add_surface(RID p_mesh, uint32_t p_format, VS::PrimitiveType p_primitive, const PoolVector<uint8_t> &p_array, int p_vertex_count, const PoolVector<uint8_t> &p_index_array, int p_index_count, const AABB &p_aabb, const Vector<PoolVector<uint8_t> > &p_blend_shapes = Vector<PoolVector<uint8_t> >(), const Vector<AABB> &p_bone_aabbs = Vector<AABB>()) {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND(!m);
+
+ m->surfaces.push_back(DummySurface());
+ DummySurface *s = &m->surfaces[m->surfaces.size() - 1];
+ s->format = p_format;
+ s->primitive = p_primitive;
+ s->array = p_array;
+ s->vertex_count = p_vertex_count;
+ s->index_array = p_index_array;
+ s->index_count = p_index_count;
+ s->aabb = p_aabb;
+ s->blend_shapes = p_blend_shapes;
+ s->bone_aabbs = p_bone_aabbs;
+ }
- void mesh_set_blend_shape_count(RID p_mesh, int p_amount) {}
- int mesh_get_blend_shape_count(RID p_mesh) const { return 0; }
+ void mesh_set_blend_shape_count(RID p_mesh, int p_amount) {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND(!m);
+ m->blend_shape_count = p_amount;
+ }
+ int mesh_get_blend_shape_count(RID p_mesh) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, 0);
+ return m->blend_shape_count;
+ }
- void mesh_set_blend_shape_mode(RID p_mesh, VS::BlendShapeMode p_mode) {}
- VS::BlendShapeMode mesh_get_blend_shape_mode(RID p_mesh) const { return VS::BLEND_SHAPE_MODE_NORMALIZED; }
+ void mesh_set_blend_shape_mode(RID p_mesh, VS::BlendShapeMode p_mode) {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND(!m);
+ m->blend_shape_mode = p_mode;
+ }
+ VS::BlendShapeMode mesh_get_blend_shape_mode(RID p_mesh) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, VS::BLEND_SHAPE_MODE_NORMALIZED);
+ return m->blend_shape_mode;
+ }
void mesh_surface_update_region(RID p_mesh, int p_surface, int p_offset, const PoolVector<uint8_t> &p_data) {}
void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material) {}
RID mesh_surface_get_material(RID p_mesh, int p_surface) const { return RID(); }
- int mesh_surface_get_array_len(RID p_mesh, int p_surface) const { return 0; }
- int mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const { return 0; }
+ int mesh_surface_get_array_len(RID p_mesh, int p_surface) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, 0);
+
+ return m->surfaces[p_surface].vertex_count;
+ }
+ int mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, 0);
+
+ return m->surfaces[p_surface].index_count;
+ }
PoolVector<uint8_t> mesh_surface_get_array(RID p_mesh, int p_surface) const {
- PoolVector<uint8_t> p;
- return p;
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, PoolVector<uint8_t>());
+
+ return m->surfaces[p_surface].array;
}
PoolVector<uint8_t> mesh_surface_get_index_array(RID p_mesh, int p_surface) const {
- PoolVector<uint8_t> p;
- return p;
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, PoolVector<uint8_t>());
+
+ return m->surfaces[p_surface].index_array;
+ }
+
+ uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, 0);
+
+ return m->surfaces[p_surface].format;
+ }
+ VS::PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, VS::PRIMITIVE_POINTS);
+
+ return m->surfaces[p_surface].primitive;
+ }
+
+ AABB mesh_surface_get_aabb(RID p_mesh, int p_surface) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, AABB());
+
+ return m->surfaces[p_surface].aabb;
}
+ Vector<PoolVector<uint8_t> > mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, Vector<PoolVector<uint8_t> >());
- uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const { return 0; }
- VS::PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const { return VS::PRIMITIVE_POINTS; }
+ return m->surfaces[p_surface].blend_shapes;
+ }
+ Vector<AABB> mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, Vector<AABB>());
+
+ return m->surfaces[p_surface].bone_aabbs;
+ }
- AABB mesh_surface_get_aabb(RID p_mesh, int p_surface) const { return AABB(); }
- Vector<PoolVector<uint8_t> > mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const { return Vector<PoolVector<uint8_t> >(); }
- Vector<AABB> mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const { return Vector<AABB>(); }
+ void mesh_remove_surface(RID p_mesh, int p_index) {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND(!m);
+ ERR_FAIL_COND(p_index >= m->surfaces.size());
- void mesh_remove_surface(RID p_mesh, int p_index) {}
- int mesh_get_surface_count(RID p_mesh) const { return 0; }
+ m->surfaces.remove(p_index);
+ }
+ int mesh_get_surface_count(RID p_mesh) const {
+ DummyMesh *m = mesh_owner.getornull(p_mesh);
+ ERR_FAIL_COND_V(!m, 0);
+ return m->surfaces.size();
+ }
void mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) {}
AABB mesh_get_custom_aabb(RID p_mesh) const { return AABB(); }
@@ -598,7 +699,14 @@ public:
RID canvas_light_occluder_create() { return RID(); }
void canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2> &p_lines) {}
- VS::InstanceType get_base_type(RID p_rid) const { return VS::INSTANCE_NONE; }
+ VS::InstanceType get_base_type(RID p_rid) const {
+ if (mesh_owner.owns(p_rid)) {
+ return VS::INSTANCE_MESH;
+ }
+
+ return VS::INSTANCE_NONE;
+ }
+
bool free(RID p_rid) {
if (texture_owner.owns(p_rid)) {
diff --git a/drivers/dummy/texture_loader_dummy.cpp b/drivers/dummy/texture_loader_dummy.cpp
new file mode 100644
index 0000000000..6d3e176bbb
--- /dev/null
+++ b/drivers/dummy/texture_loader_dummy.cpp
@@ -0,0 +1,87 @@
+/*************************************************************************/
+/* texture_loader_dummy.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#include "texture_loader_dummy.h"
+#include "core/os/file_access.h"
+#include "print_string.h"
+#include <string.h>
+
+RES ResourceFormatDummyTexture::load(const String &p_path, const String &p_original_path, Error *r_error) {
+ unsigned int width = 8;
+ unsigned int height = 8;
+
+ //We just use some format
+ Image::Format fmt = Image::FORMAT_RGB8;
+ int rowsize = 3 * width;
+
+ PoolVector<uint8_t> dstbuff;
+
+ dstbuff.resize(rowsize * height);
+
+ PoolVector<uint8_t>::Write dstbuff_write = dstbuff.write();
+
+ uint8_t *data = dstbuff_write.ptr();
+
+ uint8_t **row_p = memnew_arr(uint8_t *, height);
+
+ for (unsigned int i = 0; i < height; i++) {
+ row_p[i] = 0; //No colors any more, I want them to turn black
+ }
+
+ memdelete_arr(row_p);
+
+ Ref<Image> img = memnew(Image(width, height, 0, fmt, dstbuff));
+
+ Ref<ImageTexture> texture = memnew(ImageTexture);
+ texture->create_from_image(img);
+
+ if (r_error)
+ *r_error = OK;
+
+ return texture;
+}
+
+void ResourceFormatDummyTexture::get_recognized_extensions(List<String> *p_extensions) const {
+ p_extensions->push_back("png");
+ p_extensions->push_back("hdr");
+ p_extensions->push_back("jpg");
+ p_extensions->push_back("tga");
+}
+
+bool ResourceFormatDummyTexture::handles_type(const String &p_type) const {
+ return ClassDB::is_parent_class(p_type, "Texture");
+}
+
+String ResourceFormatDummyTexture::get_resource_type(const String &p_path) const {
+ String extension = p_path.get_extension().to_lower();
+ if (extension == "png" || extension == "hdr" || extension == "jpg" || extension == "tga")
+ return "ImageTexture";
+ return "";
+}
diff --git a/drivers/dummy/texture_loader_dummy.h b/drivers/dummy/texture_loader_dummy.h
new file mode 100644
index 0000000000..f0a355ec12
--- /dev/null
+++ b/drivers/dummy/texture_loader_dummy.h
@@ -0,0 +1,47 @@
+/*************************************************************************/
+/* texture_loader_dummy.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
+/* */
+/* 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. */
+/*************************************************************************/
+
+#ifndef TEXTURE_LOADER_DUMMY_H
+#define TEXTURE_LOADER_DUMMY_H
+
+#include "core/io/resource_loader.h"
+#include "scene/resources/texture.h"
+
+class ResourceFormatDummyTexture : public ResourceFormatLoader {
+public:
+ virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+ virtual void get_recognized_extensions(List<String> *p_extensions) const;
+ virtual bool handles_type(const String &p_type) const;
+ virtual String get_resource_type(const String &p_path) const;
+
+ virtual ~ResourceFormatDummyTexture() {}
+};
+
+#endif // TEXTURE_LOADER_DUMMY_H
diff --git a/editor/animation_editor.cpp b/editor/animation_editor.cpp
index f7c8cac93f..a03bf76d1b 100644
--- a/editor/animation_editor.cpp
+++ b/editor/animation_editor.cpp
@@ -2969,6 +2969,7 @@ void AnimationKeyEditor::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_VISIBILITY_CHANGED: {
+ update_keying();
EditorNode::get_singleton()->update_keying();
emit_signal("keying_changed");
} break;
diff --git a/editor/code_editor.cpp b/editor/code_editor.cpp
index 24e86770bf..93c86d920a 100644
--- a/editor/code_editor.cpp
+++ b/editor/code_editor.cpp
@@ -779,6 +779,7 @@ void CodeTextEditor::update_editor_settings() {
text_editor->set_draw_breakpoint_gutter(EditorSettings::get_singleton()->get("text_editor/line_numbers/show_breakpoint_gutter"));
text_editor->set_hiding_enabled(EditorSettings::get_singleton()->get("text_editor/line_numbers/code_folding"));
text_editor->set_draw_fold_gutter(EditorSettings::get_singleton()->get("text_editor/line_numbers/code_folding"));
+ text_editor->set_wrap_enabled(EditorSettings::get_singleton()->get("text_editor/line_numbers/word_wrap"));
text_editor->cursor_set_block_mode(EditorSettings::get_singleton()->get("text_editor/cursor/block_caret"));
text_editor->set_smooth_scroll_enabled(EditorSettings::get_singleton()->get("text_editor/open_scripts/smooth_scrolling"));
text_editor->set_v_scroll_speed(EditorSettings::get_singleton()->get("text_editor/open_scripts/v_scroll_speed"));
diff --git a/editor/doc/doc_data.cpp b/editor/doc/doc_data.cpp
index 3434aa33f9..c992ac5f16 100644
--- a/editor/doc/doc_data.cpp
+++ b/editor/doc/doc_data.cpp
@@ -567,6 +567,9 @@ void DocData::generate(bool p_basic_types) {
PropertyDoc pd;
Engine::Singleton &s = E->get();
+ if (!s.ptr) {
+ continue;
+ }
pd.name = s.name;
pd.type = s.ptr->get_class();
while (String(ClassDB::get_parent_class(pd.type)) != "Object")
diff --git a/editor/editor_inspector.cpp b/editor/editor_inspector.cpp
new file mode 100644
index 0000000000..21ad71fe06
--- /dev/null
+++ b/editor/editor_inspector.cpp
@@ -0,0 +1,1797 @@
+#include "editor_inspector.h"
+#include "array_property_edit.h"
+#include "dictionary_property_edit.h"
+#include "editor_node.h"
+#include "editor_scale.h"
+#include "multi_node_edit.h"
+#include "scene/resources/packed_scene.h"
+
+// TODO:
+// arrays
+
+Size2 EditorProperty::get_minimum_size() const {
+
+ Size2 ms;
+ for (int i = 0; i < get_child_count(); i++) {
+
+ Control *c = Object::cast_to<Control>(get_child(i));
+ if (!c)
+ continue;
+ if (c->is_set_as_toplevel())
+ continue;
+ if (!c->is_visible())
+ continue;
+ Size2 minsize = c->get_combined_minimum_size();
+ ms.width = MAX(ms.width, minsize.width);
+ ms.height = MAX(ms.height, minsize.height);
+ }
+
+ if (keying) {
+ Ref<Texture> key = get_icon("Key", "EditorIcons");
+ ms.width += key->get_width() + get_constant("hseparator", "Tree");
+ }
+
+ if (checkable) {
+ Ref<Texture> check = get_icon("checked", "CheckBox");
+ ms.width += check->get_width() + get_constant("hseparator", "Tree");
+ }
+
+ if (label_layout == LABEL_LAYOUT_TOP) {
+ Ref<Font> font = get_font("font", "Tree");
+ ms.height += font->get_height();
+ ms.height += get_constant("vseparation", "Tree");
+ }
+
+ return ms;
+}
+
+void EditorProperty::_notification(int p_what) {
+
+ if (p_what == NOTIFICATION_SORT_CHILDREN) {
+
+ Size2 size = get_size();
+ Rect2 rect;
+
+ if (label_layout == LABEL_LAYOUT_LEFT) {
+ int child_room = size.width / 2;
+
+ //compute room needed
+ for (int i = 0; i < get_child_count(); i++) {
+
+ Control *c = Object::cast_to<Control>(get_child(i));
+ if (!c)
+ continue;
+ if (c->is_set_as_toplevel())
+ continue;
+
+ Size2 minsize = c->get_combined_minimum_size();
+ child_room = MAX(child_room, minsize.width);
+ }
+
+ text_size = MAX(0, size.width - child_room + 4 * EDSCALE);
+
+ rect = Rect2(text_size, 0, size.width - text_size, size.height);
+ } else {
+ Ref<Font> font = get_font("font", "Tree");
+
+ text_size = size.width;
+ rect.position.x = 0;
+ rect.position.y = font->get_height() + get_constant("vseparation", "Tree");
+ rect.size = get_size();
+ rect.size.height -= rect.position.y;
+ }
+
+ if (keying) {
+ Ref<Texture> key;
+
+ if (use_keying_next()) {
+ key = get_icon("KeyNext", "EditorIcons");
+ } else {
+ key = get_icon("Key", "EditorIcons");
+ }
+
+ rect.size.x -= key->get_width() + get_constant("hseparator", "Tree");
+ }
+
+ //set children
+ for (int i = 0; i < get_child_count(); i++) {
+
+ Control *c = Object::cast_to<Control>(get_child(i));
+ if (!c)
+ continue;
+ if (c->is_set_as_toplevel())
+ continue;
+
+ fit_child_in_rect(c, rect);
+ }
+
+ update(); //need to redraw text
+ }
+
+ if (p_what == NOTIFICATION_DRAW) {
+ Ref<Font> font = get_font("font", "Tree");
+
+ Size2 size = get_size();
+ if (label_layout == LABEL_LAYOUT_TOP) {
+ size.height = font->get_height();
+ } else if (label_reference) {
+ size.height = label_reference->get_size().height;
+ }
+
+ if (selected) {
+ Ref<StyleBox> sb = get_stylebox("selected", "Tree");
+ draw_style_box(sb, Rect2(Vector2(), size));
+ }
+
+ Color color;
+ if (draw_red) {
+ color = get_color("error_color", "Editor");
+ } else {
+ color = get_color("font_color", "Tree");
+ }
+ if (label.find(".") != -1) {
+ color.a = 0.5; //this should be un-hacked honestly, as it's used for editor overrides
+ }
+
+ int ofs = 0;
+ if (checkable) {
+ Ref<Texture> checkbox;
+ if (checked)
+ checkbox = get_icon("checked", "CheckBox");
+ else
+ checkbox = get_icon("unchecked", "CheckBox");
+
+ Color color(1, 1, 1);
+ if (check_hover) {
+ color.r *= 1.2;
+ color.g *= 1.2;
+ color.b *= 1.2;
+ }
+ check_rect = Rect2(ofs, ((size.height - checkbox->get_height()) / 2), checkbox->get_width(), checkbox->get_height());
+ draw_texture(checkbox, check_rect.position, color);
+ ofs += get_constant("hseparator", "Tree");
+ ofs += checkbox->get_width();
+ } else {
+ check_rect = Rect2();
+ }
+
+ int text_limit = text_size;
+
+ if (can_revert) {
+ Ref<Texture> reload_icon = get_icon("ReloadSmall", "EditorIcons");
+ text_limit -= reload_icon->get_width() + get_constant("hseparator", "Tree") * 2;
+ revert_rect = Rect2(text_limit + get_constant("hseparator", "Tree"), (size.height - reload_icon->get_height()) / 2, reload_icon->get_width(), reload_icon->get_height());
+
+ Color color(1, 1, 1);
+ if (revert_hover) {
+ color.r *= 1.2;
+ color.g *= 1.2;
+ color.b *= 1.2;
+ }
+
+ draw_texture(reload_icon, revert_rect.position, color);
+ } else {
+ revert_rect = Rect2();
+ }
+
+ int v_ofs = (size.height - font->get_height()) / 2;
+ draw_string(font, Point2(ofs, v_ofs + font->get_ascent()), label, color, text_limit);
+
+ if (keying) {
+ Ref<Texture> key;
+
+ if (use_keying_next()) {
+ key = get_icon("KeyNext", "EditorIcons");
+ } else {
+ key = get_icon("Key", "EditorIcons");
+ }
+
+ ofs = size.width - key->get_width() - get_constant("hseparator", "Tree");
+
+ Color color(1, 1, 1);
+ if (keying_hover) {
+ color.r *= 1.2;
+ color.g *= 1.2;
+ color.b *= 1.2;
+ }
+ keying_rect = Rect2(ofs, ((size.height - key->get_height()) / 2), key->get_width(), key->get_height());
+ draw_texture(key, keying_rect.position, color);
+ } else {
+ keying_rect = Rect2();
+ }
+
+ //int vs = get_constant("vseparation", "Tree");
+ Color guide_color = get_color("guide_color", "Tree");
+ int vs_height = get_size().height; // vs / 2;
+ draw_line(Point2(0, vs_height), Point2(get_size().width, vs_height), guide_color);
+ }
+}
+
+void EditorProperty::set_label(const String &p_label) {
+ label = p_label;
+ update();
+}
+
+String EditorProperty::get_label() const {
+ return label;
+}
+
+Object *EditorProperty::get_edited_object() {
+ return object;
+}
+
+StringName EditorProperty::get_edited_property() {
+ return property;
+}
+
+void EditorProperty::update_property() {
+ if (get_script_instance())
+ get_script_instance()->call("update_property");
+}
+
+void EditorProperty::set_read_only(bool p_read_only) {
+ read_only = p_read_only;
+}
+
+bool EditorProperty::is_read_only() const {
+ return read_only;
+}
+
+bool EditorProperty::_might_be_in_instance() {
+
+ if (!object)
+ return false;
+
+ Node *node = Object::cast_to<Node>(object);
+
+ Node *edited_scene = EditorNode::get_singleton()->get_edited_scene();
+
+ bool might_be = false;
+
+ while (node) {
+
+ if (node->get_scene_instance_state().is_valid()) {
+ might_be = true;
+ break;
+ }
+ if (node == edited_scene) {
+ if (node->get_scene_inherited_state().is_valid()) {
+ might_be = true;
+ break;
+ }
+ might_be = false;
+ break;
+ }
+ node = node->get_owner();
+ }
+
+ return might_be; // or might not be
+}
+
+bool EditorProperty::_get_instanced_node_original_property(const StringName &p_prop, Variant &value) {
+
+ Node *node = Object::cast_to<Node>(object);
+
+ if (!node)
+ return false;
+
+ Node *orig = node;
+
+ Node *edited_scene = EditorNode::get_singleton()->get_edited_scene();
+
+ bool found = false;
+
+ while (node) {
+
+ Ref<SceneState> ss;
+
+ if (node == edited_scene) {
+ ss = node->get_scene_inherited_state();
+
+ } else {
+ ss = node->get_scene_instance_state();
+ }
+
+ if (ss.is_valid()) {
+
+ NodePath np = node->get_path_to(orig);
+ int node_idx = ss->find_node_by_path(np);
+ if (node_idx >= 0) {
+ bool lfound = false;
+ Variant lvar;
+ lvar = ss->get_property_value(node_idx, p_prop, lfound);
+ if (lfound) {
+
+ found = true;
+ value = lvar;
+ }
+ }
+ }
+ if (node == edited_scene) {
+ //just in case
+ break;
+ }
+ node = node->get_owner();
+ }
+
+ return found;
+}
+
+bool EditorProperty::_is_property_different(const Variant &p_current, const Variant &p_orig, int p_usage) {
+
+ // this is a pretty difficult function, because a property may not be saved but may have
+ // the flag to not save if one or if zero
+
+ {
+ Node *node = Object::cast_to<Node>(object);
+ if (!node)
+ return false;
+
+ Node *edited_scene = EditorNode::get_singleton()->get_edited_scene();
+ bool found_state = false;
+
+ while (node) {
+
+ Ref<SceneState> ss;
+
+ if (node == edited_scene) {
+ ss = node->get_scene_inherited_state();
+
+ } else {
+ ss = node->get_scene_instance_state();
+ }
+
+ if (ss.is_valid()) {
+ found_state = true;
+ }
+ if (node == edited_scene) {
+ //just in case
+ break;
+ }
+ node = node->get_owner();
+ }
+
+ if (!found_state)
+ return false; //pointless to check if we are not comparing against anything.
+ }
+
+ if (p_orig.get_type() == Variant::NIL) {
+ // not found (was not saved)
+ // check if it was not saved due to being zero or one
+ if (p_current.is_zero() && property_usage & PROPERTY_USAGE_STORE_IF_NONZERO)
+ return false;
+ if (p_current.is_one() && property_usage & PROPERTY_USAGE_STORE_IF_NONONE)
+ return false;
+ }
+
+ if (p_current.get_type() == Variant::REAL && p_orig.get_type() == Variant::REAL) {
+ float a = p_current;
+ float b = p_orig;
+
+ return Math::abs(a - b) > CMP_EPSILON; //this must be done because, as some scenes save as text, there might be a tiny difference in floats due to numerical error
+ }
+
+ return bool(Variant::evaluate(Variant::OP_NOT_EQUAL, p_current, p_orig));
+}
+
+bool EditorProperty::_is_instanced_node_with_original_property_different() {
+
+ bool mbi = _might_be_in_instance();
+ if (mbi) {
+ Variant vorig;
+ int usage = property_usage & (PROPERTY_USAGE_STORE_IF_NONONE | PROPERTY_USAGE_STORE_IF_NONZERO);
+ if (_get_instanced_node_original_property(property, vorig) || usage) {
+ Variant v = object->get(property);
+
+ if (_is_property_different(v, vorig, usage)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+void EditorProperty::update_reload_status() {
+
+ if (property == StringName())
+ return; //no property, so nothing to do
+
+ bool has_reload = false;
+
+ if (_is_instanced_node_with_original_property_different()) {
+ has_reload = true;
+ }
+
+ if (object->call("property_can_revert", property).operator bool()) {
+
+ has_reload = true;
+ }
+
+ if (!has_reload && !object->get_script().is_null()) {
+ Ref<Script> scr = object->get_script();
+ Variant orig_value;
+ if (scr->get_property_default_value(property, orig_value)) {
+ if (orig_value != object->get(property)) {
+ has_reload = true;
+ }
+ }
+ }
+
+ if (has_reload != can_revert) {
+ can_revert = has_reload;
+ update();
+ }
+}
+
+bool EditorProperty::use_keying_next() const {
+ return false;
+}
+void EditorProperty::set_checkable(bool p_checkable) {
+
+ checkable = p_checkable;
+ update();
+ queue_sort();
+}
+
+bool EditorProperty::is_checkable() const {
+
+ return checkable;
+}
+
+void EditorProperty::set_checked(bool p_checked) {
+
+ checked = p_checked;
+ update();
+}
+
+bool EditorProperty::is_checked() const {
+
+ return checked;
+}
+
+void EditorProperty::set_draw_red(bool p_draw_red) {
+
+ draw_red = p_draw_red;
+ update();
+}
+
+void EditorProperty::set_keying(bool p_keying) {
+ keying = p_keying;
+ update();
+ queue_sort();
+}
+
+bool EditorProperty::is_keying() const {
+ return keying;
+}
+
+bool EditorProperty::is_draw_red() const {
+
+ return draw_red;
+}
+
+void EditorProperty::_focusable_focused(int p_index) {
+
+ bool already_selected = selected;
+ selected = true;
+ selected_focusable = p_index;
+ update();
+ if (!already_selected && selected) {
+ emit_signal("selected", property, selected_focusable);
+ }
+}
+
+void EditorProperty::add_focusable(Control *p_control) {
+
+ p_control->connect("focus_entered", this, "_focusable_focused", varray(focusables.size()));
+ focusables.push_back(p_control);
+}
+
+void EditorProperty::select(int p_focusable) {
+
+ bool already_selected = selected;
+
+ if (p_focusable >= 0) {
+ ERR_FAIL_INDEX(p_focusable, focusables.size());
+ focusables[p_focusable]->grab_focus();
+ } else {
+ selected = true;
+ update();
+ }
+
+ if (!already_selected && selected) {
+ emit_signal("selected", property, selected_focusable);
+ }
+}
+
+void EditorProperty::deselect() {
+ selected = false;
+ selected_focusable = -1;
+ update();
+}
+
+bool EditorProperty::is_selected() const {
+ return selected;
+}
+
+void EditorProperty::_gui_input(const Ref<InputEvent> &p_event) {
+
+ if (property == StringName())
+ return;
+
+ Ref<InputEventMouse> me = p_event;
+
+ if (me.is_valid()) {
+
+ bool button_left = me->get_button_mask() & BUTTON_MASK_LEFT;
+
+ bool new_keying_hover = keying_rect.has_point(me->get_position()) && !button_left;
+ if (new_keying_hover != keying_hover) {
+ keying_hover = new_keying_hover;
+ update();
+ }
+
+ bool new_revert_hover = revert_rect.has_point(me->get_position()) && !button_left;
+ if (new_revert_hover != revert_hover) {
+ revert_hover = new_revert_hover;
+ update();
+ }
+
+ bool new_check_hover = check_rect.has_point(me->get_position()) && !button_left;
+ if (new_check_hover != check_hover) {
+ check_hover = new_check_hover;
+ update();
+ }
+ }
+
+ Ref<InputEventMouseButton> mb = p_event;
+
+ if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
+
+ if (!selected) {
+ selected = true;
+ emit_signal("selected", property, -1);
+ update();
+ }
+
+ if (keying_rect.has_point(mb->get_position())) {
+ emit_signal("property_keyed", property);
+ }
+
+ if (revert_rect.has_point(mb->get_position())) {
+
+ Variant vorig;
+
+ if (_might_be_in_instance() && _get_instanced_node_original_property(property, vorig)) {
+
+ emit_signal("property_changed", property, vorig.duplicate(true));
+ update_property();
+ return;
+ }
+
+ if (object->call("property_can_revert", property).operator bool()) {
+ Variant rev = object->call("property_get_revert", property);
+ emit_signal("property_changed", property, rev);
+ update_property();
+ }
+
+ if (!object->get_script().is_null()) {
+ Ref<Script> scr = object->get_script();
+ Variant orig_value;
+ if (scr->get_property_default_value(property, orig_value)) {
+ emit_signal("property_changed", property, orig_value);
+ update_property();
+ }
+ }
+ }
+ if (check_rect.has_point(mb->get_position())) {
+ checked = !checked;
+ update();
+ emit_signal("property_checked", property, checked);
+ }
+ }
+}
+
+void EditorProperty::set_label_reference(Control *p_control) {
+
+ label_reference = p_control;
+}
+
+Variant EditorProperty::get_drag_data(const Point2 &p_point) {
+
+ if (property == StringName())
+ return Variant();
+
+ Dictionary dp;
+ dp["type"] = "obj_property";
+ dp["object"] = object;
+ dp["property"] = property;
+ dp["value"] = object->get(property);
+
+ Label *label = memnew(Label);
+ label->set_text(property);
+ set_drag_preview(label);
+ return dp;
+}
+
+void EditorProperty::set_label_layout(LabelLayout p_layout) {
+ label_layout = p_layout;
+ queue_sort();
+ update();
+}
+
+void EditorProperty::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("set_label", "text"), &EditorProperty::set_label);
+ ClassDB::bind_method(D_METHOD("get_label"), &EditorProperty::get_label);
+
+ ClassDB::bind_method(D_METHOD("set_read_only", "read_only"), &EditorProperty::set_read_only);
+ ClassDB::bind_method(D_METHOD("is_read_only"), &EditorProperty::is_read_only);
+
+ ClassDB::bind_method(D_METHOD("set_checkable", "checkable"), &EditorProperty::set_checkable);
+ ClassDB::bind_method(D_METHOD("is_checkable"), &EditorProperty::is_checkable);
+
+ ClassDB::bind_method(D_METHOD("set_checked", "checked"), &EditorProperty::set_checked);
+ ClassDB::bind_method(D_METHOD("is_checked"), &EditorProperty::is_checked);
+
+ ClassDB::bind_method(D_METHOD("set_draw_red", "draw_red"), &EditorProperty::set_draw_red);
+ ClassDB::bind_method(D_METHOD("is_draw_red"), &EditorProperty::is_draw_red);
+
+ ClassDB::bind_method(D_METHOD("set_keying", "keying"), &EditorProperty::set_keying);
+ ClassDB::bind_method(D_METHOD("is_keying"), &EditorProperty::is_keying);
+
+ ClassDB::bind_method(D_METHOD("get_edited_property"), &EditorProperty::get_edited_property);
+ ClassDB::bind_method(D_METHOD("get_edited_object"), &EditorProperty::get_edited_object);
+
+ ClassDB::bind_method(D_METHOD("_gui_input"), &EditorProperty::_gui_input);
+ ClassDB::bind_method(D_METHOD("_focusable_focused"), &EditorProperty::_focusable_focused);
+
+ ADD_PROPERTY(PropertyInfo(Variant::STRING, "label"), "set_label", "get_label");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "read_only"), "set_read_only", "is_read_only");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "checkable"), "set_checkable", "is_checkable");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "checked"), "set_checked", "is_checked");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "draw_red"), "set_draw_red", "is_draw_red");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "keying"), "set_keying", "is_keying");
+ ADD_SIGNAL(MethodInfo("property_changed", PropertyInfo(Variant::STRING, "property"), PropertyInfo(Variant::NIL, "value", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT)));
+ ADD_SIGNAL(MethodInfo("multiple_properties_changed", PropertyInfo(Variant::POOL_STRING_ARRAY, "properties"), PropertyInfo(Variant::ARRAY, "value")));
+ ADD_SIGNAL(MethodInfo("property_keyed", PropertyInfo(Variant::STRING, "property")));
+ ADD_SIGNAL(MethodInfo("property_checked", PropertyInfo(Variant::STRING, "property"), PropertyInfo(Variant::STRING, "bool")));
+ ADD_SIGNAL(MethodInfo("resource_selected", PropertyInfo(Variant::STRING, "path"), PropertyInfo(Variant::OBJECT, "resource", PROPERTY_HINT_RESOURCE_TYPE, "Resource")));
+ ADD_SIGNAL(MethodInfo("object_id_selected", PropertyInfo(Variant::STRING, "property"), PropertyInfo(Variant::INT, "id")));
+ ADD_SIGNAL(MethodInfo("selected", PropertyInfo(Variant::STRING, "path"), PropertyInfo(Variant::INT, "focusable_idx")));
+
+ MethodInfo vm;
+ vm.name = "update_property";
+ BIND_VMETHOD(vm);
+}
+
+EditorProperty::EditorProperty() {
+
+ text_size = 0;
+ read_only = false;
+ checkable = false;
+ checked = false;
+ draw_red = false;
+ keying = false;
+ keying_hover = false;
+ revert_hover = false;
+ check_hover = false;
+ can_revert = false;
+ property_usage = 0;
+ selected = false;
+ selected_focusable = -1;
+ label_reference = NULL;
+ label_layout = LABEL_LAYOUT_LEFT;
+}
+////////////////////////////////////////////////
+////////////////////////////////////////////////
+
+void EditorInspectorPlugin::add_custom_control(Control *control) {
+
+ AddedEditor ae;
+ ae.property_editor = control;
+ added_editors.push_back(ae);
+}
+
+void EditorInspectorPlugin::add_property_editor(const String &p_for_property, Control *p_prop) {
+
+ ERR_FAIL_COND(Object::cast_to<EditorProperty>(p_prop) == NULL);
+
+ AddedEditor ae;
+ ae.properties.push_back(p_for_property);
+ ae.property_editor = p_prop;
+ added_editors.push_back(ae);
+}
+
+void EditorInspectorPlugin::add_property_editor_for_multiple_properties(const String &p_label, const Vector<String> &p_properties, Control *p_prop) {
+
+ AddedEditor ae;
+ ae.properties = p_properties;
+ ae.property_editor = p_prop;
+ ae.label = p_label;
+ added_editors.push_back(ae);
+}
+
+bool EditorInspectorPlugin::can_handle(Object *p_object) {
+
+ if (get_script_instance()) {
+ return get_script_instance()->call("can_handle", p_object);
+ }
+ return false;
+}
+void EditorInspectorPlugin::parse_begin(Object *p_object) {
+
+ if (get_script_instance()) {
+ get_script_instance()->call("parse_begin", p_object);
+ }
+}
+bool EditorInspectorPlugin::parse_property(Object *p_object, Variant::Type p_type, const String &p_path, PropertyHint p_hint, const String &p_hint_text, int p_usage) {
+
+ if (get_script_instance()) {
+ Variant arg[6] = {
+ p_object, p_type, p_path, p_hint, p_hint_text, p_usage
+ };
+ const Variant *argptr[6] = {
+ &arg[0], &arg[1], &arg[2], &arg[3], &arg[4], &arg[5]
+ };
+
+ Variant::CallError err;
+ return get_script_instance()->call("parse_property", (const Variant **)&argptr, 6, err);
+ }
+ return false;
+}
+void EditorInspectorPlugin::parse_end() {
+
+ if (get_script_instance()) {
+ get_script_instance()->call("parse_end");
+ }
+}
+
+void EditorInspectorPlugin::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("add_custom_control", "control"), &EditorInspectorPlugin::add_custom_control);
+ ClassDB::bind_method(D_METHOD("add_property_editor", "property", "editor"), &EditorInspectorPlugin::add_property_editor);
+ ClassDB::bind_method(D_METHOD("add_property_editor_for_multiple_properties", "label", "properties", "editor"), &EditorInspectorPlugin::add_property_editor_for_multiple_properties);
+
+ MethodInfo vm;
+ vm.name = "can_handle";
+ vm.arguments.push_back(PropertyInfo(Variant::OBJECT, "object"));
+ BIND_VMETHOD(vm);
+ vm.name = "parse_begin";
+ BIND_VMETHOD(vm);
+ vm.name = "parse_property";
+ vm.return_val.type = Variant::BOOL;
+ vm.arguments.push_back(PropertyInfo(Variant::INT, "type"));
+ vm.arguments.push_back(PropertyInfo(Variant::STRING, "path"));
+ vm.arguments.push_back(PropertyInfo(Variant::INT, "hint"));
+ vm.arguments.push_back(PropertyInfo(Variant::STRING, "hint_text"));
+ vm.arguments.push_back(PropertyInfo(Variant::INT, "usage"));
+ BIND_VMETHOD(vm);
+ vm.arguments.clear();
+ vm.return_val.type = Variant::NIL;
+ vm.name = "parse_end";
+ BIND_VMETHOD(vm);
+}
+
+////////////////////////////////////////////////
+////////////////////////////////////////////////
+
+void EditorInspectorCategory::_notification(int p_what) {
+
+ if (p_what == NOTIFICATION_DRAW) {
+
+ draw_rect(Rect2(Vector2(), get_size()), bg_color);
+ Ref<Font> font = get_font("font", "Tree");
+
+ int hs = get_constant("hseparation", "Tree");
+
+ int w = font->get_string_size(label).width;
+ if (icon.is_valid()) {
+ w += hs + icon->get_width();
+ }
+
+ int ofs = (get_size().width - w) / 2;
+
+ if (icon.is_valid()) {
+ draw_texture(icon, Point2(ofs, (get_size().height - icon->get_height()) / 2).floor());
+ ofs += hs + icon->get_width();
+ }
+
+ Color color = get_color("font_color", "Tree");
+ draw_string(font, Point2(ofs, font->get_ascent() + (get_size().height - font->get_height()) / 2).floor(), label, color, get_size().width);
+ }
+}
+
+Size2 EditorInspectorCategory::get_minimum_size() const {
+
+ Ref<Font> font = get_font("font", "Tree");
+
+ Size2 ms;
+ ms.width = 1;
+ ms.height = font->get_height();
+ if (icon.is_valid()) {
+ ms.height = MAX(icon->get_height(), ms.height);
+ }
+ ms.height += get_constant("vseparation", "Tree");
+
+ return ms;
+}
+
+EditorInspectorCategory::EditorInspectorCategory() {
+}
+
+////////////////////////////////////////////////
+////////////////////////////////////////////////
+
+void EditorInspectorSection::_notification(int p_what) {
+
+ if (p_what == NOTIFICATION_SORT_CHILDREN) {
+
+ Ref<Font> font = get_font("font", "Tree");
+ Ref<Texture> arrow;
+
+#ifdef TOOLS_ENABLED
+ if (foldable) {
+ if (object->editor_is_section_unfolded(section)) {
+ arrow = get_icon("arrow", "Tree");
+ } else {
+ arrow = get_icon("arrow_collapsed", "Tree");
+ }
+ }
+#endif
+
+ Size2 size = get_size();
+ Point2 offset;
+ offset.y = font->get_height();
+ if (arrow.is_valid()) {
+ offset.y = MAX(offset.y, arrow->get_height());
+ }
+
+ offset.y += get_constant("vseparation", "Tree");
+ offset.x += get_constant("item_margin", "Tree");
+
+ Rect2 rect(offset, size - offset);
+
+ //set children
+ for (int i = 0; i < get_child_count(); i++) {
+
+ Control *c = Object::cast_to<Control>(get_child(i));
+ if (!c)
+ continue;
+ if (c->is_set_as_toplevel())
+ continue;
+ if (!c->is_visible_in_tree())
+ continue;
+
+ fit_child_in_rect(c, rect);
+ }
+
+ update(); //need to redraw text
+ }
+
+ if (p_what == NOTIFICATION_DRAW) {
+
+ Ref<Texture> arrow;
+
+#ifdef TOOLS_ENABLED
+ if (foldable) {
+ if (object->editor_is_section_unfolded(section)) {
+ arrow = get_icon("arrow", "Tree");
+ } else {
+ arrow = get_icon("arrow_collapsed", "Tree");
+ }
+ }
+#endif
+
+ Ref<Font> font = get_font("font", "Tree");
+
+ int h = font->get_height();
+ if (arrow.is_valid()) {
+ h = MAX(h, arrow->get_height());
+ }
+ h += get_constant("vseparation", "Tree");
+
+ draw_rect(Rect2(Vector2(), Vector2(get_size().width, h)), bg_color);
+
+ int hs = get_constant("hseparation", "Tree");
+
+ int ofs = 0;
+ if (arrow.is_valid()) {
+ draw_texture(arrow, Point2(ofs, (h - arrow->get_height()) / 2).floor());
+ ofs += hs + arrow->get_width();
+ }
+
+ Color color = get_color("font_color", "Tree");
+ draw_string(font, Point2(ofs, font->get_ascent() + (h - font->get_height()) / 2).floor(), label, color, get_size().width);
+ }
+}
+
+Size2 EditorInspectorSection::get_minimum_size() const {
+
+ Size2 ms;
+ for (int i = 0; i < get_child_count(); i++) {
+
+ Control *c = Object::cast_to<Control>(get_child(i));
+ if (!c)
+ continue;
+ if (c->is_set_as_toplevel())
+ continue;
+ if (!c->is_visible())
+ continue;
+ Size2 minsize = c->get_combined_minimum_size();
+ ms.width = MAX(ms.width, minsize.width);
+ ms.height = MAX(ms.height, minsize.height);
+ }
+
+ Ref<Font> font = get_font("font", "Tree");
+ ms.height += font->get_ascent() + get_constant("vseparation", "Tree");
+ ms.width += get_constant("item_margin", "Tree");
+
+ return ms;
+}
+
+void EditorInspectorSection::setup(const String &p_section, const String &p_label, Object *p_object, const Color &p_bg_color, bool p_foldable) {
+
+ section = p_section;
+ label = p_label;
+ object = p_object;
+ bg_color = p_bg_color;
+ foldable = p_foldable;
+
+#ifdef TOOLS_ENABLED
+ if (foldable) {
+ if (object->editor_is_section_unfolded(section)) {
+ vbox->show();
+ } else {
+ vbox->hide();
+ }
+ }
+ // void editor_set_section_unfold(const String &p_section, bool p_unfolded);
+
+#endif
+}
+
+void EditorInspectorSection::_gui_input(const Ref<InputEvent> &p_event) {
+
+ if (!foldable)
+ return;
+
+#ifdef TOOLS_ENABLED
+
+ Ref<InputEventMouseButton> mb = p_event;
+ if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
+ bool unfold = !object->editor_is_section_unfolded(section);
+ object->editor_set_section_unfold(section, unfold);
+ if (unfold) {
+ vbox->show();
+ } else {
+ vbox->hide();
+ }
+ }
+#endif
+}
+
+VBoxContainer *EditorInspectorSection::get_vbox() {
+ return vbox;
+}
+
+void EditorInspectorSection::unfold() {
+
+ if (!foldable)
+ return;
+#ifdef TOOLS_ENABLED
+
+ object->editor_set_section_unfold(section, true);
+ vbox->show();
+ update();
+#endif
+}
+
+void EditorInspectorSection::fold() {
+ if (!foldable)
+ return;
+
+#ifdef TOOLS_ENABLED
+
+ object->editor_set_section_unfold(section, false);
+ vbox->hide();
+ update();
+#endif
+}
+
+void EditorInspectorSection::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("setup", "section", "label", "object", "bg_color", "foldable"), &EditorInspectorSection::setup);
+ ClassDB::bind_method(D_METHOD("get_vbox"), &EditorInspectorSection::get_vbox);
+ ClassDB::bind_method(D_METHOD("unfold"), &EditorInspectorSection::unfold);
+ ClassDB::bind_method(D_METHOD("fold"), &EditorInspectorSection::fold);
+ ClassDB::bind_method(D_METHOD("_gui_input"), &EditorInspectorSection::_gui_input);
+}
+
+EditorInspectorSection::EditorInspectorSection() {
+ object = NULL;
+ foldable = false;
+ vbox = memnew(VBoxContainer);
+ add_child(vbox);
+}
+
+////////////////////////////////////////////////
+////////////////////////////////////////////////
+
+Ref<EditorInspectorPlugin> EditorInspector::inspector_plugins[MAX_PLUGINS];
+int EditorInspector::inspector_plugin_count = 0;
+
+void EditorInspector::add_inspector_plugin(const Ref<EditorInspectorPlugin> &p_plugin) {
+
+ ERR_FAIL_COND(inspector_plugin_count == MAX_PLUGINS);
+
+ for (int i = 0; i < inspector_plugin_count; i++) {
+ if (inspector_plugins[i] == p_plugin)
+ return; //already exists
+ }
+ inspector_plugins[inspector_plugin_count++] = p_plugin;
+}
+
+void EditorInspector::remove_inspector_plugin(const Ref<EditorInspectorPlugin> &p_plugin) {
+
+ ERR_FAIL_COND(inspector_plugin_count == MAX_PLUGINS);
+
+ int idx = -1;
+ for (int i = 0; i < inspector_plugin_count; i++) {
+ if (inspector_plugins[i] == p_plugin) {
+ idx = i;
+ break;
+ }
+ }
+
+ for (int i = idx; i < inspector_plugin_count - 1; i++) {
+ inspector_plugins[i] = inspector_plugins[i + 1];
+ }
+ inspector_plugin_count--;
+}
+
+void EditorInspector::cleanup_plugins() {
+ for (int i = 0; i < inspector_plugin_count; i++) {
+ inspector_plugins[i].unref();
+ }
+ inspector_plugin_count = 0;
+}
+
+void EditorInspector::set_undo_redo(UndoRedo *p_undo_redo) {
+ undo_redo = p_undo_redo;
+}
+
+String EditorInspector::get_selected_path() const {
+
+ return property_selected;
+}
+
+void EditorInspector::update_tree() {
+
+ //to update properly if all is refreshed
+ StringName current_selected = property_selected;
+ int current_focusable = property_focusable;
+
+ _clear();
+
+ if (!object)
+ return;
+
+ List<Ref<EditorInspectorPlugin> > valid_plugins;
+
+ for (int i = inspector_plugin_count - 1; i >= 0; i--) { //start by last, so lastly added can override newly added
+ if (!inspector_plugins[i]->can_handle(object))
+ continue;
+ valid_plugins.push_back(inspector_plugins[i]);
+ }
+
+ bool draw_red = false;
+
+ {
+ Node *nod = Object::cast_to<Node>(object);
+ Node *es = EditorNode::get_singleton()->get_edited_scene();
+ if (nod && es != nod && nod->get_owner() != es) {
+ draw_red = true;
+ }
+ }
+
+ // TreeItem *current_category = NULL;
+
+ String filter = search_box ? search_box->get_text() : "";
+ String group;
+ String group_base;
+
+ List<PropertyInfo> plist;
+ object->get_property_list(&plist, true);
+
+ HashMap<String, VBoxContainer *> item_path;
+ item_path[""] = main_vbox;
+
+ Color sscolor = get_color("prop_subsection", "Editor");
+
+ for (List<PropertyInfo>::Element *I = plist.front(); I; I = I->next()) {
+
+ PropertyInfo &p = I->get();
+
+ //make sure the property can be edited
+
+ if (p.usage & PROPERTY_USAGE_GROUP) {
+
+ group = p.name;
+ group_base = p.hint_string;
+
+ continue;
+
+ } else if (p.usage & PROPERTY_USAGE_CATEGORY) {
+
+ group = "";
+ group_base = "";
+
+ if (!show_categories)
+ continue;
+
+ List<PropertyInfo>::Element *N = I->next();
+ bool valid = true;
+ //if no properties in category, skip
+ while (N) {
+ if (N->get().usage & PROPERTY_USAGE_EDITOR)
+ break;
+ if (N->get().usage & PROPERTY_USAGE_CATEGORY) {
+ valid = false;
+ break;
+ }
+ N = N->next();
+ }
+ if (!valid)
+ continue; //empty, ignore
+
+ EditorInspectorCategory *category = memnew(EditorInspectorCategory);
+ main_vbox->add_child(category);
+
+ String type = p.name;
+ if (has_icon(type, "EditorIcons"))
+ category->icon = get_icon(type, "EditorIcons");
+ else
+ category->icon = get_icon("Object", "EditorIcons");
+ category->label = type;
+
+ category->bg_color = get_color("prop_category", "Editor");
+ if (use_doc_hints) {
+ StringName type = p.name;
+ if (!class_descr_cache.has(type)) {
+
+ String descr;
+ DocData *dd = EditorHelp::get_doc_data();
+ Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(type);
+ if (E) {
+ descr = E->get().brief_description;
+ }
+ class_descr_cache[type] = descr.word_wrap(80);
+ }
+
+ category->set_tooltip(TTR("Class:") + " " + p.name + (class_descr_cache[type] == "" ? "" : "\n\n" + class_descr_cache[type]));
+ }
+ continue;
+
+ } else if (!(p.usage & PROPERTY_USAGE_EDITOR))
+ continue;
+
+ if (hide_script && p.name == "script")
+ continue;
+
+ String basename = p.name;
+ if (group != "") {
+ if (group_base != "") {
+ if (basename.begins_with(group_base)) {
+ basename = basename.replace_first(group_base, "");
+ } else if (group_base.begins_with(basename)) {
+ //keep it, this is used pretty often
+ } else {
+ group = ""; //no longer using group base, clear
+ }
+ }
+ }
+
+ if (group != "") {
+ basename = group + "/" + basename;
+ }
+
+ String name = (basename.find("/") != -1) ? basename.right(basename.find_last("/") + 1) : basename;
+
+ if (capitalize_paths) {
+ int dot = name.find(".");
+ if (dot != -1) {
+ String ov = name.right(dot);
+ name = name.substr(0, dot);
+ name = name.camelcase_to_underscore().capitalize();
+ name += ov;
+
+ } else {
+ name = name.camelcase_to_underscore().capitalize();
+ }
+ }
+
+ String path = basename.left(basename.find_last("/"));
+
+ if (use_filter && filter != "") {
+
+ String cat = path;
+
+ if (capitalize_paths)
+ cat = cat.capitalize();
+
+ if (!filter.is_subsequence_ofi(cat) && !filter.is_subsequence_ofi(name))
+ continue;
+ }
+
+ VBoxContainer *current_vbox = main_vbox;
+
+ {
+
+ String acc_path = "";
+ int level = 1;
+ for (int i = 0; i < path.get_slice_count("/"); i++) {
+ String path_name = path.get_slice("/", i);
+ if (i > 0)
+ acc_path += "/";
+ acc_path += path_name;
+ if (!item_path.has(acc_path)) {
+ EditorInspectorSection *section = memnew(EditorInspectorSection);
+ current_vbox->add_child(section);
+ sections.push_back(section);
+
+ if (capitalize_paths)
+ path_name = path_name.capitalize();
+ Color c = sscolor;
+ c.a /= level;
+ section->setup(path_name, acc_path, object, c, use_folding);
+
+ item_path[acc_path] = section->get_vbox();
+ }
+ current_vbox = item_path[acc_path];
+ level = (MIN(level + 1, 4));
+ }
+ }
+
+ bool checkable = false;
+ bool checked = false;
+ if (p.usage & PROPERTY_USAGE_CHECKABLE) {
+ checkable = true;
+ checked = p.usage & PROPERTY_USAGE_CHECKED;
+ }
+
+ String doc_hint;
+
+ if (use_doc_hints) {
+
+ StringName classname = object->get_class_name();
+ StringName propname = p.name;
+ String descr;
+ bool found = false;
+
+ Map<StringName, Map<StringName, String> >::Element *E = descr_cache.find(classname);
+ if (E) {
+ Map<StringName, String>::Element *F = E->get().find(propname);
+ if (F) {
+ found = true;
+ descr = F->get();
+ }
+ }
+
+ if (!found) {
+ DocData *dd = EditorHelp::get_doc_data();
+ Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(classname);
+ while (E && descr == String()) {
+ for (int i = 0; i < E->get().properties.size(); i++) {
+ if (E->get().properties[i].name == propname.operator String()) {
+ descr = E->get().properties[i].description.strip_edges().word_wrap(80);
+ break;
+ }
+ }
+ if (!E->get().inherits.empty()) {
+ E = dd->class_list.find(E->get().inherits);
+ } else {
+ break;
+ }
+ }
+ descr_cache[classname][propname] = descr;
+ }
+
+ doc_hint = descr;
+ }
+
+#if 0
+ if (p.name == selected_property) {
+
+ item->select(1);
+ }
+#endif
+ for (List<Ref<EditorInspectorPlugin> >::Element *E = valid_plugins.front(); E; E = E->next()) {
+ Ref<EditorInspectorPlugin> ped = E->get();
+ ped->parse_property(object, p.type, p.name, p.hint, p.hint_string, p.usage);
+ for (List<EditorInspectorPlugin::AddedEditor>::Element *F = ped->added_editors.front(); F; F = F->next()) {
+
+ EditorProperty *ep = Object::cast_to<EditorProperty>(F->get().property_editor);
+ current_vbox->add_child(F->get().property_editor);
+
+ if (ep) {
+
+ ep->object = object;
+ ep->connect("property_changed", this, "_property_changed");
+ ep->connect("property_keyed", this, "_property_keyed");
+ ep->connect("property_checked", this, "_property_checked");
+ ep->connect("selected", this, "_property_selected");
+ ep->connect("multiple_properties_changed", this, "_multiple_properties_changed");
+ ep->connect("resource_selected", this, "_resource_selected", varray(), CONNECT_DEFERRED);
+ ep->connect("object_id_selected", this, "_object_id_selected", varray(), CONNECT_DEFERRED);
+ ep->set_tooltip(doc_hint);
+ ep->set_draw_red(draw_red);
+ ep->set_checkable(checkable);
+ ep->set_checked(checked);
+ ep->set_keying(keying);
+
+ if (F->get().properties.size()) {
+
+ if (F->get().properties.size() == 1) {
+ //since it's one, associate:
+ ep->property = F->get().properties[0];
+ ep->property_usage = p.usage;
+ //and set label?
+ }
+
+ if (F->get().label != String()) {
+ ep->set_label(F->get().label);
+ } else {
+ //use existin one
+ ep->set_label(name);
+ }
+ for (int i = 0; i < F->get().properties.size(); i++) {
+ String prop = F->get().properties[i];
+
+ if (!editor_property_map.has(prop)) {
+ editor_property_map[prop] = List<EditorProperty *>();
+ }
+ editor_property_map[prop].push_back(ep);
+ }
+ }
+
+ ep->set_read_only(read_only);
+ ep->update_property();
+ ep->update_reload_status();
+
+ if (current_selected && ep->property == current_selected) {
+ ep->select(current_focusable);
+ }
+ }
+ }
+ ped->added_editors.clear();
+ }
+ }
+
+ //see if this property exists and should be kept
+}
+void EditorInspector::update_property(const String &p_prop) {
+ if (!editor_property_map.has(p_prop))
+ return;
+
+ for (List<EditorProperty *>::Element *E = editor_property_map[p_prop].front(); E; E = E->next()) {
+ E->get()->update_property();
+ E->get()->update_reload_status();
+ }
+}
+
+void EditorInspector::_clear() {
+
+ editor_property_map.clear();
+ sections.clear();
+ pending.clear();
+ property_selected = StringName();
+ property_focusable = -1;
+ while (main_vbox->get_child_count()) {
+ memdelete(main_vbox->get_child(0));
+ }
+}
+
+void EditorInspector::refresh() {
+
+ if (refresh_countdown > 0)
+ return;
+ refresh_countdown = EditorSettings::get_singleton()->get("docks/property_editor/auto_refresh_interval");
+}
+
+void EditorInspector::edit(Object *p_object) {
+ if (object != p_object) {
+ _clear();
+ }
+
+ if (object) {
+
+ object->remove_change_receptor(this);
+ }
+
+ object = p_object;
+ if (object) {
+ object->add_change_receptor(this);
+ update_tree();
+ }
+}
+
+void EditorInspector::set_keying(bool p_active) {
+ if (keying == p_active)
+ return;
+ keying = p_active;
+ update_tree();
+}
+void EditorInspector::set_read_only(bool p_read_only) {
+ read_only = p_read_only;
+ update_tree();
+}
+
+bool EditorInspector::is_capitalize_paths_enabled() const {
+
+ return capitalize_paths;
+}
+void EditorInspector::set_enable_capitalize_paths(bool p_capitalize) {
+ capitalize_paths = p_capitalize;
+ update_tree();
+}
+
+void EditorInspector::set_autoclear(bool p_enable) {
+ autoclear = p_enable;
+}
+
+void EditorInspector::set_show_categories(bool p_show) {
+ show_categories = p_show;
+ update_tree();
+}
+
+void EditorInspector::set_use_doc_hints(bool p_enable) {
+ use_doc_hints = p_enable;
+ update_tree();
+}
+void EditorInspector::set_hide_script(bool p_hide) {
+ hide_script = p_hide;
+ update_tree();
+}
+void EditorInspector::set_use_filter(bool p_use) {
+ use_filter = p_use;
+ update_tree();
+}
+void EditorInspector::register_text_enter(Node *p_line_edit) {
+ search_box = Object::cast_to<LineEdit>(p_line_edit);
+ if (search_box)
+ search_box->connect("text_changed", this, "_filter_changed");
+}
+
+void EditorInspector::_filter_changed(const String &p_text) {
+
+ update_tree();
+}
+
+void EditorInspector::set_subsection_selectable(bool p_selectable) {
+}
+
+void EditorInspector::set_property_selectable(bool p_selectable) {
+}
+
+void EditorInspector::set_use_folding(bool p_enable) {
+ use_folding = p_enable;
+ update_tree();
+}
+
+void EditorInspector::collapse_all_folding() {
+
+ for (List<EditorInspectorSection *>::Element *E = sections.front(); E; E = E->next()) {
+ E->get()->fold();
+ }
+}
+
+void EditorInspector::expand_all_folding() {
+ for (List<EditorInspectorSection *>::Element *E = sections.front(); E; E = E->next()) {
+ E->get()->unfold();
+ }
+}
+
+void EditorInspector::set_scroll_offset(int p_offset) {
+ set_v_scroll(p_offset);
+}
+
+int EditorInspector::get_scroll_offset() const {
+ return get_v_scroll();
+}
+
+void EditorInspector::_edit_request_change(Object *p_object, const String &p_property) {
+
+ if (object != p_object) //may be undoing/redoing for a non edited object, so ignore
+ return;
+
+ if (changing)
+ return;
+
+ if (p_property == String())
+ update_tree_pending = true;
+ else {
+ pending.insert(p_property);
+ }
+}
+
+void EditorInspector::_edit_set(const String &p_name, const Variant &p_value, bool p_refresh_all, const String &p_changed_field) {
+
+ if (autoclear && editor_property_map.has(p_name)) {
+ for (List<EditorProperty *>::Element *E = editor_property_map[p_name].front(); E; E = E->next()) {
+ if (E->get()->is_checkable()) {
+ E->get()->set_checked(true);
+ }
+ }
+ }
+
+ if (!undo_redo || Object::cast_to<ArrayPropertyEdit>(object) || Object::cast_to<DictionaryPropertyEdit>(object)) { //kind of hacky
+
+ object->set(p_name, p_value);
+ if (p_refresh_all)
+ _edit_request_change(object, "");
+ else
+ _edit_request_change(object, p_name);
+
+ emit_signal(_prop_edited, p_name);
+
+ } else if (Object::cast_to<MultiNodeEdit>(object)) {
+
+ Object::cast_to<MultiNodeEdit>(object)->set_property_field(p_name, p_value, p_changed_field);
+ _edit_request_change(object, p_name);
+ emit_signal(_prop_edited, p_name);
+ } else {
+
+ undo_redo->create_action(TTR("Set") + " " + p_name, UndoRedo::MERGE_ENDS);
+ undo_redo->add_do_property(object, p_name, p_value);
+ undo_redo->add_undo_property(object, p_name, object->get(p_name));
+
+ if (p_refresh_all) {
+ undo_redo->add_do_method(this, "_edit_request_change", object, "");
+ undo_redo->add_undo_method(this, "_edit_request_change", object, "");
+ } else {
+
+ undo_redo->add_do_method(this, "_edit_request_change", object, p_name);
+ undo_redo->add_undo_method(this, "_edit_request_change", object, p_name);
+ }
+
+ Resource *r = Object::cast_to<Resource>(object);
+ if (r) {
+ if (!r->is_edited() && String(p_name) != "resource/edited") {
+ undo_redo->add_do_method(r, "set_edited", true);
+ undo_redo->add_undo_method(r, "set_edited", false);
+ }
+
+ if (String(p_name) == "resource_local_to_scene") {
+ bool prev = object->get(p_name);
+ bool next = p_value;
+ if (next) {
+ undo_redo->add_do_method(r, "setup_local_to_scene");
+ }
+ if (prev) {
+ undo_redo->add_undo_method(r, "setup_local_to_scene");
+ }
+ }
+ }
+ undo_redo->add_do_method(this, "emit_signal", _prop_edited, p_name);
+ undo_redo->add_undo_method(this, "emit_signal", _prop_edited, p_name);
+ changing++;
+ undo_redo->commit_action();
+ changing--;
+ }
+
+ if (editor_property_map.has(p_name)) {
+ for (List<EditorProperty *>::Element *E = editor_property_map[p_name].front(); E; E = E->next()) {
+ E->get()->update_reload_status();
+ }
+ }
+}
+
+void EditorInspector::_property_changed(const String &p_path, const Variant &p_value) {
+
+ _edit_set(p_path, p_value, false, "");
+}
+
+void EditorInspector::_multiple_properties_changed(Vector<String> p_paths, Array p_values) {
+
+ ERR_FAIL_COND(p_paths.size() == 0 || p_values.size() == 0);
+ ERR_FAIL_COND(p_paths.size() != p_values.size());
+ String names;
+ for (int i = 0; i < p_paths.size(); i++) {
+ if (i > 0)
+ names += ",";
+ names += p_paths[i];
+ }
+ undo_redo->create_action(TTR("Set Multiple:") + " " + names, UndoRedo::MERGE_ENDS);
+ for (int i = 0; i < p_paths.size(); i++) {
+ _edit_set(p_paths[i], p_values[i], false, "");
+ }
+ changing++;
+ undo_redo->commit_action();
+ changing--;
+}
+
+void EditorInspector::_property_keyed(const String &p_path) {
+
+ if (!object)
+ return;
+
+ emit_signal("property_keyed", p_path, object->get(p_path), false); //second param is deprecated
+}
+
+void EditorInspector::_property_checked(const String &p_path, bool p_checked) {
+
+ if (!object)
+ return;
+
+ //property checked
+ if (autoclear) {
+
+ if (!p_checked) {
+ object->set(p_path, Variant());
+ } else {
+
+ Variant to_create;
+ List<PropertyInfo> pinfo;
+ object->get_property_list(&pinfo);
+ for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
+ if (E->get().name == p_path) {
+ Variant::CallError ce;
+ to_create = Variant::construct(E->get().type, NULL, 0, ce);
+ break;
+ }
+ }
+ object->set(p_path, to_create);
+ }
+
+ if (editor_property_map.has(p_path)) {
+ for (List<EditorProperty *>::Element *E = editor_property_map[p_path].front(); E; E = E->next()) {
+ E->get()->update_property();
+ E->get()->update_reload_status();
+ }
+ }
+
+ } else {
+ emit_signal("property_toggled", p_path, p_checked);
+ }
+}
+
+void EditorInspector::_property_selected(const String &p_path, int p_focusable) {
+
+ property_selected = p_path;
+ property_focusable = p_focusable;
+ //deselect the others
+ for (Map<StringName, List<EditorProperty *> >::Element *F = editor_property_map.front(); F; F = F->next()) {
+ if (F->key() == property_selected)
+ continue;
+ for (List<EditorProperty *>::Element *E = F->get().front(); E; E = E->next()) {
+ if (E->get()->is_selected())
+ E->get()->deselect();
+ }
+ }
+}
+
+void EditorInspector::_object_id_selected(const String &p_path, ObjectID p_id) {
+
+ emit_signal("object_id_selected", p_id);
+}
+
+void EditorInspector::_resource_selected(const String &p_path, RES p_resource) {
+ emit_signal("resource_selected", p_resource, p_path);
+}
+
+void EditorInspector::_node_removed(Node *p_node) {
+
+ if (p_node == object) {
+ edit(NULL);
+ }
+}
+
+void EditorInspector::_notification(int p_what) {
+
+ if (p_what == NOTIFICATION_ENTER_TREE) {
+
+ get_tree()->connect("node_removed", this, "_node_removed");
+ add_style_override("bg", get_stylebox("bg", "Tree"));
+ }
+ if (p_what == NOTIFICATION_EXIT_TREE) {
+
+ get_tree()->disconnect("node_removed", this, "_node_removed");
+ edit(NULL);
+ }
+
+ if (p_what == NOTIFICATION_PROCESS) {
+
+ if (refresh_countdown > 0) {
+ refresh_countdown -= get_process_delta_time();
+ if (refresh_countdown <= 0) {
+ for (Map<StringName, List<EditorProperty *> >::Element *F = editor_property_map.front(); F; F = F->next()) {
+ for (List<EditorProperty *>::Element *E = F->get().front(); E; E = E->next()) {
+ E->get()->update_property();
+ E->get()->update_reload_status();
+ }
+ }
+ }
+ }
+
+ changing++;
+
+ if (update_tree_pending) {
+
+ update_tree();
+ update_tree_pending = false;
+ pending.clear();
+
+ } else {
+
+ while (pending.size()) {
+ StringName prop = pending.front()->get();
+ if (editor_property_map.has(prop)) {
+ for (List<EditorProperty *>::Element *E = editor_property_map[prop].front(); E; E = E->next()) {
+ E->get()->update_property();
+ E->get()->update_reload_status();
+ }
+ }
+ pending.erase(pending.front());
+ }
+ }
+
+ changing--;
+ }
+
+ if (p_what == EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED) {
+ update_tree();
+ }
+}
+
+void EditorInspector::_changed_callback(Object *p_changed, const char *p_prop) {
+ //this is called when property change is notified via _change_notify()
+ _edit_request_change(p_changed, p_prop);
+}
+
+void EditorInspector::_bind_methods() {
+
+ ClassDB::bind_method("_multiple_properties_changed", &EditorInspector::_multiple_properties_changed);
+ ClassDB::bind_method("_property_changed", &EditorInspector::_property_changed);
+ ClassDB::bind_method("_edit_request_change", &EditorInspector::_edit_request_change);
+ ClassDB::bind_method("_node_removed", &EditorInspector::_node_removed);
+ ClassDB::bind_method("_filter_changed", &EditorInspector::_filter_changed);
+ ClassDB::bind_method("_property_keyed", &EditorInspector::_property_keyed);
+ ClassDB::bind_method("_property_checked", &EditorInspector::_property_checked);
+ ClassDB::bind_method("_property_selected", &EditorInspector::_property_selected);
+ ClassDB::bind_method("_resource_selected", &EditorInspector::_resource_selected);
+ ClassDB::bind_method("_object_id_selected", &EditorInspector::_object_id_selected);
+
+ ADD_SIGNAL(MethodInfo("property_keyed", PropertyInfo(Variant::STRING, "property")));
+ ADD_SIGNAL(MethodInfo("resource_selected", PropertyInfo(Variant::OBJECT, "res"), PropertyInfo(Variant::STRING, "prop")));
+ ADD_SIGNAL(MethodInfo("object_id_selected", PropertyInfo(Variant::INT, "id")));
+}
+
+EditorInspector::EditorInspector() {
+ object = NULL;
+ undo_redo = NULL;
+ main_vbox = memnew(VBoxContainer);
+ main_vbox->set_h_size_flags(SIZE_EXPAND_FILL);
+ add_child(main_vbox);
+ main_vbox->set_name("pipirulo");
+ set_h_scroll(false);
+ set_v_scroll(true);
+
+ show_categories = false;
+ hide_script = true;
+ use_doc_hints = false;
+ capitalize_paths = false;
+ use_filter = false;
+ autoclear = false;
+ changing = 0;
+ use_folding = false;
+ update_all_pending = false;
+ update_tree_pending = false;
+ refresh_countdown = 0;
+ read_only = false;
+ search_box = NULL;
+ keying = false;
+ _prop_edited = "property_edited";
+ set_process(true);
+ property_focusable = -1;
+}
diff --git a/editor/editor_inspector.h b/editor/editor_inspector.h
new file mode 100644
index 0000000000..64be316b0e
--- /dev/null
+++ b/editor/editor_inspector.h
@@ -0,0 +1,283 @@
+#ifndef EDITOR_INSPECTOR_H
+#define EDITOR_INSPECTOR_H
+
+#include "editor_data.h"
+#include "scene/gui/scroll_container.h"
+
+class EditorProperty : public Container {
+
+ GDCLASS(EditorProperty, Container)
+public:
+ enum LabelLayout {
+ LABEL_LAYOUT_LEFT,
+ LABEL_LAYOUT_TOP,
+ };
+
+private:
+ String label;
+ int text_size;
+ friend class EditorInspector;
+ Object *object;
+ StringName property;
+
+ LabelLayout label_layout;
+
+ int property_usage;
+
+ bool read_only;
+ bool checkable;
+ bool checked;
+ bool draw_red;
+ bool keying;
+
+ Rect2 keying_rect;
+ bool keying_hover;
+ Rect2 revert_rect;
+ bool revert_hover;
+ Rect2 check_rect;
+ bool check_hover;
+
+ bool can_revert;
+
+ bool _might_be_in_instance();
+ bool _is_property_different(const Variant &p_current, const Variant &p_orig, int p_usage);
+ bool _is_instanced_node_with_original_property_different();
+ bool _get_instanced_node_original_property(const StringName &p_prop, Variant &value);
+ void _focusable_focused(int p_index);
+
+ bool selected;
+ int selected_focusable;
+
+ Vector<Control *> focusables;
+ Control *label_reference;
+
+protected:
+ void _notification(int p_what);
+ static void _bind_methods();
+
+ void _gui_input(const Ref<InputEvent> &p_event);
+
+public:
+ virtual Size2 get_minimum_size() const;
+
+ void set_label(const String &p_label);
+ String get_label() const;
+
+ void set_read_only(bool p_read_only);
+ bool is_read_only() const;
+
+ Object *get_edited_object();
+ StringName get_edited_property();
+
+ virtual void update_property();
+ void update_reload_status();
+
+ virtual bool use_keying_next() const;
+
+ void set_checkable(bool p_checkable);
+ bool is_checkable() const;
+
+ void set_checked(bool p_checked);
+ bool is_checked() const;
+
+ void set_draw_red(bool p_draw_red);
+ bool is_draw_red() const;
+
+ void set_keying(bool p_keying);
+ bool is_keying() const;
+
+ void add_focusable(Control *p_control);
+ void select(int p_focusable = -1);
+ void deselect();
+ bool is_selected() const;
+
+ void set_label_reference(Control *p_control);
+
+ virtual Variant get_drag_data(const Point2 &p_point);
+
+ void set_label_layout(LabelLayout p_layout);
+ EditorProperty();
+};
+
+class EditorInspectorPlugin : public Reference {
+ GDCLASS(EditorInspectorPlugin, Reference)
+
+ friend class EditorInspector;
+ struct AddedEditor {
+ Control *property_editor;
+ Vector<String> properties;
+ String label;
+ };
+
+ List<AddedEditor> added_editors;
+
+protected:
+ static void _bind_methods();
+
+public:
+ void add_custom_control(Control *control);
+ void add_property_editor(const String &p_for_property, Control *p_prop);
+ void add_property_editor_for_multiple_properties(const String &p_label, const Vector<String> &p_properties, Control *p_prop);
+
+ virtual bool can_handle(Object *p_object);
+ virtual void parse_begin(Object *p_object);
+ virtual bool parse_property(Object *p_object, Variant::Type p_type, const String &p_path, PropertyHint p_hint, const String &p_hint_text, int p_usage);
+ virtual void parse_end();
+};
+
+class EditorInspectorCategory : public Control {
+ GDCLASS(EditorInspectorCategory, Control);
+
+ friend class EditorInspector;
+ Ref<Texture> icon;
+ String label;
+ Color bg_color;
+
+protected:
+ void _notification(int p_what);
+
+public:
+ virtual Size2 get_minimum_size() const;
+
+ EditorInspectorCategory();
+};
+
+class EditorInspectorSection : public Container {
+ GDCLASS(EditorInspectorSection, Container);
+
+ String label;
+ String section;
+ Object *object;
+ VBoxContainer *vbox;
+ Color bg_color;
+ bool foldable;
+
+protected:
+ void _notification(int p_what);
+ static void _bind_methods();
+ void _gui_input(const Ref<InputEvent> &p_event);
+
+public:
+ virtual Size2 get_minimum_size() const;
+
+ void setup(const String &p_section, const String &p_label, Object *p_object, const Color &p_bg_color, bool p_foldable);
+ VBoxContainer *get_vbox();
+ void unfold();
+ void fold();
+
+ Object *get_edited_object();
+
+ EditorInspectorSection();
+};
+
+class EditorInspector : public ScrollContainer {
+ GDCLASS(EditorInspector, ScrollContainer);
+
+ UndoRedo *undo_redo;
+ enum {
+ MAX_PLUGINS = 1024
+ };
+ static Ref<EditorInspectorPlugin> inspector_plugins[MAX_PLUGINS];
+ static int inspector_plugin_count;
+
+ VBoxContainer *main_vbox;
+
+ //map use to cache the instanced editors
+ Map<StringName, List<EditorProperty *> > editor_property_map;
+ List<EditorInspectorSection *> sections;
+ Set<StringName> pending;
+
+ void _clear();
+ Object *object;
+
+ //
+
+ LineEdit *search_box;
+ bool show_categories;
+ bool hide_script;
+ bool use_doc_hints;
+ bool capitalize_paths;
+ bool use_filter;
+ bool autoclear;
+ bool use_folding;
+ int changing;
+ bool update_all_pending;
+ bool read_only;
+ bool keying;
+
+ int refresh_countdown;
+ bool update_tree_pending;
+ StringName _prop_edited;
+ StringName property_selected;
+ int property_focusable;
+
+ Map<StringName, Map<StringName, String> > descr_cache;
+ Map<StringName, String> class_descr_cache;
+
+ void _edit_set(const String &p_name, const Variant &p_value, bool p_refresh_all, const String &p_changed_field);
+
+ void _property_changed(const String &p_path, const Variant &p_value);
+ void _multiple_properties_changed(Vector<String> p_paths, Array p_values);
+ void _property_keyed(const String &p_path);
+ void _property_checked(const String &p_path, bool p_checked);
+
+ void _resource_selected(const String &p_path, RES p_resource);
+ void _property_selected(const String &p_path, int p_focusable);
+ void _object_id_selected(const String &p_path, ObjectID p_id);
+
+ void _node_removed(Node *p_node);
+
+ void _changed_callback(Object *p_changed, const char *p_prop);
+ void _edit_request_change(Object *p_changed, const String &p_prop);
+
+ void _filter_changed(const String &p_text);
+
+protected:
+ static void _bind_methods();
+ void _notification(int p_what);
+
+public:
+ static void add_inspector_plugin(const Ref<EditorInspectorPlugin> &p_plugin);
+ static void remove_inspector_plugin(const Ref<EditorInspectorPlugin> &p_plugin);
+ static void cleanup_plugins();
+
+ void set_undo_redo(UndoRedo *p_undo_redo);
+
+ String get_selected_path() const;
+
+ void update_tree();
+ void update_property(const String &p_prop);
+
+ void refresh();
+
+ void edit(Object *p_object);
+
+ void set_keying(bool p_active);
+ void set_read_only(bool p_read_only);
+
+ bool is_capitalize_paths_enabled() const;
+ void set_enable_capitalize_paths(bool p_capitalize);
+ void set_autoclear(bool p_enable);
+
+ void set_show_categories(bool p_show);
+ void set_use_doc_hints(bool p_enable);
+ void set_hide_script(bool p_hide);
+
+ void set_use_filter(bool p_use);
+ void register_text_enter(Node *p_line_edit);
+
+ void set_subsection_selectable(bool p_selectable);
+ void set_property_selectable(bool p_selectable);
+
+ void set_use_folding(bool p_enable);
+
+ void collapse_all_folding();
+ void expand_all_folding();
+
+ void set_scroll_offset(int p_offset);
+ int get_scroll_offset() const;
+
+ EditorInspector();
+};
+
+#endif // INSPECTOR_H
diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index 3f0a09cfd9..49f70e3215 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -56,6 +56,7 @@
#include "editor/editor_file_system.h"
#include "editor/editor_help.h"
#include "editor/editor_initialize_ssl.h"
+#include "editor/editor_properties.h"
#include "editor/editor_settings.h"
#include "editor/editor_themes.h"
#include "editor/import/editor_import_collada.h"
@@ -548,8 +549,8 @@ void EditorNode::_vp_resized() {
void EditorNode::_node_renamed() {
- if (property_editor)
- property_editor->update_tree();
+ if (inspector)
+ inspector->update_tree();
}
void EditorNode::_editor_select_next() {
@@ -1351,7 +1352,7 @@ void EditorNode::_dialog_action(String p_file) {
void EditorNode::push_item(Object *p_object, const String &p_property) {
if (!p_object) {
- property_editor->edit(NULL);
+ inspector->edit(NULL);
node_dock->set_node(NULL);
scene_tree_dock->set_selected(NULL);
return;
@@ -1444,12 +1445,12 @@ void EditorNode::_property_editor_back() {
void EditorNode::_menu_collapseall() {
- property_editor->collapse_all_folding();
+ inspector->collapse_all_folding();
}
void EditorNode::_menu_expandall() {
- property_editor->expand_all_folding();
+ inspector->expand_all_folding();
}
void EditorNode::_save_default_environment() {
@@ -1515,7 +1516,7 @@ void EditorNode::_edit_current() {
if (!current_obj) {
scene_tree_dock->set_selected(NULL);
- property_editor->edit(NULL);
+ inspector->edit(NULL);
node_dock->set_node(NULL);
object_menu->set_disabled(true);
@@ -1536,7 +1537,7 @@ void EditorNode::_edit_current() {
Resource *current_res = Object::cast_to<Resource>(current_obj);
ERR_FAIL_COND(!current_res);
scene_tree_dock->set_selected(NULL);
- property_editor->edit(current_res);
+ inspector->edit(current_res);
node_dock->set_node(NULL);
object_menu->set_disabled(false);
EditorNode::get_singleton()->get_import_dock()->set_edit_path(current_res->get_path());
@@ -1561,7 +1562,7 @@ void EditorNode::_edit_current() {
Node *current_node = Object::cast_to<Node>(current_obj);
ERR_FAIL_COND(!current_node);
- property_editor->edit(current_node);
+ inspector->edit(current_node);
if (current_node->is_inside_tree()) {
node_dock->set_node(current_node);
scene_tree_dock->set_selected(current_node);
@@ -1585,7 +1586,7 @@ void EditorNode::_edit_current() {
capitalize = false;
}
- property_editor->edit(current_obj);
+ inspector->edit(current_obj);
node_dock->set_node(NULL);
}
@@ -1594,8 +1595,8 @@ void EditorNode::_edit_current() {
property_editable_warning_dialog->set_text(editable_warning);
}
- if (property_editor->is_capitalize_paths_enabled() != capitalize) {
- property_editor->set_enable_capitalize_paths(capitalize);
+ if (inspector->is_capitalize_paths_enabled() != capitalize) {
+ inspector->set_enable_capitalize_paths(capitalize);
}
/* Take care of PLUGIN EDITOR */
@@ -2939,7 +2940,7 @@ Dictionary EditorNode::_get_main_scene_state() {
Dictionary state;
state["main_tab"] = _get_current_main_editor();
state["scene_tree_offset"] = scene_tree_dock->get_tree_editor()->get_scene_tree()->get_vscroll_bar()->get_value();
- state["property_edit_offset"] = get_property_editor()->get_scene_tree()->get_vscroll_bar()->get_value();
+ state["property_edit_offset"] = get_inspector()->get_scroll_offset();
state["saved_version"] = saved_version;
state["node_filter"] = scene_tree_dock->get_filter();
return state;
@@ -2985,7 +2986,7 @@ void EditorNode::_set_main_scene_state(Dictionary p_state, Node *p_for_scene) {
if (p_state.has("scene_tree_offset"))
scene_tree_dock->get_tree_editor()->get_scene_tree()->get_vscroll_bar()->set_value(p_state["scene_tree_offset"]);
if (p_state.has("property_edit_offset"))
- get_property_editor()->get_scene_tree()->get_vscroll_bar()->set_value(p_state["property_edit_offset"]);
+ get_inspector()->set_scroll_offset(p_state["property_edit_offset"]);
if (p_state.has("node_filter"))
scene_tree_dock->set_filter(p_state["node_filter"]);
@@ -3278,9 +3279,7 @@ void EditorNode::update_keying() {
}
}
- property_editor->set_keying(valid);
-
- AnimationPlayerEditor::singleton->get_key_editor()->update_keying();
+ inspector->set_keying(valid);
}
void EditorNode::_close_messages() {
@@ -3425,6 +3424,9 @@ void EditorNode::register_editor_types() {
ClassDB::register_class<EditorExportPlugin>();
ClassDB::register_class<EditorResourceConversionPlugin>();
ClassDB::register_class<EditorSceneImporter>();
+ ClassDB::register_class<EditorInspector>();
+ ClassDB::register_class<EditorInspectorPlugin>();
+ ClassDB::register_class<EditorProperty>();
// FIXME: Is this stuff obsolete, or should it be ported to new APIs?
ClassDB::register_class<EditorScenePostImport>();
@@ -4236,7 +4238,7 @@ void EditorNode::_scene_tab_changed(int p_tab) {
void EditorNode::_toggle_search_bar(bool p_pressed) {
- property_editor->set_use_filter(p_pressed);
+ inspector->set_use_filter(p_pressed);
if (p_pressed) {
@@ -4255,7 +4257,7 @@ void EditorNode::_clear_search_box() {
return;
search_box->clear();
- property_editor->update_tree();
+ inspector->update_tree();
}
ToolButton *EditorNode::add_bottom_panel_item(String p_text, Control *p_item) {
@@ -5007,6 +5009,12 @@ EditorNode::EditorNode() {
ResourceFormatImporter::get_singleton()->add_importer(import_bitmap);
}
+ {
+ Ref<EditorInspectorDefaultPlugin> eidp;
+ eidp.instance();
+ EditorInspector::add_inspector_plugin(eidp);
+ }
+
_pvrtc_register_compressors();
editor_selection = memnew(EditorSelection);
@@ -5665,21 +5673,21 @@ EditorNode::EditorNode() {
property_editable_warning->hide();
property_editable_warning->connect("pressed", this, "_property_editable_warning_pressed");
- property_editor = memnew(PropertyEditor);
- property_editor->set_autoclear(true);
- property_editor->set_show_categories(true);
- property_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL);
- property_editor->set_use_doc_hints(true);
- property_editor->set_hide_script(false);
- property_editor->set_enable_capitalize_paths(bool(EDITOR_DEF("interface/editor/capitalize_properties", true)));
- property_editor->set_use_folding(!bool(EDITOR_DEF("interface/editor/disable_inspector_folding", false)));
+ inspector = memnew(EditorInspector);
+ inspector->set_autoclear(true);
+ inspector->set_show_categories(true);
+ inspector->set_v_size_flags(Control::SIZE_EXPAND_FILL);
+ inspector->set_use_doc_hints(true);
+ inspector->set_hide_script(false);
+ inspector->set_enable_capitalize_paths(bool(EDITOR_DEF("interface/editor/capitalize_properties", true)));
+ inspector->set_use_folding(!bool(EDITOR_DEF("interface/editor/disable_inspector_folding", false)));
- property_editor->hide_top_label();
- property_editor->register_text_enter(search_box);
+ // inspector->hide_top_label();
+ inspector->register_text_enter(search_box);
Button *property_editable_warning;
- prop_editor_base->add_child(property_editor);
- property_editor->set_undo_redo(&editor_data.get_undo_redo());
+ prop_editor_base->add_child(inspector);
+ inspector->set_undo_redo(&editor_data.get_undo_redo());
import_dock = memnew(ImportDock);
dock_slot[DOCK_SLOT_RIGHT_UL]->add_child(import_dock);
@@ -5815,8 +5823,8 @@ EditorNode::EditorNode() {
file->connect("file_selected", this, "_dialog_action");
file_templates->connect("file_selected", this, "_dialog_action");
- property_editor->connect("resource_selected", this, "_resource_selected");
- property_editor->connect("property_keyed", this, "_property_keyed");
+ inspector->connect("resource_selected", this, "_resource_selected");
+ inspector->connect("property_keyed", this, "_property_keyed");
//plugin stuff
@@ -6039,6 +6047,8 @@ EditorNode::EditorNode() {
EditorNode::~EditorNode() {
+ EditorInspector::cleanup_plugins();
+
remove_print_handler(&print_handler);
memdelete(EditorHelp::get_doc_data());
memdelete(editor_selection);
diff --git a/editor/editor_node.h b/editor/editor_node.h
index f774fa0a2e..86b85663ab 100644
--- a/editor/editor_node.h
+++ b/editor/editor_node.h
@@ -37,6 +37,7 @@
#include "editor/editor_about.h"
#include "editor/editor_data.h"
#include "editor/editor_export.h"
+#include "editor/editor_inspector.h"
#include "editor/editor_log.h"
#include "editor/editor_name_dialog.h"
#include "editor/editor_path.h"
@@ -80,7 +81,6 @@
#include "scene/gui/tool_button.h"
#include "scene/gui/tree.h"
#include "scene/gui/viewport_container.h"
-
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
@@ -267,7 +267,7 @@ private:
Button *property_back;
Button *property_forward;
SceneTreeDock *scene_tree_dock;
- PropertyEditor *property_editor;
+ EditorInspector *inspector;
Button *property_editable_warning;
AcceptDialog *property_editable_warning_dialog;
void _property_editable_warning_pressed();
@@ -640,7 +640,7 @@ public:
EditorPluginList *get_editor_plugins_over() { return editor_plugins_over; }
EditorPluginList *get_editor_plugins_force_over() { return editor_plugins_force_over; }
EditorPluginList *get_editor_plugins_force_input_forwarding() { return editor_plugins_force_input_forwarding; }
- PropertyEditor *get_property_editor() { return property_editor; }
+ EditorInspector *get_inspector() { return inspector; }
VBoxContainer *get_property_editor_vb() { return prop_editor_vb; }
ProjectSettingsEditor *get_project_settings() { return project_settings; }
diff --git a/editor/editor_properties.cpp b/editor/editor_properties.cpp
new file mode 100644
index 0000000000..51be64bd3f
--- /dev/null
+++ b/editor/editor_properties.cpp
@@ -0,0 +1,2411 @@
+#include "editor_properties.h"
+#include "editor/editor_resource_preview.h"
+#include "editor_node.h"
+#include "scene/main/viewport.h"
+///////////////////// TEXT /////////////////////////
+void EditorPropertyText::_text_changed(const String &p_string) {
+ if (updating)
+ return;
+
+ emit_signal("property_changed", get_edited_property(), p_string);
+}
+
+void EditorPropertyText::update_property() {
+ String s = get_edited_object()->get(get_edited_property());
+ updating = true;
+ text->set_text(s);
+ text->set_editable(!is_read_only());
+ updating = false;
+}
+
+void EditorPropertyText::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_text_changed", "txt"), &EditorPropertyText::_text_changed);
+}
+
+EditorPropertyText::EditorPropertyText() {
+ text = memnew(LineEdit);
+ add_child(text);
+ add_focusable(text);
+ text->connect("text_changed", this, "_text_changed");
+ updating = false;
+}
+
+///////////////////// MULTILINE TEXT /////////////////////////
+
+void EditorPropertyMultilineText::_big_text_changed() {
+ text->set_text(big_text->get_text());
+ emit_signal("property_changed", get_edited_property(), big_text->get_text());
+}
+
+void EditorPropertyMultilineText::_text_changed() {
+
+ emit_signal("property_changed", get_edited_property(), text->get_text());
+}
+
+void EditorPropertyMultilineText::_open_big_text() {
+
+ if (!big_text_dialog) {
+ big_text = memnew(TextEdit);
+ big_text->connect("text_changed", this, "_big_text_changed");
+ big_text_dialog = memnew(AcceptDialog);
+ big_text_dialog->add_child(big_text);
+ big_text_dialog->set_title("Edit Text:");
+ add_child(big_text_dialog);
+ }
+
+ big_text->set_text(text->get_text());
+ big_text_dialog->popup_centered_ratio();
+}
+
+void EditorPropertyMultilineText::update_property() {
+ String t = get_edited_object()->get(get_edited_property());
+ text->set_text(t);
+ if (big_text && big_text->is_visible_in_tree()) {
+ big_text->set_text(t);
+ }
+}
+
+void EditorPropertyMultilineText::_notification(int p_what) {
+ switch (p_what) {
+ case NOTIFICATION_THEME_CHANGED:
+ case NOTIFICATION_ENTER_TREE: {
+ Ref<Texture> df = get_icon("DistractionFree", "EditorIcons");
+ open_big_text->set_icon(df);
+ Ref<Font> font = get_font("font", "Label");
+ text->set_custom_minimum_size(Vector2(0, font->get_height() * 6));
+
+ } break;
+ }
+}
+
+void EditorPropertyMultilineText::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_text_changed"), &EditorPropertyMultilineText::_text_changed);
+ ClassDB::bind_method(D_METHOD("_big_text_changed"), &EditorPropertyMultilineText::_big_text_changed);
+ ClassDB::bind_method(D_METHOD("_open_big_text"), &EditorPropertyMultilineText::_open_big_text);
+}
+
+EditorPropertyMultilineText::EditorPropertyMultilineText() {
+ HBoxContainer *hb = memnew(HBoxContainer);
+ set_label_layout(LABEL_LAYOUT_TOP);
+ add_child(hb);
+ text = memnew(TextEdit);
+ text->connect("text_changed", this, "_text_changed");
+ add_focusable(text);
+ hb->add_child(text);
+ text->set_h_size_flags(SIZE_EXPAND_FILL);
+ open_big_text = memnew(ToolButton);
+ open_big_text->connect("pressed", this, "_open_big_text");
+ hb->add_child(open_big_text);
+ big_text_dialog = NULL;
+ big_text = NULL;
+}
+
+///////////////////// TEXT ENUM /////////////////////////
+
+void EditorPropertyTextEnum::_option_selected(int p_which) {
+
+ emit_signal("property_changed", get_edited_property(), options->get_item_text(p_which));
+}
+
+void EditorPropertyTextEnum::update_property() {
+
+ String which = get_edited_object()->get(get_edited_property());
+ for (int i = 0; i < options->get_item_count(); i++) {
+ String t = options->get_item_text(i);
+ if (t == which) {
+ options->select(i);
+ return;
+ }
+ }
+}
+
+void EditorPropertyTextEnum::setup(const Vector<String> &p_options) {
+ for (int i = 0; i < p_options.size(); i++) {
+ options->add_item(p_options[i], i);
+ }
+}
+
+void EditorPropertyTextEnum::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_option_selected"), &EditorPropertyTextEnum::_option_selected);
+}
+
+EditorPropertyTextEnum::EditorPropertyTextEnum() {
+ options = memnew(OptionButton);
+ options->set_clip_text(true);
+ add_child(options);
+ add_focusable(options);
+ options->connect("item_selected", this, "_option_selected");
+}
+///////////////////// PATH /////////////////////////
+
+void EditorPropertyPath::_path_selected(const String &p_path) {
+
+ emit_signal("property_changed", get_edited_property(), p_path);
+ update_property();
+}
+void EditorPropertyPath::_path_pressed() {
+
+ if (!dialog) {
+ dialog = memnew(EditorFileDialog);
+ dialog->connect("file_selected", this, "_path_selected");
+ dialog->connect("dir_selected", this, "_path_selected");
+ add_child(dialog);
+ }
+
+ String full_path = get_edited_object()->get(get_edited_property());
+
+ dialog->clear_filters();
+
+ if (global) {
+ dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
+ } else {
+ dialog->set_access(EditorFileDialog::ACCESS_RESOURCES);
+ }
+
+ if (folder) {
+ dialog->set_mode(EditorFileDialog::MODE_OPEN_DIR);
+ dialog->set_current_dir(full_path);
+ } else {
+ dialog->set_mode(EditorFileDialog::MODE_OPEN_FILE);
+ for (int i = 0; i < extensions.size(); i++) {
+ String e = extensions[i].strip_edges();
+ if (e != String()) {
+ dialog->add_filter(extensions[i].strip_edges());
+ }
+ }
+ dialog->set_current_path(full_path);
+ }
+
+ dialog->popup_centered_ratio();
+}
+
+void EditorPropertyPath::update_property() {
+
+ String full_path = get_edited_object()->get(get_edited_property());
+ path->set_text(full_path);
+ path->set_tooltip(full_path);
+}
+
+void EditorPropertyPath::setup(const Vector<String> &p_extensions, bool p_folder, bool p_global) {
+
+ extensions = p_extensions;
+ folder = p_folder;
+ global = p_global;
+}
+
+void EditorPropertyPath::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_path_pressed"), &EditorPropertyPath::_path_pressed);
+ ClassDB::bind_method(D_METHOD("_path_selected"), &EditorPropertyPath::_path_selected);
+}
+
+EditorPropertyPath::EditorPropertyPath() {
+ path = memnew(Button);
+ path->set_clip_text(true);
+ add_child(path);
+ add_focusable(path);
+ dialog = NULL;
+ path->connect("pressed", this, "_path_pressed");
+ folder = false;
+ global = false;
+}
+
+///////////////////// MEMBER /////////////////////////
+
+void EditorPropertyMember::_property_selected(const String &p_selected) {
+
+ emit_signal("property_changed", get_edited_property(), p_selected);
+ update_property();
+}
+
+void EditorPropertyMember::_property_select() {
+
+ if (!selector) {
+ selector = memnew(PropertySelector);
+ selector->connect("selected", this, "_property_selected");
+ add_child(selector);
+ }
+
+ String current = get_edited_object()->get(get_edited_property());
+
+ if (hint == MEMBER_METHOD_OF_VARIANT_TYPE) {
+
+ Variant::Type type = Variant::NIL;
+ for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+ if (hint_text == Variant::get_type_name(Variant::Type(i))) {
+ type = Variant::Type(i);
+ }
+ }
+ if (type)
+ selector->select_method_from_basic_type(type, current);
+
+ } else if (hint == MEMBER_METHOD_OF_BASE_TYPE) {
+
+ selector->select_method_from_base_type(hint_text, current);
+
+ } else if (hint == MEMBER_METHOD_OF_INSTANCE) {
+
+ Object *instance = ObjectDB::get_instance(hint_text.to_int64());
+ if (instance)
+ selector->select_method_from_instance(instance, current);
+
+ } else if (hint == MEMBER_METHOD_OF_SCRIPT) {
+
+ Object *obj = ObjectDB::get_instance(hint_text.to_int64());
+ if (Object::cast_to<Script>(obj)) {
+ selector->select_method_from_script(Object::cast_to<Script>(obj), current);
+ }
+
+ } else if (hint == MEMBER_PROPERTY_OF_VARIANT_TYPE) {
+
+ Variant::Type type = Variant::NIL;
+ String tname = hint_text;
+ if (tname.find(".") != -1)
+ tname = tname.get_slice(".", 0);
+ for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+ if (tname == Variant::get_type_name(Variant::Type(i))) {
+ type = Variant::Type(Variant::Type(i));
+ }
+ }
+
+ if (type != Variant::NIL)
+ selector->select_property_from_basic_type(type, current);
+
+ } else if (hint == MEMBER_PROPERTY_OF_BASE_TYPE) {
+
+ selector->select_property_from_base_type(hint_text, current);
+
+ } else if (hint == MEMBER_PROPERTY_OF_INSTANCE) {
+
+ Object *instance = ObjectDB::get_instance(hint_text.to_int64());
+ if (instance)
+ selector->select_property_from_instance(instance, current);
+
+ } else if (hint == MEMBER_PROPERTY_OF_SCRIPT) {
+
+ Object *obj = ObjectDB::get_instance(hint_text.to_int64());
+ if (Object::cast_to<Script>(obj)) {
+ selector->select_property_from_script(Object::cast_to<Script>(obj), current);
+ }
+ }
+}
+
+void EditorPropertyMember::setup(Type p_hint, const String &p_hint_text) {
+ hint = p_hint;
+ hint_text = p_hint_text;
+}
+
+void EditorPropertyMember::update_property() {
+
+ String full_path = get_edited_object()->get(get_edited_property());
+ property->set_text(full_path);
+}
+
+void EditorPropertyMember::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("_property_selected"), &EditorPropertyMember::_property_selected);
+ ClassDB::bind_method(D_METHOD("_property_select"), &EditorPropertyMember::_property_select);
+}
+
+EditorPropertyMember::EditorPropertyMember() {
+ selector = NULL;
+ property = memnew(Button);
+ property->set_clip_text(true);
+ add_child(property);
+ add_focusable(property);
+ property->connect("pressed", this, "_property_select");
+}
+
+///////////////////// CHECK /////////////////////////
+void EditorPropertyCheck::_checkbox_pressed() {
+
+ emit_signal("property_changed", get_edited_property(), checkbox->is_pressed());
+}
+
+void EditorPropertyCheck::update_property() {
+ bool c = get_edited_object()->get(get_edited_property());
+ checkbox->set_pressed(c);
+ checkbox->set_disabled(is_read_only());
+}
+
+void EditorPropertyCheck::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_checkbox_pressed"), &EditorPropertyCheck::_checkbox_pressed);
+}
+
+EditorPropertyCheck::EditorPropertyCheck() {
+ checkbox = memnew(CheckBox);
+ checkbox->set_text(TTR("On"));
+ add_child(checkbox);
+ add_focusable(checkbox);
+ checkbox->connect("pressed", this, "_checkbox_pressed");
+}
+
+///////////////////// ENUM /////////////////////////
+
+void EditorPropertyEnum::_option_selected(int p_which) {
+
+ emit_signal("property_changed", get_edited_property(), p_which);
+}
+
+void EditorPropertyEnum::update_property() {
+
+ int which = get_edited_object()->get(get_edited_property());
+ options->select(which);
+}
+
+void EditorPropertyEnum::setup(const Vector<String> &p_options) {
+ for (int i = 0; i < p_options.size(); i++) {
+ options->add_item(p_options[i], i);
+ }
+}
+
+void EditorPropertyEnum::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_option_selected"), &EditorPropertyEnum::_option_selected);
+}
+
+EditorPropertyEnum::EditorPropertyEnum() {
+ options = memnew(OptionButton);
+ options->set_clip_text(true);
+ add_child(options);
+ add_focusable(options);
+ options->connect("item_selected", this, "_option_selected");
+}
+
+///////////////////// FLAGS /////////////////////////
+
+void EditorPropertyFlags::_flag_toggled() {
+
+ uint32_t value = 0;
+ for (int i = 0; i < flags.size(); i++) {
+ if (flags[i]->is_pressed()) {
+ uint32_t val = 1;
+ val <<= flag_indices[i];
+ value |= val;
+ }
+ }
+
+ emit_signal("property_changed", get_edited_property(), value);
+}
+
+void EditorPropertyFlags::update_property() {
+
+ uint32_t value = get_edited_object()->get(get_edited_property());
+
+ for (int i = 0; i < flags.size(); i++) {
+ uint32_t val = 1;
+ val <<= flag_indices[i];
+ if (value & val) {
+
+ flags[i]->set_pressed(true);
+ } else {
+ flags[i]->set_pressed(false);
+ }
+ }
+}
+
+void EditorPropertyFlags::setup(const Vector<String> &p_options) {
+ ERR_FAIL_COND(flags.size());
+
+ bool first = true;
+ for (int i = 0; i < p_options.size(); i++) {
+ String option = p_options[i].strip_edges();
+ if (option != "") {
+ CheckBox *cb = memnew(CheckBox);
+ cb->set_text(option);
+ cb->set_clip_text(true);
+ cb->connect("pressed", this, "_flag_toggled");
+ add_focusable(cb);
+ vbox->add_child(cb);
+ flags.push_back(cb);
+ flag_indices.push_back(i);
+ if (first) {
+ set_label_reference(cb);
+ first = false;
+ }
+ }
+ }
+}
+
+void EditorPropertyFlags::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_flag_toggled"), &EditorPropertyFlags::_flag_toggled);
+}
+
+EditorPropertyFlags::EditorPropertyFlags() {
+
+ vbox = memnew(VBoxContainer);
+ add_child(vbox);
+}
+
+///////////////////// LAYERS /////////////////////////
+
+class EditorPropertyLayersGrid : public Control {
+ GDCLASS(EditorPropertyLayersGrid, Control)
+public:
+ uint32_t value;
+ Vector<Rect2> flag_rects;
+ Vector<String> names;
+
+ virtual Size2 get_minimum_size() const {
+ Ref<Font> font = get_font("font", "Label");
+ return Vector2(0, font->get_height() * 2);
+ }
+
+ virtual String get_tooltip(const Point2 &p_pos) const {
+ for (int i = 0; i < flag_rects.size(); i++) {
+ if (flag_rects[i].has_point(p_pos) && i < names.size()) {
+ return names[i];
+ }
+ }
+ return String();
+ }
+ void _gui_input(const Ref<InputEvent> &p_ev) {
+ Ref<InputEventMouseButton> mb = p_ev;
+ if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) {
+ for (int i = 0; i < flag_rects.size(); i++) {
+ if (flag_rects[i].has_point(mb->get_position())) {
+ //toggle
+ if (value & (1 << i)) {
+ value &= ~(1 << i);
+ } else {
+ value |= (1 << i);
+ }
+ emit_signal("flag_changed", value);
+ update();
+ }
+ }
+ }
+ }
+
+ void _notification(int p_what) {
+ if (p_what == NOTIFICATION_DRAW) {
+
+ Rect2 rect;
+ rect.size = get_size();
+ flag_rects.clear();
+
+ int bsize = (rect.size.height * 80 / 100) / 2;
+
+ int h = bsize * 2 + 1;
+ int vofs = (rect.size.height - h) / 2;
+
+ for (int i = 0; i < 2; i++) {
+
+ Point2 ofs(4, vofs);
+ if (i == 1)
+ ofs.y += bsize + 1;
+
+ ofs += rect.position;
+ for (int j = 0; j < 10; j++) {
+
+ Point2 o = ofs + Point2(j * (bsize + 1), 0);
+ if (j >= 5)
+ o.x += 1;
+
+ uint32_t idx = i * 10 + j;
+ bool on = value & (1 << idx);
+ Rect2 rect = Rect2(o, Size2(bsize, bsize));
+ draw_rect(rect, Color(0, 0, 0, on ? 0.8 : 0.3));
+ flag_rects.push_back(rect);
+ }
+ }
+ }
+ }
+
+ void set_flag(uint32_t p_flag) {
+ value = p_flag;
+ update();
+ }
+
+ static void _bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_gui_input"), &EditorPropertyLayersGrid::_gui_input);
+ ADD_SIGNAL(MethodInfo("flag_changed", PropertyInfo(Variant::INT, "flag")));
+ }
+
+ EditorPropertyLayersGrid() {
+ value = 0;
+ }
+};
+void EditorPropertyLayers::_grid_changed(uint32_t p_grid) {
+
+ emit_signal("property_changed", get_edited_property(), p_grid);
+}
+
+void EditorPropertyLayers::update_property() {
+
+ uint32_t value = get_edited_object()->get(get_edited_property());
+
+ grid->set_flag(value);
+}
+
+void EditorPropertyLayers::setup(LayerType p_layer_type) {
+
+ String basename;
+ switch (p_layer_type) {
+ case LAYER_RENDER_2D:
+ basename = "layer_names/2d_render";
+ break;
+ case LAYER_PHYSICS_2D:
+ basename = "layer_names/2d_physics";
+ break;
+ case LAYER_RENDER_3D:
+ basename = "layer_names/3d_render";
+ break;
+ case LAYER_PHYSICS_3D:
+ basename = "layer_names/3d_physics";
+ break;
+ }
+
+ Vector<String> names;
+ for (int i = 0; i < 20; i++) {
+ String name;
+
+ if (ProjectSettings::get_singleton()->has_setting(basename + "/layer_" + itos(i + 1))) {
+ name = ProjectSettings::get_singleton()->get(basename + "/layer_" + itos(i + 1));
+ }
+
+ if (name == "") {
+ name = "Layer " + itos(i + 1);
+ }
+
+ names.push_back(name);
+ }
+
+ grid->names = names;
+}
+
+void EditorPropertyLayers::_button_pressed() {
+
+ layers->clear();
+ for (int i = 0; i < 20; i++) {
+ if (i == 5 || i == 10 || i == 15) {
+ layers->add_separator();
+ }
+ layers->add_check_item(grid->names[i], i);
+ int idx = layers->get_item_index(i);
+ layers->set_item_checked(idx, grid->value & (1 << i));
+ }
+
+ Rect2 gp = button->get_global_rect();
+ Vector2 popup_pos = gp.position - Vector2(layers->get_combined_minimum_size().x, 0);
+ layers->set_global_position(popup_pos);
+ layers->popup();
+}
+
+void EditorPropertyLayers::_menu_pressed(int p_menu) {
+ if (grid->value & (1 << p_menu)) {
+ grid->value &= ~(1 << p_menu);
+ } else {
+ grid->value |= (1 << p_menu);
+ }
+ grid->update();
+ _grid_changed(grid->value);
+}
+
+void EditorPropertyLayers::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_grid_changed"), &EditorPropertyLayers::_grid_changed);
+ ClassDB::bind_method(D_METHOD("_button_pressed"), &EditorPropertyLayers::_button_pressed);
+ ClassDB::bind_method(D_METHOD("_menu_pressed"), &EditorPropertyLayers::_menu_pressed);
+}
+
+EditorPropertyLayers::EditorPropertyLayers() {
+
+ HBoxContainer *hb = memnew(HBoxContainer);
+ add_child(hb);
+ grid = memnew(EditorPropertyLayersGrid);
+ grid->connect("flag_changed", this, "_grid_changed");
+ grid->set_h_size_flags(SIZE_EXPAND_FILL);
+ hb->add_child(grid);
+ button = memnew(Button);
+ button->set_text("..");
+ button->connect("pressed", this, "_button_pressed");
+ hb->add_child(button);
+ set_label_layout(LABEL_LAYOUT_TOP);
+ layers = memnew(PopupMenu);
+ add_child(layers);
+ layers->connect("id_pressed", this, "_menu_pressed");
+}
+///////////////////// INT /////////////////////////
+
+void EditorPropertyInteger::_value_changed(double val) {
+ if (setting)
+ return;
+ emit_signal("property_changed", get_edited_property(), int(val));
+}
+
+void EditorPropertyInteger::update_property() {
+ int val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin->set_value(val);
+ setting = false;
+}
+
+void EditorPropertyInteger::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyInteger::_value_changed);
+}
+
+void EditorPropertyInteger::setup(int p_min, int p_max) {
+ spin->set_min(p_min);
+ spin->set_max(p_max);
+ spin->set_step(1);
+}
+
+EditorPropertyInteger::EditorPropertyInteger() {
+ spin = memnew(EditorSpinSlider);
+ add_child(spin);
+ add_focusable(spin);
+ spin->connect("value_changed", this, "_value_changed");
+ setting = false;
+}
+
+///////////////////// OBJECT ID /////////////////////////
+
+void EditorPropertyObjectID::_edit_pressed() {
+
+ emit_signal("object_id_selected", get_edited_property(), get_edited_object()->get(get_edited_property()));
+}
+
+void EditorPropertyObjectID::update_property() {
+ String type = base_type;
+ if (type == "")
+ type = "Object";
+
+ String icon_type = type;
+ if (has_icon(icon_type, "EditorIcons")) {
+ type = icon_type;
+ } else {
+ type = "Object";
+ }
+
+ ObjectID id = get_edited_object()->get(get_edited_property());
+ if (id != 0) {
+ edit->set_text(type + " ID: " + itos(id));
+ edit->set_disabled(false);
+ edit->set_icon(get_icon(icon_type, "EditorIcons"));
+ } else {
+ edit->set_text(TTR("[Empty]"));
+ edit->set_disabled(true);
+ edit->set_icon(Ref<Texture>());
+ }
+}
+
+void EditorPropertyObjectID::setup(const String &p_base_type) {
+ base_type = p_base_type;
+}
+
+void EditorPropertyObjectID::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("_edit_pressed"), &EditorPropertyObjectID::_edit_pressed);
+}
+
+EditorPropertyObjectID::EditorPropertyObjectID() {
+ edit = memnew(Button);
+ add_child(edit);
+ add_focusable(edit);
+ edit->connect("pressed", this, "_edit_pressed");
+}
+
+///////////////////// FLOAT /////////////////////////
+
+void EditorPropertyFloat::_value_changed(double val) {
+ if (setting)
+ return;
+
+ emit_signal("property_changed", get_edited_property(), val);
+}
+
+void EditorPropertyFloat::update_property() {
+ double val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin->set_value(val);
+ setting = false;
+}
+
+void EditorPropertyFloat::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyFloat::_value_changed);
+}
+
+void EditorPropertyFloat::setup(double p_min, double p_max, double p_step, bool p_no_slider, bool p_exp_range) {
+
+ spin->set_min(p_min);
+ spin->set_max(p_max);
+ spin->set_step(p_step);
+ spin->set_hide_slider(p_no_slider);
+ spin->set_exp_ratio(p_exp_range);
+}
+
+EditorPropertyFloat::EditorPropertyFloat() {
+ spin = memnew(EditorSpinSlider);
+ add_child(spin);
+ add_focusable(spin);
+ spin->connect("value_changed", this, "_value_changed");
+ setting = false;
+}
+
+///////////////////// EASING /////////////////////////
+
+void EditorPropertyEasing::_drag_easing(const Ref<InputEvent> &p_ev) {
+
+ Ref<InputEventMouseMotion> mm = p_ev;
+
+ if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_LEFT) {
+
+ float rel = mm->get_relative().x;
+ if (rel == 0)
+ return;
+
+ if (flip)
+ rel = -rel;
+
+ float val = get_edited_object()->get(get_edited_property());
+ if (val == 0)
+ return;
+ bool sg = val < 0;
+ val = Math::absf(val);
+
+ val = Math::log(val) / Math::log((float)2.0);
+ //logspace
+ val += rel * 0.05;
+
+ val = Math::pow(2.0f, val);
+ if (sg)
+ val = -val;
+
+ emit_signal("property_changed", get_edited_property(), val);
+ easing_draw->update();
+ }
+}
+
+void EditorPropertyEasing::_draw_easing() {
+
+ RID ci = easing_draw->get_canvas_item();
+
+ Size2 s = easing_draw->get_size();
+ Rect2 r(Point2(), s);
+ r = r.grow(3);
+ get_stylebox("normal", "LineEdit")->draw(ci, r);
+
+ int points = 48;
+
+ float prev = 1.0;
+ float exp = get_edited_object()->get(get_edited_property());
+
+ Ref<Font> f = get_font("font", "Label");
+ Color color = get_color("font_color", "Label");
+
+ for (int i = 1; i <= points; i++) {
+
+ float ifl = i / float(points);
+ float iflp = (i - 1) / float(points);
+
+ float h = 1.0 - Math::ease(ifl, exp);
+
+ if (flip) {
+ ifl = 1.0 - ifl;
+ iflp = 1.0 - iflp;
+ }
+
+ VisualServer::get_singleton()->canvas_item_add_line(ci, Point2(iflp * s.width, prev * s.height), Point2(ifl * s.width, h * s.height), color);
+ prev = h;
+ }
+
+ f->draw(ci, Point2(10, 10 + f->get_ascent()), String::num(exp, 2), color);
+}
+
+void EditorPropertyEasing::update_property() {
+ easing_draw->update();
+}
+
+void EditorPropertyEasing::_set_preset(float p_val) {
+ emit_signal("property_changed", get_edited_property(), p_val);
+ easing_draw->update();
+}
+
+void EditorPropertyEasing::setup(bool p_full, bool p_flip) {
+
+ flip = p_flip;
+ if (p_full) {
+ HBoxContainer *hb2 = memnew(HBoxContainer);
+ vb->add_child(hb2);
+ button_out_in = memnew(ToolButton);
+ button_out_in->set_tooltip(TTR("Out-In"));
+ button_out_in->set_h_size_flags(SIZE_EXPAND_FILL);
+ button_out_in->connect("pressed", this, "_set_preset", varray(-0.5));
+ hb2->add_child(button_out_in);
+
+ button_in_out = memnew(ToolButton);
+ button_in_out->set_tooltip(TTR("In"));
+ button_in_out->set_h_size_flags(SIZE_EXPAND_FILL);
+ button_in_out->connect("pressed", this, "_set_preset", varray(-2));
+ hb2->add_child(button_in_out);
+ }
+}
+
+void EditorPropertyEasing::_notification(int p_what) {
+
+ switch (p_what) {
+ case NOTIFICATION_THEME_CHANGED:
+ case NOTIFICATION_ENTER_TREE: {
+ easing_draw->set_custom_minimum_size(Size2(0, get_font("font", "Label")->get_height() * 2));
+ button_linear->set_icon(get_icon("CurveLinear", "EditorIcons"));
+ button_out->set_icon(get_icon("CurveOut", "EditorIcons"));
+ button_in->set_icon(get_icon("CurveIn", "EditorIcons"));
+ button_constant->set_icon(get_icon("CurveConstant", "EditorIcons"));
+ if (button_out_in)
+ button_out_in->set_icon(get_icon("CurveOutIn", "EditorIcons"));
+ if (button_in_out)
+ button_in_out->set_icon(get_icon("CurveInOut", "EditorIcons"));
+ } break;
+ }
+}
+
+void EditorPropertyEasing::_bind_methods() {
+
+ ClassDB::bind_method("_draw_easing", &EditorPropertyEasing::_draw_easing);
+ ClassDB::bind_method("_drag_easing", &EditorPropertyEasing::_drag_easing);
+ ClassDB::bind_method("_set_preset", &EditorPropertyEasing::_set_preset);
+}
+
+EditorPropertyEasing::EditorPropertyEasing() {
+
+ vb = memnew(VBoxContainer);
+ add_child(vb);
+ HBoxContainer *hb = memnew(HBoxContainer);
+ set_label_reference(hb);
+
+ vb->add_child(hb);
+
+ button_linear = memnew(ToolButton);
+ button_linear->set_tooltip(TTR("Linear"));
+ button_linear->set_h_size_flags(SIZE_EXPAND_FILL);
+ button_linear->connect("pressed", this, "_set_preset", varray(1));
+ hb->add_child(button_linear);
+
+ button_constant = memnew(ToolButton);
+ button_constant->set_tooltip(TTR("Linear"));
+ button_constant->set_h_size_flags(SIZE_EXPAND_FILL);
+ button_constant->connect("pressed", this, "_set_preset", varray(0));
+ hb->add_child(button_constant);
+
+ button_out = memnew(ToolButton);
+ button_out->set_tooltip(TTR("Out"));
+ button_out->set_h_size_flags(SIZE_EXPAND_FILL);
+ button_out->connect("pressed", this, "_set_preset", varray(0.5));
+ hb->add_child(button_out);
+
+ button_in = memnew(ToolButton);
+ button_in->set_tooltip(TTR("In"));
+ button_in->set_h_size_flags(SIZE_EXPAND_FILL);
+ button_in->connect("pressed", this, "_set_preset", varray(2));
+ hb->add_child(button_in);
+
+ button_in_out = NULL;
+ button_out_in = NULL;
+
+ easing_draw = memnew(Control);
+ easing_draw->connect("draw", this, "_draw_easing");
+ easing_draw->connect("gui_input", this, "_drag_easing");
+ easing_draw->set_default_cursor_shape(Control::CURSOR_MOVE);
+ vb->add_child(easing_draw);
+
+ flip = false;
+}
+
+///////////////////// VECTOR2 /////////////////////////
+
+void EditorPropertyVector2::_value_changed(double val) {
+ if (setting)
+ return;
+
+ Vector2 v2;
+ v2.x = spin[0]->get_value();
+ v2.y = spin[1]->get_value();
+ emit_signal("property_changed", get_edited_property(), v2);
+}
+
+void EditorPropertyVector2::update_property() {
+ Vector2 val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val.x);
+ spin[1]->set_value(val.y);
+ setting = false;
+}
+
+void EditorPropertyVector2::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyVector2::_value_changed);
+}
+
+void EditorPropertyVector2::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 2; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyVector2::EditorPropertyVector2() {
+ VBoxContainer *vb = memnew(VBoxContainer);
+ add_child(vb);
+ static const char *desc[2] = { "x", "y" };
+ for (int i = 0; i < 2; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ vb->add_child(spin[i]);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ setting = false;
+}
+
+///////////////////// RECT2 /////////////////////////
+
+void EditorPropertyRect2::_value_changed(double val) {
+ if (setting)
+ return;
+
+ Rect2 r2;
+ r2.position.x = spin[0]->get_value();
+ r2.position.x = spin[1]->get_value();
+ r2.size.y = spin[2]->get_value();
+ r2.size.y = spin[3]->get_value();
+ emit_signal("property_changed", get_edited_property(), r2);
+}
+
+void EditorPropertyRect2::update_property() {
+ Rect2 val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val.position.x);
+ spin[1]->set_value(val.position.y);
+ spin[2]->set_value(val.size.x);
+ spin[3]->set_value(val.size.y);
+ setting = false;
+}
+
+void EditorPropertyRect2::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyRect2::_value_changed);
+}
+
+void EditorPropertyRect2::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 4; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyRect2::EditorPropertyRect2() {
+ VBoxContainer *vb = memnew(VBoxContainer);
+ add_child(vb);
+ static const char *desc[4] = { "x", "y", "w", "h" };
+ for (int i = 0; i < 4; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ vb->add_child(spin[i]);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ setting = false;
+}
+///////////////////// VECTOR3 /////////////////////////
+
+void EditorPropertyVector3::_value_changed(double val) {
+ if (setting)
+ return;
+
+ Vector3 v3;
+ v3.x = spin[0]->get_value();
+ v3.y = spin[1]->get_value();
+ v3.z = spin[2]->get_value();
+ emit_signal("property_changed", get_edited_property(), v3);
+}
+
+void EditorPropertyVector3::update_property() {
+ Vector3 val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val.x);
+ spin[1]->set_value(val.y);
+ spin[2]->set_value(val.z);
+ setting = false;
+}
+
+void EditorPropertyVector3::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyVector3::_value_changed);
+}
+
+void EditorPropertyVector3::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 3; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyVector3::EditorPropertyVector3() {
+ VBoxContainer *vb = memnew(VBoxContainer);
+ add_child(vb);
+ static const char *desc[3] = { "x", "y", "z" };
+ for (int i = 0; i < 3; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ vb->add_child(spin[i]);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ setting = false;
+}
+///////////////////// PLANE /////////////////////////
+
+void EditorPropertyPlane::_value_changed(double val) {
+ if (setting)
+ return;
+
+ Plane p;
+ p.normal.x = spin[0]->get_value();
+ p.normal.y = spin[1]->get_value();
+ p.normal.z = spin[2]->get_value();
+ p.d = spin[3]->get_value();
+ emit_signal("property_changed", get_edited_property(), p);
+}
+
+void EditorPropertyPlane::update_property() {
+ Plane val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val.normal.x);
+ spin[1]->set_value(val.normal.y);
+ spin[2]->set_value(val.normal.z);
+ spin[3]->set_value(val.d);
+ setting = false;
+}
+
+void EditorPropertyPlane::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyPlane::_value_changed);
+}
+
+void EditorPropertyPlane::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 4; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyPlane::EditorPropertyPlane() {
+ VBoxContainer *vb = memnew(VBoxContainer);
+ add_child(vb);
+ static const char *desc[4] = { "x", "y", "z", "d" };
+ for (int i = 0; i < 4; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ vb->add_child(spin[i]);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ setting = false;
+}
+
+///////////////////// QUAT /////////////////////////
+
+void EditorPropertyQuat::_value_changed(double val) {
+ if (setting)
+ return;
+
+ Quat p;
+ p.x = spin[0]->get_value();
+ p.y = spin[1]->get_value();
+ p.z = spin[2]->get_value();
+ p.w = spin[3]->get_value();
+ emit_signal("property_changed", get_edited_property(), p);
+}
+
+void EditorPropertyQuat::update_property() {
+ Quat val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val.x);
+ spin[1]->set_value(val.y);
+ spin[2]->set_value(val.z);
+ spin[3]->set_value(val.w);
+ setting = false;
+}
+
+void EditorPropertyQuat::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyQuat::_value_changed);
+}
+
+void EditorPropertyQuat::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 4; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyQuat::EditorPropertyQuat() {
+ VBoxContainer *vb = memnew(VBoxContainer);
+ add_child(vb);
+ static const char *desc[4] = { "x", "y", "z", "w" };
+ for (int i = 0; i < 4; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ vb->add_child(spin[i]);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ setting = false;
+}
+
+///////////////////// AABB /////////////////////////
+
+void EditorPropertyAABB::_value_changed(double val) {
+ if (setting)
+ return;
+
+ AABB p;
+ p.position.x = spin[0]->get_value();
+ p.position.y = spin[1]->get_value();
+ p.position.z = spin[2]->get_value();
+ p.size.x = spin[3]->get_value();
+ p.size.y = spin[4]->get_value();
+ p.size.z = spin[5]->get_value();
+
+ emit_signal("property_changed", get_edited_property(), p);
+}
+
+void EditorPropertyAABB::update_property() {
+ AABB val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val.position.x);
+ spin[1]->set_value(val.position.y);
+ spin[2]->set_value(val.position.z);
+ spin[3]->set_value(val.size.x);
+ spin[4]->set_value(val.size.y);
+ spin[5]->set_value(val.size.z);
+
+ setting = false;
+}
+
+void EditorPropertyAABB::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyAABB::_value_changed);
+}
+
+void EditorPropertyAABB::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 6; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyAABB::EditorPropertyAABB() {
+ GridContainer *g = memnew(GridContainer);
+ g->set_columns(3);
+ add_child(g);
+
+ static const char *desc[6] = { "x", "y", "z", "w", "h", "d" };
+ for (int i = 0; i < 6; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ g->add_child(spin[i]);
+ spin[i]->set_h_size_flags(SIZE_EXPAND_FILL);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ set_label_layout(LABEL_LAYOUT_TOP);
+ setting = false;
+}
+
+///////////////////// TRANSFORM2D /////////////////////////
+
+void EditorPropertyTransform2D::_value_changed(double val) {
+ if (setting)
+ return;
+
+ Transform2D p;
+ p[0][0] = spin[0]->get_value();
+ p[0][1] = spin[1]->get_value();
+ p[1][0] = spin[2]->get_value();
+ p[1][1] = spin[3]->get_value();
+ p[2][0] = spin[4]->get_value();
+ p[2][1] = spin[5]->get_value();
+
+ emit_signal("property_changed", get_edited_property(), p);
+}
+
+void EditorPropertyTransform2D::update_property() {
+ Transform2D val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val[0][0]);
+ spin[1]->set_value(val[0][1]);
+ spin[2]->set_value(val[1][0]);
+ spin[3]->set_value(val[1][1]);
+ spin[4]->set_value(val[2][0]);
+ spin[5]->set_value(val[2][1]);
+
+ setting = false;
+}
+
+void EditorPropertyTransform2D::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyTransform2D::_value_changed);
+}
+
+void EditorPropertyTransform2D::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 6; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyTransform2D::EditorPropertyTransform2D() {
+ GridContainer *g = memnew(GridContainer);
+ g->set_columns(2);
+ add_child(g);
+
+ static const char *desc[6] = { "xx", "xy", "yx", "yy", "ox", "oy" };
+ for (int i = 0; i < 6; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ g->add_child(spin[i]);
+ spin[i]->set_h_size_flags(SIZE_EXPAND_FILL);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ set_label_layout(LABEL_LAYOUT_TOP);
+ setting = false;
+}
+
+///////////////////// BASIS /////////////////////////
+
+void EditorPropertyBasis::_value_changed(double val) {
+ if (setting)
+ return;
+
+ Basis p;
+ p[0][0] = spin[0]->get_value();
+ p[1][0] = spin[1]->get_value();
+ p[2][0] = spin[2]->get_value();
+ p[0][1] = spin[3]->get_value();
+ p[1][1] = spin[4]->get_value();
+ p[2][1] = spin[5]->get_value();
+ p[0][2] = spin[6]->get_value();
+ p[1][2] = spin[7]->get_value();
+ p[2][2] = spin[8]->get_value();
+
+ emit_signal("property_changed", get_edited_property(), p);
+}
+
+void EditorPropertyBasis::update_property() {
+ Basis val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val[0][0]);
+ spin[1]->set_value(val[1][0]);
+ spin[2]->set_value(val[2][0]);
+ spin[3]->set_value(val[0][1]);
+ spin[4]->set_value(val[1][1]);
+ spin[5]->set_value(val[2][1]);
+ spin[6]->set_value(val[0][2]);
+ spin[7]->set_value(val[1][2]);
+ spin[8]->set_value(val[2][2]);
+
+ setting = false;
+}
+
+void EditorPropertyBasis::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyBasis::_value_changed);
+}
+
+void EditorPropertyBasis::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 9; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyBasis::EditorPropertyBasis() {
+ GridContainer *g = memnew(GridContainer);
+ g->set_columns(3);
+ add_child(g);
+
+ static const char *desc[9] = { "xx", "xy", "xz", "yx", "yy", "yz", "zx", "zy", "zz" };
+ for (int i = 0; i < 9; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ g->add_child(spin[i]);
+ spin[i]->set_h_size_flags(SIZE_EXPAND_FILL);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ set_label_layout(LABEL_LAYOUT_TOP);
+ setting = false;
+}
+
+///////////////////// TRANSFORM /////////////////////////
+
+void EditorPropertyTransform::_value_changed(double val) {
+ if (setting)
+ return;
+
+ Transform p;
+ p.basis[0][0] = spin[0]->get_value();
+ p.basis[1][0] = spin[1]->get_value();
+ p.basis[2][0] = spin[2]->get_value();
+ p.basis[0][1] = spin[3]->get_value();
+ p.basis[1][1] = spin[4]->get_value();
+ p.basis[2][1] = spin[5]->get_value();
+ p.basis[0][2] = spin[6]->get_value();
+ p.basis[1][2] = spin[7]->get_value();
+ p.basis[2][2] = spin[8]->get_value();
+ p.origin[0] = spin[9]->get_value();
+ p.origin[1] = spin[10]->get_value();
+ p.origin[2] = spin[11]->get_value();
+
+ emit_signal("property_changed", get_edited_property(), p);
+}
+
+void EditorPropertyTransform::update_property() {
+ Transform val = get_edited_object()->get(get_edited_property());
+ setting = true;
+ spin[0]->set_value(val.basis[0][0]);
+ spin[1]->set_value(val.basis[1][0]);
+ spin[2]->set_value(val.basis[2][0]);
+ spin[3]->set_value(val.basis[0][1]);
+ spin[4]->set_value(val.basis[1][1]);
+ spin[5]->set_value(val.basis[2][1]);
+ spin[6]->set_value(val.basis[0][2]);
+ spin[7]->set_value(val.basis[1][2]);
+ spin[8]->set_value(val.basis[2][2]);
+ spin[9]->set_value(val.origin[0]);
+ spin[10]->set_value(val.origin[1]);
+ spin[11]->set_value(val.origin[2]);
+
+ setting = false;
+}
+
+void EditorPropertyTransform::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_value_changed"), &EditorPropertyTransform::_value_changed);
+}
+
+void EditorPropertyTransform::setup(double p_min, double p_max, double p_step, bool p_no_slider) {
+ for (int i = 0; i < 12; i++) {
+ spin[i]->set_min(p_min);
+ spin[i]->set_max(p_max);
+ spin[i]->set_step(p_step);
+ spin[i]->set_hide_slider(p_no_slider);
+ }
+}
+
+EditorPropertyTransform::EditorPropertyTransform() {
+ GridContainer *g = memnew(GridContainer);
+ g->set_columns(3);
+ add_child(g);
+
+ static const char *desc[12] = { "xx", "xy", "xz", "yx", "yy", "yz", "zx", "zy", "zz", "ox", "oy", "oz" };
+ for (int i = 0; i < 12; i++) {
+ spin[i] = memnew(EditorSpinSlider);
+ spin[i]->set_label(desc[i]);
+ g->add_child(spin[i]);
+ spin[i]->set_h_size_flags(SIZE_EXPAND_FILL);
+ add_focusable(spin[i]);
+ spin[i]->connect("value_changed", this, "_value_changed");
+ }
+ set_label_reference(spin[0]); //show text and buttons around this
+ set_label_layout(LABEL_LAYOUT_TOP);
+ setting = false;
+}
+
+////////////// COLOR PICKER //////////////////////
+
+void EditorPropertyColor::_color_changed(const Color &p_color) {
+
+ emit_signal("property_changed", get_edited_property(), p_color);
+}
+
+void EditorPropertyColor::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_color_changed"), &EditorPropertyColor::_color_changed);
+}
+
+void EditorPropertyColor::update_property() {
+
+ picker->set_pick_color(get_edited_object()->get(get_edited_property()));
+}
+
+void EditorPropertyColor::setup(bool p_show_alpha) {
+ picker->set_edit_alpha(p_show_alpha);
+}
+
+EditorPropertyColor::EditorPropertyColor() {
+
+ picker = memnew(ColorPickerButton);
+ add_child(picker);
+ picker->set_flat(true);
+ picker->connect("color_changed", this, "_color_changed");
+}
+
+////////////// NODE PATH //////////////////////
+
+void EditorPropertyNodePath::_node_selected(const NodePath &p_path) {
+
+ emit_signal("property_changed", get_edited_property(), p_path);
+ update_property();
+}
+
+void EditorPropertyNodePath::_node_assign() {
+ if (!scene_tree) {
+ scene_tree = memnew(SceneTreeDialog);
+ add_child(scene_tree);
+ scene_tree->connect("selected", this, "_node_selected");
+ }
+ scene_tree->popup_centered_ratio();
+}
+
+void EditorPropertyNodePath::_node_clear() {
+
+ emit_signal("property_changed", get_edited_property(), NodePath());
+ update_property();
+}
+
+void EditorPropertyNodePath::update_property() {
+
+ NodePath p = get_edited_object()->get(get_edited_property());
+
+ assign->set_tooltip(p);
+ if (p == NodePath()) {
+ assign->set_icon(Ref<Texture>());
+ assign->set_text(TTR("Assign.."));
+ assign->set_flat(false);
+ return;
+ }
+ assign->set_flat(true);
+
+ Node *base_node = NULL;
+ if (base_hint != NodePath()) {
+ if (get_tree()->get_root()->has_node(base_hint)) {
+ base_node = get_tree()->get_root()->get_node(base_hint);
+ }
+ } else {
+ base_node = Object::cast_to<Node>(get_edited_object());
+ }
+
+ if (!base_node || !base_node->has_node(p)) {
+ assign->set_icon(Ref<Texture>());
+ assign->set_text(p);
+ return;
+ }
+
+ Node *target_node = base_node->get_node(p);
+ ERR_FAIL_COND(!target_node);
+
+ assign->set_text(target_node->get_name());
+
+ Ref<Texture> icon;
+ if (has_icon(target_node->get_class(), "EditorIcons"))
+ icon = get_icon(target_node->get_class(), "EditorIcons");
+ else
+ icon = get_icon("Node", "EditorIcons");
+
+ assign->set_icon(icon);
+}
+
+void EditorPropertyNodePath::setup(const NodePath &p_base_hint) {
+
+ base_hint = p_base_hint;
+}
+
+void EditorPropertyNodePath::_notification(int p_what) {
+
+ if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) {
+ Ref<Texture> t = get_icon("Clear", "EditorIcons");
+ clear->set_icon(t);
+ }
+}
+
+void EditorPropertyNodePath::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_node_selected"), &EditorPropertyNodePath::_node_selected);
+ ClassDB::bind_method(D_METHOD("_node_assign"), &EditorPropertyNodePath::_node_assign);
+ ClassDB::bind_method(D_METHOD("_node_clear"), &EditorPropertyNodePath::_node_clear);
+}
+
+EditorPropertyNodePath::EditorPropertyNodePath() {
+
+ HBoxContainer *hbc = memnew(HBoxContainer);
+ add_child(hbc);
+ assign = memnew(Button);
+ assign->set_flat(true);
+ assign->set_h_size_flags(SIZE_EXPAND_FILL);
+ assign->set_clip_text(true);
+ assign->connect("pressed", this, "_node_assign");
+ hbc->add_child(assign);
+
+ clear = memnew(Button);
+ clear->set_flat(true);
+ clear->connect("pressed", this, "_node_clear");
+ hbc->add_child(clear);
+
+ scene_tree = NULL; //do not allocate unnecesarily
+}
+
+////////////// RESOURCE //////////////////////
+
+void EditorPropertyResource::_file_selected(const String &p_path) {
+
+ RES res = ResourceLoader::load(p_path);
+ emit_signal("property_changed", get_edited_property(), res);
+ update_property();
+}
+
+void EditorPropertyResource::_menu_option(int p_which) {
+
+ // scene_tree->popup_centered_ratio();
+ switch (p_which) {
+ case OBJ_MENU_LOAD: {
+
+ if (!file) {
+ file = memnew(EditorFileDialog);
+ file->connect("file_selected", this, "_file_selected");
+ add_child(file);
+ }
+ file->set_mode(EditorFileDialog::MODE_OPEN_FILE);
+ String type = base_type;
+
+ List<String> extensions;
+ for (int i = 0; i < type.get_slice_count(","); i++) {
+
+ ResourceLoader::get_recognized_extensions_for_type(type.get_slice(",", i), &extensions);
+ }
+
+ Set<String> valid_extensions;
+ for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
+ valid_extensions.insert(E->get());
+ }
+
+ file->clear_filters();
+ for (Set<String>::Element *E = valid_extensions.front(); E; E = E->next()) {
+
+ file->add_filter("*." + E->get() + " ; " + E->get().to_upper());
+ }
+
+ file->popup_centered_ratio();
+ } break;
+
+ case OBJ_MENU_EDIT: {
+
+ RES res = get_edited_object()->get(get_edited_property());
+
+ if (!res.is_null()) {
+
+ emit_signal("resource_selected", get_edited_property(), res);
+ }
+ } break;
+ case OBJ_MENU_CLEAR: {
+
+ emit_signal("property_changed", get_edited_property(), RES());
+ update_property();
+
+ } break;
+
+ case OBJ_MENU_MAKE_UNIQUE: {
+
+ RES res_orig = get_edited_object()->get(get_edited_property());
+ if (res_orig.is_null())
+ return;
+
+ List<PropertyInfo> property_list;
+ res_orig->get_property_list(&property_list);
+ List<Pair<String, Variant> > propvalues;
+
+ for (List<PropertyInfo>::Element *E = property_list.front(); E; E = E->next()) {
+
+ Pair<String, Variant> p;
+ PropertyInfo &pi = E->get();
+ if (pi.usage & PROPERTY_USAGE_STORAGE) {
+
+ p.first = pi.name;
+ p.second = res_orig->get(pi.name);
+ }
+
+ propvalues.push_back(p);
+ }
+
+ String orig_type = res_orig->get_class();
+
+ Object *inst = ClassDB::instance(orig_type);
+
+ Ref<Resource> res = Ref<Resource>(Object::cast_to<Resource>(inst));
+
+ ERR_FAIL_COND(res.is_null());
+
+ for (List<Pair<String, Variant> >::Element *E = propvalues.front(); E; E = E->next()) {
+
+ Pair<String, Variant> &p = E->get();
+ res->set(p.first, p.second);
+ }
+
+ emit_signal("property_changed", get_edited_property(), res);
+ update_property();
+
+ } break;
+
+ case OBJ_MENU_COPY: {
+ RES res = get_edited_object()->get(get_edited_property());
+
+ EditorSettings::get_singleton()->set_resource_clipboard(res);
+
+ } break;
+ case OBJ_MENU_PASTE: {
+
+ RES res = EditorSettings::get_singleton()->get_resource_clipboard();
+ emit_signal("property_changed", get_edited_property(), res);
+ update_property();
+
+ } break;
+ case OBJ_MENU_NEW_SCRIPT: {
+
+ if (Object::cast_to<Node>(get_edited_object())) {
+ EditorNode::get_singleton()->get_scene_tree_dock()->open_script_dialog(Object::cast_to<Node>(get_edited_object()));
+ }
+
+ } break;
+ case OBJ_MENU_SHOW_IN_FILE_SYSTEM: {
+ RES res = get_edited_object()->get(get_edited_property());
+
+ FileSystemDock *file_system_dock = EditorNode::get_singleton()->get_filesystem_dock();
+ file_system_dock->navigate_to_path(res->get_path());
+ // Ensure that the FileSystem dock is visible.
+ TabContainer *tab_container = (TabContainer *)file_system_dock->get_parent_control();
+ tab_container->set_current_tab(file_system_dock->get_position_in_parent());
+ } break;
+ default: {
+
+ RES res = get_edited_object()->get(get_edited_property());
+
+ if (p_which >= CONVERT_BASE_ID) {
+
+ int to_type = p_which - CONVERT_BASE_ID;
+
+ Vector<Ref<EditorResourceConversionPlugin> > conversions = EditorNode::get_singleton()->find_resource_conversion_plugin(res);
+
+ ERR_FAIL_INDEX(to_type, conversions.size());
+
+ Ref<Resource> new_res = conversions[to_type]->convert(res);
+
+ emit_signal("property_changed", get_edited_property(), new_res);
+ update_property();
+ break;
+ }
+ ERR_FAIL_COND(inheritors_array.empty());
+
+ String intype = inheritors_array[p_which - TYPE_BASE_ID];
+
+ if (intype == "ViewportTexture") {
+
+ if (!scene_tree) {
+ scene_tree = memnew(SceneTreeDialog);
+ add_child(scene_tree);
+ scene_tree->connect("selected", this, "_viewport_selected");
+ scene_tree->set_title(TTR("Pick a Viewport"));
+ }
+ scene_tree->popup_centered_ratio();
+
+ return;
+ }
+
+ Object *obj = ClassDB::instance(intype);
+
+ if (!obj) {
+ obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
+ }
+
+ ERR_BREAK(!obj);
+ Resource *resp = Object::cast_to<Resource>(obj);
+ ERR_BREAK(!resp);
+ if (get_edited_object() && base_type != String() && base_type == "Script") {
+ //make visual script the right type
+ res->call("set_instance_base_type", get_edited_object()->get_class());
+ }
+
+ res = Ref<Resource>(resp);
+ emit_signal("property_changed", get_edited_property(), res);
+ update_property();
+
+ } break;
+ }
+}
+
+void EditorPropertyResource::_resource_preview(const String &p_path, const Ref<Texture> &p_preview, ObjectID p_obj) {
+
+ RES p = get_edited_object()->get(get_edited_property());
+ if (p.is_valid() && p->get_instance_id() == p_obj) {
+ if (p_preview.is_valid()) {
+ assign->set_icon(p_preview);
+ }
+ }
+}
+
+void EditorPropertyResource::_update_menu() {
+ //////////////////// UPDATE MENU //////////////////////////
+ RES res = get_edited_object()->get(get_edited_property());
+
+ menu->clear();
+
+ if (get_edited_property() == "script" && base_type == "Script" && Object::cast_to<Node>(get_edited_object())) {
+ menu->add_icon_item(get_icon("Script", "EditorIcons"), TTR("New Script"), OBJ_MENU_NEW_SCRIPT);
+ menu->add_separator();
+ } else if (base_type != "") {
+ int idx = 0;
+
+ Vector<EditorData::CustomType> custom_resources;
+
+ if (EditorNode::get_editor_data().get_custom_types().has("Resource")) {
+ custom_resources = EditorNode::get_editor_data().get_custom_types()["Resource"];
+ }
+
+ for (int i = 0; i < base_type.get_slice_count(","); i++) {
+
+ String base = base_type.get_slice(",", i);
+
+ Set<String> valid_inheritors;
+ valid_inheritors.insert(base);
+ List<StringName> inheritors;
+ ClassDB::get_inheriters_from_class(base.strip_edges(), &inheritors);
+
+ for (int i = 0; i < custom_resources.size(); i++) {
+ inheritors.push_back(custom_resources[i].name);
+ }
+
+ List<StringName>::Element *E = inheritors.front();
+ while (E) {
+ valid_inheritors.insert(E->get());
+ E = E->next();
+ }
+
+ for (Set<String>::Element *E = valid_inheritors.front(); E; E = E->next()) {
+ String t = E->get();
+
+ bool is_custom_resource = false;
+ Ref<Texture> icon;
+ if (!custom_resources.empty()) {
+ for (int i = 0; i < custom_resources.size(); i++) {
+ if (custom_resources[i].name == t) {
+ is_custom_resource = true;
+ if (custom_resources[i].icon.is_valid())
+ icon = custom_resources[i].icon;
+ break;
+ }
+ }
+ }
+
+ if (!is_custom_resource && !ClassDB::can_instance(t))
+ continue;
+
+ inheritors_array.push_back(t);
+
+ int id = TYPE_BASE_ID + idx;
+
+ if (!icon.is_valid() && has_icon(t, "EditorIcons")) {
+ icon = get_icon(t, "EditorIcons");
+ }
+
+ if (icon.is_valid()) {
+
+ menu->add_icon_item(icon, vformat(TTR("New %s"), t), id);
+ } else {
+
+ menu->add_item(vformat(TTR("New %s"), t), id);
+ }
+
+ idx++;
+ }
+ }
+
+ if (menu->get_item_count())
+ menu->add_separator();
+ }
+
+ menu->add_icon_item(get_icon("Load", "EditorIcons"), TTR("Load"), OBJ_MENU_LOAD);
+
+ if (!res.is_null()) {
+
+ menu->add_icon_item(get_icon("Edit", "EditorIcons"), TTR("Edit"), OBJ_MENU_EDIT);
+ menu->add_icon_item(get_icon("Clear", "EditorIcons"), TTR("Clear"), OBJ_MENU_CLEAR);
+ menu->add_icon_item(get_icon("Duplicate", "EditorIcons"), TTR("Make Unique"), OBJ_MENU_MAKE_UNIQUE);
+ RES r = res;
+ if (r.is_valid() && r->get_path().is_resource_file()) {
+ menu->add_separator();
+ menu->add_item(TTR("Show in File System"), OBJ_MENU_SHOW_IN_FILE_SYSTEM);
+ }
+ } else {
+ }
+
+ RES cb = EditorSettings::get_singleton()->get_resource_clipboard();
+ bool paste_valid = false;
+ if (cb.is_valid()) {
+ if (base_type == "")
+ paste_valid = true;
+ else
+ for (int i = 0; i < base_type.get_slice_count(","); i++)
+ if (ClassDB::is_parent_class(cb->get_class(), base_type.get_slice(",", i))) {
+ paste_valid = true;
+ break;
+ }
+ }
+
+ if (!res.is_null() || paste_valid) {
+ menu->add_separator();
+
+ if (!res.is_null()) {
+
+ menu->add_item(TTR("Copy"), OBJ_MENU_COPY);
+ }
+
+ if (paste_valid) {
+
+ menu->add_item(TTR("Paste"), OBJ_MENU_PASTE);
+ }
+ }
+
+ if (!res.is_null()) {
+
+ Vector<Ref<EditorResourceConversionPlugin> > conversions = EditorNode::get_singleton()->find_resource_conversion_plugin(res);
+ if (conversions.size()) {
+ menu->add_separator();
+ }
+ for (int i = 0; i < conversions.size(); i++) {
+ String what = conversions[i]->converts_to();
+ Ref<Texture> icon;
+ if (has_icon(what, "EditorIcons")) {
+
+ icon = get_icon(what, "EditorIcons");
+ } else {
+
+ icon = get_icon(what, "Resource");
+ }
+
+ menu->add_icon_item(icon, vformat(TTR("Convert To %s"), what), CONVERT_BASE_ID + i);
+ }
+ }
+
+ Rect2 gt = get_global_rect();
+ int ms = menu->get_combined_minimum_size().width;
+ Vector2 popup_pos = gt.position + gt.size - Vector2(ms, 0);
+ menu->set_position(popup_pos);
+ menu->popup();
+}
+
+void EditorPropertyResource::update_property() {
+
+ RES res = get_edited_object()->get(get_edited_property());
+
+ if (res == RES()) {
+ assign->set_icon(Ref<Texture>());
+ assign->set_text(TTR("[empty]"));
+ assign->set_disabled(true);
+ } else {
+ assign->set_disabled(false);
+
+ Ref<Texture> icon;
+ if (has_icon(res->get_class(), "EditorIcons"))
+ icon = get_icon(res->get_class(), "EditorIcons");
+ else
+ icon = get_icon("Node", "EditorIcons");
+
+ assign->set_icon(icon);
+
+ if (res->get_name() != String()) {
+ assign->set_text(res->get_name());
+ } else if (res->get_path().is_resource_file()) {
+ assign->set_text(res->get_name());
+ assign->set_tooltip(res->get_path());
+ } else {
+ assign->set_text(res->get_class());
+ }
+
+ if (res->get_path().is_resource_file()) {
+ assign->set_tooltip(res->get_path());
+ }
+
+ //preview will override the above, so called at the end
+ EditorResourcePreview::get_singleton()->queue_edited_resource_preview(res, this, "_resource_preview", res->get_instance_id());
+ }
+}
+
+void EditorPropertyResource::_resource_selected() {
+ RES res = get_edited_object()->get(get_edited_property());
+
+ if (!res.is_null()) {
+
+ emit_signal("resource_selected", get_edited_property(), res);
+ }
+}
+
+void EditorPropertyResource::setup(const String &p_base_type) {
+ base_type = p_base_type;
+}
+
+void EditorPropertyResource::_notification(int p_what) {
+
+ if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) {
+ Ref<Texture> t = get_icon("select_arrow", "Tree");
+ edit->set_icon(t);
+ }
+}
+
+void EditorPropertyResource::_viewport_selected(const NodePath &p_path) {
+
+ Node *to_node = get_node(p_path);
+ if (!Object::cast_to<Viewport>(to_node)) {
+ EditorNode::get_singleton()->show_warning(TTR("Selected node is not a Viewport!"));
+ return;
+ }
+
+ Ref<ViewportTexture> vt;
+ vt.instance();
+ vt->set_viewport_path_in_scene(get_tree()->get_edited_scene_root()->get_path_to(to_node));
+ vt->setup_local_to_scene();
+
+ emit_signal("property_changed", get_edited_property(), vt);
+ update_property();
+}
+void EditorPropertyResource::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_file_selected"), &EditorPropertyResource::_file_selected);
+ ClassDB::bind_method(D_METHOD("_menu_option"), &EditorPropertyResource::_menu_option);
+ ClassDB::bind_method(D_METHOD("_update_menu"), &EditorPropertyResource::_update_menu);
+ ClassDB::bind_method(D_METHOD("_resource_preview"), &EditorPropertyResource::_resource_preview);
+ ClassDB::bind_method(D_METHOD("_resource_selected"), &EditorPropertyResource::_resource_selected);
+ ClassDB::bind_method(D_METHOD("_viewport_selected"), &EditorPropertyResource::_viewport_selected);
+}
+
+EditorPropertyResource::EditorPropertyResource() {
+
+ HBoxContainer *hbc = memnew(HBoxContainer);
+ add_child(hbc);
+ assign = memnew(Button);
+ assign->set_flat(true);
+ assign->set_h_size_flags(SIZE_EXPAND_FILL);
+ assign->set_clip_text(true);
+ assign->connect("pressed", this, "_resource_selected");
+ hbc->add_child(assign);
+
+ menu = memnew(PopupMenu);
+ add_child(menu);
+ edit = memnew(Button);
+ edit->set_flat(true);
+ menu->connect("id_pressed", this, "_menu_option");
+ edit->connect("pressed", this, "_update_menu");
+ hbc->add_child(edit);
+
+ file = NULL;
+ scene_tree = NULL;
+}
+
+////////////// DEFAULT PLUGIN //////////////////////
+
+bool EditorInspectorDefaultPlugin::can_handle(Object *p_object) {
+ return true; //can handle everything
+}
+
+void EditorInspectorDefaultPlugin::parse_begin(Object *p_object) {
+ //do none
+}
+
+bool EditorInspectorDefaultPlugin::parse_property(Object *p_object, Variant::Type p_type, const String &p_path, PropertyHint p_hint, const String &p_hint_text, int p_usage) {
+
+ switch (p_type) {
+
+ // atomic types
+ case Variant::BOOL: {
+ EditorPropertyCheck *editor = memnew(EditorPropertyCheck);
+ add_property_editor(p_path, editor);
+ } break;
+ case Variant::INT: {
+
+ if (p_hint == PROPERTY_HINT_ENUM) {
+ EditorPropertyEnum *editor = memnew(EditorPropertyEnum);
+ Vector<String> options = p_hint_text.split(",");
+ editor->setup(options);
+ add_property_editor(p_path, editor);
+
+ } else if (p_hint == PROPERTY_HINT_FLAGS) {
+ EditorPropertyFlags *editor = memnew(EditorPropertyFlags);
+ Vector<String> options = p_hint_text.split(",");
+ editor->setup(options);
+ add_property_editor(p_path, editor);
+
+ } else if (p_hint == PROPERTY_HINT_LAYERS_2D_PHYSICS || p_hint == PROPERTY_HINT_LAYERS_2D_RENDER || p_hint == PROPERTY_HINT_LAYERS_3D_PHYSICS || p_hint == PROPERTY_HINT_LAYERS_3D_RENDER) {
+
+ EditorPropertyLayers::LayerType lt;
+ switch (p_hint) {
+ case PROPERTY_HINT_LAYERS_2D_RENDER:
+ lt = EditorPropertyLayers::LAYER_RENDER_2D;
+ break;
+ case PROPERTY_HINT_LAYERS_2D_PHYSICS:
+ lt = EditorPropertyLayers::LAYER_PHYSICS_2D;
+ break;
+ case PROPERTY_HINT_LAYERS_3D_RENDER:
+ lt = EditorPropertyLayers::LAYER_RENDER_3D;
+ break;
+ case PROPERTY_HINT_LAYERS_3D_PHYSICS:
+ lt = EditorPropertyLayers::LAYER_PHYSICS_3D;
+ break;
+ default: {} //compiler could be smarter here and realize this cant happen
+ }
+ EditorPropertyLayers *editor = memnew(EditorPropertyLayers);
+ editor->setup(lt);
+ add_property_editor(p_path, editor);
+ } else if (p_hint == PROPERTY_HINT_OBJECT_ID) {
+
+ EditorPropertyObjectID *editor = memnew(EditorPropertyObjectID);
+ editor->setup(p_hint_text);
+ add_property_editor(p_path, editor);
+
+ } else {
+ EditorPropertyInteger *editor = memnew(EditorPropertyInteger);
+ int min = 0, max = 65535;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_int();
+ max = p_hint_text.get_slice(",", 1).to_int();
+ }
+
+ editor->setup(min, max);
+
+ add_property_editor(p_path, editor);
+ }
+ } break;
+ case Variant::REAL: {
+
+ if (p_hint == PROPERTY_HINT_EXP_EASING) {
+ EditorPropertyEasing *editor = memnew(EditorPropertyEasing);
+ bool full = true;
+ bool flip = false;
+ Vector<String> hints = p_hint_text.split(",");
+ for (int i = 0; i < hints.size(); i++) {
+ String h = hints[i].strip_edges();
+ if (h == "attenuation") {
+ flip = true;
+ }
+ if (h == "inout") {
+ full = true;
+ }
+ }
+
+ editor->setup(full, flip);
+ add_property_editor(p_path, editor);
+
+ } else {
+ EditorPropertyFloat *editor = memnew(EditorPropertyFloat);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+ bool exp_range = false;
+
+ if ((p_hint == PROPERTY_HINT_RANGE || p_hint == PROPERTY_HINT_EXP_RANGE) && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ exp_range = p_hint == PROPERTY_HINT_EXP_RANGE;
+ }
+
+ editor->setup(min, max, step, hide_slider, exp_range);
+
+ add_property_editor(p_path, editor);
+ }
+ } break;
+ case Variant::STRING: {
+
+ if (p_hint == PROPERTY_HINT_ENUM) {
+ EditorPropertyTextEnum *editor = memnew(EditorPropertyTextEnum);
+ Vector<String> options = p_hint_text.split(",");
+ editor->setup(options);
+ add_property_editor(p_path, editor);
+ } else if (p_hint == PROPERTY_HINT_MULTILINE_TEXT) {
+ EditorPropertyMultilineText *editor = memnew(EditorPropertyMultilineText);
+ add_property_editor(p_path, editor);
+ } else if (p_hint == PROPERTY_HINT_DIR || p_hint == PROPERTY_HINT_FILE || p_hint == PROPERTY_HINT_GLOBAL_DIR || p_hint == PROPERTY_HINT_GLOBAL_FILE) {
+
+ Vector<String> extensions = p_hint_text.split(",");
+ bool global = p_hint == PROPERTY_HINT_GLOBAL_DIR || p_hint == PROPERTY_HINT_GLOBAL_FILE;
+ bool folder = p_hint == PROPERTY_HINT_DIR || p_hint == PROPERTY_HINT_GLOBAL_DIR;
+ EditorPropertyPath *editor = memnew(EditorPropertyPath);
+ editor->setup(extensions, folder, global);
+ add_property_editor(p_path, editor);
+ } else if (p_hint == PROPERTY_HINT_METHOD_OF_VARIANT_TYPE ||
+ p_hint == PROPERTY_HINT_METHOD_OF_BASE_TYPE ||
+ p_hint == PROPERTY_HINT_METHOD_OF_INSTANCE ||
+ p_hint == PROPERTY_HINT_METHOD_OF_SCRIPT ||
+ p_hint == PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE ||
+ p_hint == PROPERTY_HINT_PROPERTY_OF_BASE_TYPE ||
+ p_hint == PROPERTY_HINT_PROPERTY_OF_INSTANCE ||
+ p_hint == PROPERTY_HINT_PROPERTY_OF_SCRIPT) {
+
+ EditorPropertyMember *editor = memnew(EditorPropertyMember);
+
+ EditorPropertyMember::Type type = EditorPropertyMember::MEMBER_METHOD_OF_BASE_TYPE;
+ switch (p_hint) {
+ case PROPERTY_HINT_METHOD_OF_BASE_TYPE: type = EditorPropertyMember::MEMBER_METHOD_OF_BASE_TYPE; break;
+ case PROPERTY_HINT_METHOD_OF_INSTANCE: type = EditorPropertyMember::MEMBER_METHOD_OF_INSTANCE; break;
+ case PROPERTY_HINT_METHOD_OF_SCRIPT: type = EditorPropertyMember::MEMBER_METHOD_OF_SCRIPT; break;
+ case PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE: type = EditorPropertyMember::MEMBER_PROPERTY_OF_VARIANT_TYPE; break;
+ case PROPERTY_HINT_PROPERTY_OF_BASE_TYPE: type = EditorPropertyMember::MEMBER_PROPERTY_OF_BASE_TYPE; break;
+ case PROPERTY_HINT_PROPERTY_OF_INSTANCE: type = EditorPropertyMember::MEMBER_PROPERTY_OF_INSTANCE; break;
+ case PROPERTY_HINT_PROPERTY_OF_SCRIPT: type = EditorPropertyMember::MEMBER_PROPERTY_OF_SCRIPT; break;
+ default: {}
+ }
+ editor->setup(type, p_hint_text);
+ add_property_editor(p_path, editor);
+
+ } else {
+
+ EditorPropertyText *editor = memnew(EditorPropertyText);
+ add_property_editor(p_path, editor);
+ }
+ } break;
+
+ // math types
+
+ case Variant::VECTOR2: {
+ EditorPropertyVector2 *editor = memnew(EditorPropertyVector2);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+
+ } break; // 5
+ case Variant::RECT2: {
+ EditorPropertyRect2 *editor = memnew(EditorPropertyRect2);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+ } break;
+ case Variant::VECTOR3: {
+ EditorPropertyVector3 *editor = memnew(EditorPropertyVector3);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+
+ } break;
+ case Variant::TRANSFORM2D: {
+ EditorPropertyTransform2D *editor = memnew(EditorPropertyTransform2D);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+
+ } break;
+ case Variant::PLANE: {
+ EditorPropertyPlane *editor = memnew(EditorPropertyPlane);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+ } break;
+ case Variant::QUAT: {
+ EditorPropertyQuat *editor = memnew(EditorPropertyQuat);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+ } break; // 10
+ case Variant::AABB: {
+ EditorPropertyAABB *editor = memnew(EditorPropertyAABB);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+ } break;
+ case Variant::BASIS: {
+ EditorPropertyBasis *editor = memnew(EditorPropertyBasis);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+ } break;
+ case Variant::TRANSFORM: {
+ EditorPropertyTransform *editor = memnew(EditorPropertyTransform);
+ double min = -65535, max = 65535, step = 0.001;
+ bool hide_slider = true;
+
+ if (p_hint == PROPERTY_HINT_RANGE && p_hint_text.get_slice_count(",") >= 2) {
+ min = p_hint_text.get_slice(",", 0).to_double();
+ max = p_hint_text.get_slice(",", 1).to_double();
+ if (p_hint_text.get_slice_count(",") >= 3) {
+ step = p_hint_text.get_slice(",", 2).to_double();
+ }
+ hide_slider = false;
+ }
+
+ editor->setup(min, max, step, hide_slider);
+ add_property_editor(p_path, editor);
+
+ } break;
+
+ // misc types
+ case Variant::COLOR: {
+ EditorPropertyColor *editor = memnew(EditorPropertyColor);
+ editor->setup(p_hint != PROPERTY_HINT_COLOR_NO_ALPHA);
+ add_property_editor(p_path, editor);
+ } break;
+ case Variant::NODE_PATH: {
+
+ EditorPropertyNodePath *editor = memnew(EditorPropertyNodePath);
+ if (p_hint == PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE && p_hint_text != String()) {
+ editor->setup(p_hint_text);
+ }
+ add_property_editor(p_path, editor);
+
+ } break; // 15
+ case Variant::_RID: {
+ } break;
+ case Variant::OBJECT: {
+ EditorPropertyResource *editor = memnew(EditorPropertyResource);
+ editor->setup(p_hint == PROPERTY_HINT_RESOURCE_TYPE ? p_hint_text : "Resource");
+ add_property_editor(p_path, editor);
+
+ } break;
+ case Variant::DICTIONARY: {
+ } break;
+ case Variant::ARRAY: {
+ } break;
+
+ // arrays
+ case Variant::POOL_BYTE_ARRAY: {
+ } break; // 20
+ case Variant::POOL_INT_ARRAY: {
+ } break;
+ case Variant::POOL_REAL_ARRAY: {
+ } break;
+ case Variant::POOL_STRING_ARRAY: {
+ } break;
+ case Variant::POOL_VECTOR2_ARRAY: {
+ } break;
+ case Variant::POOL_VECTOR3_ARRAY: {
+ } break; // 25
+ case Variant::POOL_COLOR_ARRAY: {
+ } break;
+ default: {}
+ }
+
+ return false; //can be overriden, although it will most likely be last anyway
+}
+
+void EditorInspectorDefaultPlugin::parse_end() {
+ //do none
+}
diff --git a/editor/editor_properties.h b/editor/editor_properties.h
new file mode 100644
index 0000000000..0a831bfcfe
--- /dev/null
+++ b/editor/editor_properties.h
@@ -0,0 +1,490 @@
+#ifndef EDITOR_PROPERTIES_H
+#define EDITOR_PROPERTIES_H
+
+#include "editor/create_dialog.h"
+#include "editor/editor_file_system.h"
+#include "editor/editor_inspector.h"
+#include "editor/editor_spin_slider.h"
+#include "editor/property_selector.h"
+#include "editor/scene_tree_editor.h"
+#include "scene/gui/color_picker.h"
+
+class EditorPropertyText : public EditorProperty {
+ GDCLASS(EditorPropertyText, EditorProperty)
+ LineEdit *text;
+
+ bool updating;
+ void _text_changed(const String &p_string);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ EditorPropertyText();
+};
+
+class EditorPropertyMultilineText : public EditorProperty {
+ GDCLASS(EditorPropertyMultilineText, EditorProperty)
+ TextEdit *text;
+
+ AcceptDialog *big_text_dialog;
+ TextEdit *big_text;
+ Button *open_big_text;
+
+ void _big_text_changed();
+ void _text_changed();
+ void _open_big_text();
+
+protected:
+ void _notification(int p_what);
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ EditorPropertyMultilineText();
+};
+
+class EditorPropertyTextEnum : public EditorProperty {
+ GDCLASS(EditorPropertyTextEnum, EditorProperty)
+ OptionButton *options;
+
+ void _option_selected(int p_which);
+
+protected:
+ static void _bind_methods();
+
+public:
+ void setup(const Vector<String> &p_options);
+ virtual void update_property();
+ EditorPropertyTextEnum();
+};
+
+class EditorPropertyPath : public EditorProperty {
+ GDCLASS(EditorPropertyPath, EditorProperty)
+ Vector<String> extensions;
+ bool folder;
+ bool global;
+ EditorFileDialog *dialog;
+ Button *path;
+
+ void _path_selected(const String &p_path);
+ void _path_pressed();
+
+protected:
+ static void _bind_methods();
+
+public:
+ void setup(const Vector<String> &p_extensions, bool p_folder, bool p_global);
+ virtual void update_property();
+ EditorPropertyPath();
+};
+
+class EditorPropertyMember : public EditorProperty {
+ GDCLASS(EditorPropertyMember, EditorProperty)
+public:
+ enum Type {
+ MEMBER_METHOD_OF_VARIANT_TYPE, ///< a method of a type
+ MEMBER_METHOD_OF_BASE_TYPE, ///< a method of a base type
+ MEMBER_METHOD_OF_INSTANCE, ///< a method of an instance
+ MEMBER_METHOD_OF_SCRIPT, ///< a method of a script & base
+ MEMBER_PROPERTY_OF_VARIANT_TYPE, ///< a property of a type
+ MEMBER_PROPERTY_OF_BASE_TYPE, ///< a property of a base type
+ MEMBER_PROPERTY_OF_INSTANCE, ///< a property of an instance
+ MEMBER_PROPERTY_OF_SCRIPT, ///< a property of a script & base
+
+ };
+
+private:
+ Type hint;
+ PropertySelector *selector;
+ Button *property;
+ String hint_text;
+
+ void _property_selected(const String &p_selected);
+ void _property_select();
+
+protected:
+ static void _bind_methods();
+
+public:
+ void setup(Type p_hint, const String &p_hint_text);
+ virtual void update_property();
+ EditorPropertyMember();
+};
+
+class EditorPropertyCheck : public EditorProperty {
+ GDCLASS(EditorPropertyCheck, EditorProperty)
+ CheckBox *checkbox;
+
+ void _checkbox_pressed();
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ EditorPropertyCheck();
+};
+
+class EditorPropertyEnum : public EditorProperty {
+ GDCLASS(EditorPropertyEnum, EditorProperty)
+ OptionButton *options;
+
+ void _option_selected(int p_which);
+
+protected:
+ static void _bind_methods();
+
+public:
+ void setup(const Vector<String> &p_options);
+ virtual void update_property();
+ EditorPropertyEnum();
+};
+
+class EditorPropertyFlags : public EditorProperty {
+ GDCLASS(EditorPropertyFlags, EditorProperty)
+ VBoxContainer *vbox;
+ Vector<CheckBox *> flags;
+ Vector<int> flag_indices;
+
+ void _flag_toggled();
+
+protected:
+ static void _bind_methods();
+
+public:
+ void setup(const Vector<String> &p_options);
+ virtual void update_property();
+ EditorPropertyFlags();
+};
+
+class EditorPropertyLayersGrid;
+
+class EditorPropertyLayers : public EditorProperty {
+ GDCLASS(EditorPropertyLayers, EditorProperty)
+public:
+ enum LayerType {
+ LAYER_PHYSICS_2D,
+ LAYER_RENDER_2D,
+ LAYER_PHYSICS_3D,
+ LAYER_RENDER_3D,
+ };
+
+private:
+ EditorPropertyLayersGrid *grid;
+ void _grid_changed(uint32_t p_grid);
+ LayerType layer_type;
+ PopupMenu *layers;
+ Button *button;
+
+ void _button_pressed();
+ void _menu_pressed(int p_menu);
+
+protected:
+ static void _bind_methods();
+
+public:
+ void setup(LayerType p_layer_type);
+ virtual void update_property();
+ EditorPropertyLayers();
+};
+
+class EditorPropertyInteger : public EditorProperty {
+ GDCLASS(EditorPropertyInteger, EditorProperty)
+ EditorSpinSlider *spin;
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(int p_min, int p_max);
+ EditorPropertyInteger();
+};
+
+class EditorPropertyObjectID : public EditorProperty {
+ GDCLASS(EditorPropertyObjectID, EditorProperty)
+ Button *edit;
+ String base_type;
+ void _edit_pressed();
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(const String &p_base_type);
+ EditorPropertyObjectID();
+};
+
+class EditorPropertyFloat : public EditorProperty {
+ GDCLASS(EditorPropertyFloat, EditorProperty)
+ EditorSpinSlider *spin;
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider, bool p_exp_range);
+ EditorPropertyFloat();
+};
+
+class EditorPropertyEasing : public EditorProperty {
+ GDCLASS(EditorPropertyEasing, EditorProperty)
+ Control *easing_draw;
+ ToolButton *button_out, *button_in, *button_linear, *button_constant;
+ ToolButton *button_in_out, *button_out_in;
+ VBoxContainer *vb;
+
+ bool flip;
+
+ void _drag_easing(const Ref<InputEvent> &p_ev);
+ void _draw_easing();
+ void _notification(int p_what);
+ void _set_preset(float p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(bool p_full, bool p_flip);
+ EditorPropertyEasing();
+};
+
+class EditorPropertyVector2 : public EditorProperty {
+ GDCLASS(EditorPropertyVector2, EditorProperty)
+ EditorSpinSlider *spin[2];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyVector2();
+};
+
+class EditorPropertyRect2 : public EditorProperty {
+ GDCLASS(EditorPropertyRect2, EditorProperty)
+ EditorSpinSlider *spin[4];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyRect2();
+};
+
+class EditorPropertyVector3 : public EditorProperty {
+ GDCLASS(EditorPropertyVector3, EditorProperty)
+ EditorSpinSlider *spin[3];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyVector3();
+};
+
+class EditorPropertyPlane : public EditorProperty {
+ GDCLASS(EditorPropertyPlane, EditorProperty)
+ EditorSpinSlider *spin[4];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyPlane();
+};
+
+class EditorPropertyQuat : public EditorProperty {
+ GDCLASS(EditorPropertyQuat, EditorProperty)
+ EditorSpinSlider *spin[4];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyQuat();
+};
+
+class EditorPropertyAABB : public EditorProperty {
+ GDCLASS(EditorPropertyAABB, EditorProperty)
+ EditorSpinSlider *spin[6];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyAABB();
+};
+
+class EditorPropertyTransform2D : public EditorProperty {
+ GDCLASS(EditorPropertyTransform2D, EditorProperty)
+ EditorSpinSlider *spin[6];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyTransform2D();
+};
+
+class EditorPropertyBasis : public EditorProperty {
+ GDCLASS(EditorPropertyBasis, EditorProperty)
+ EditorSpinSlider *spin[9];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyBasis();
+};
+
+class EditorPropertyTransform : public EditorProperty {
+ GDCLASS(EditorPropertyTransform, EditorProperty)
+ EditorSpinSlider *spin[12];
+ bool setting;
+ void _value_changed(double p_val);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(double p_min, double p_max, double p_step, bool p_no_slider);
+ EditorPropertyTransform();
+};
+
+class EditorPropertyColor : public EditorProperty {
+ GDCLASS(EditorPropertyColor, EditorProperty)
+ ColorPickerButton *picker;
+ void _color_changed(const Color &p_color);
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual void update_property();
+ void setup(bool p_show_alpha);
+ EditorPropertyColor();
+};
+
+class EditorPropertyNodePath : public EditorProperty {
+ GDCLASS(EditorPropertyNodePath, EditorProperty)
+ Button *assign;
+ Button *clear;
+ SceneTreeDialog *scene_tree;
+ NodePath base_hint;
+
+ void _node_selected(const NodePath &p_path);
+ void _node_assign();
+ void _node_clear();
+
+protected:
+ static void _bind_methods();
+ void _notification(int p_what);
+
+public:
+ virtual void update_property();
+ void setup(const NodePath &p_base_hint);
+ EditorPropertyNodePath();
+};
+
+class EditorPropertyResource : public EditorProperty {
+ GDCLASS(EditorPropertyResource, EditorProperty)
+
+ enum MenuOption {
+
+ OBJ_MENU_LOAD = 0,
+ OBJ_MENU_EDIT = 1,
+ OBJ_MENU_CLEAR = 2,
+ OBJ_MENU_MAKE_UNIQUE = 3,
+ OBJ_MENU_COPY = 4,
+ OBJ_MENU_PASTE = 5,
+ OBJ_MENU_NEW_SCRIPT = 6,
+ OBJ_MENU_SHOW_IN_FILE_SYSTEM = 7,
+ TYPE_BASE_ID = 100,
+ CONVERT_BASE_ID = 1000
+
+ };
+
+ Button *assign;
+ Button *edit;
+ PopupMenu *menu;
+ EditorFileDialog *file;
+ Vector<String> inheritors_array;
+
+ String base_type;
+
+ SceneTreeDialog *scene_tree;
+
+ void _file_selected(const String &p_path);
+ void _menu_option(int p_which);
+ void _resource_preview(const String &p_path, const Ref<Texture> &p_preview, ObjectID p_obj);
+ void _resource_selected();
+ void _viewport_selected(const NodePath &p_path);
+
+ void _update_menu();
+
+protected:
+ static void _bind_methods();
+ void _notification(int p_what);
+
+public:
+ virtual void update_property();
+ void setup(const String &p_base_type);
+ EditorPropertyResource();
+};
+
+///////////////////////////////////////////////////
+/// \brief The EditorInspectorDefaultPlugin class
+///
+class EditorInspectorDefaultPlugin : public EditorInspectorPlugin {
+ GDCLASS(EditorInspectorDefaultPlugin, EditorInspectorPlugin)
+
+public:
+ virtual bool can_handle(Object *p_object);
+ virtual void parse_begin(Object *p_object);
+ virtual bool parse_property(Object *p_object, Variant::Type p_type, const String &p_path, PropertyHint p_hint, const String &p_hint_text, int p_usage);
+ virtual void parse_end();
+};
+
+#endif // EDITOR_PROPERTIES_H
diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp
index 7aca92e3ab..68705fa29d 100644
--- a/editor/editor_settings.cpp
+++ b/editor/editor_settings.cpp
@@ -371,6 +371,7 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
_initial_set("text_editor/line_numbers/line_numbers_zero_padded", false);
_initial_set("text_editor/line_numbers/show_breakpoint_gutter", true);
_initial_set("text_editor/line_numbers/code_folding", true);
+ _initial_set("text_editor/line_numbers/word_wrap", false);
_initial_set("text_editor/line_numbers/show_line_length_guideline", false);
_initial_set("text_editor/line_numbers/line_length_guideline_column", 80);
hints["text_editor/line_numbers/line_length_guideline_column"] = PropertyInfo(Variant::INT, "text_editor/line_numbers/line_length_guideline_column", PROPERTY_HINT_RANGE, "20, 160, 1");
diff --git a/editor/editor_spin_slider.cpp b/editor/editor_spin_slider.cpp
new file mode 100644
index 0000000000..8143e74a40
--- /dev/null
+++ b/editor/editor_spin_slider.cpp
@@ -0,0 +1,315 @@
+#include "editor_spin_slider.h"
+#include "editor_scale.h"
+#include "os/input.h"
+String EditorSpinSlider::get_text_value() const {
+ int zeros = Math::step_decimals(get_step());
+ return String::num(get_value(), zeros);
+}
+void EditorSpinSlider::_gui_input(const Ref<InputEvent> &p_event) {
+
+ Ref<InputEventMouseButton> mb = p_event;
+ if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT) {
+
+ if (mb->is_pressed()) {
+
+ if (updown_offset != -1 && mb->get_position().x > updown_offset) {
+ //there is an updown, so use it.
+ if (mb->get_position().y < get_size().height / 2) {
+ set_value(get_value() + get_step());
+ } else {
+ set_value(get_value() - get_step());
+ }
+ return;
+ } else {
+
+ grabbing_spinner_attempt = true;
+ grabbing_spinner = false;
+ grabbing_spinner_mouse_pos = Input::get_singleton()->get_mouse_position();
+ }
+ } else {
+
+ if (grabbing_spinner_attempt) {
+
+ if (grabbing_spinner) {
+
+ Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_VISIBLE);
+ Input::get_singleton()->warp_mouse_position(grabbing_spinner_mouse_pos);
+ update();
+ } else {
+ Rect2 gr = get_global_rect();
+ value_input->set_text(get_text_value());
+ value_input->set_position(gr.position);
+ value_input->set_size(gr.size);
+ value_input->call_deferred("show_modal");
+ value_input->call_deferred("grab_focus");
+ value_input->call_deferred("select_all");
+ }
+
+ grabbing_spinner = false;
+ grabbing_spinner_attempt = false;
+ }
+ }
+ }
+
+ Ref<InputEventMouseMotion> mm = p_event;
+ if (mm.is_valid()) {
+
+ if (grabbing_spinner_attempt) {
+
+ if (!grabbing_spinner) {
+ Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_CAPTURED);
+ grabbing_spinner = true;
+ }
+
+ double v = get_value();
+
+ double diff_x = mm->get_relative().x;
+ diff_x = Math::pow(ABS(diff_x), 1.8f) * SGN(diff_x);
+ diff_x *= 0.1;
+
+ v += diff_x * get_step();
+
+ set_value(v);
+
+ } else if (updown_offset != -1) {
+ bool new_hover = (mm->get_position().x > updown_offset);
+ if (new_hover != hover_updown) {
+ hover_updown = new_hover;
+ update();
+ }
+ }
+ }
+
+ Ref<InputEventKey> k = p_event;
+ if (k.is_valid() && k->is_pressed() && k->is_action("ui_accept")) {
+ Rect2 gr = get_global_rect();
+ value_input->set_text(get_text_value());
+ value_input->set_position(gr.position);
+ value_input->set_size(gr.size);
+ value_input->call_deferred("show_modal");
+ value_input->call_deferred("grab_focus");
+ value_input->call_deferred("select_all");
+ }
+}
+
+void EditorSpinSlider::_value_input_closed() {
+ set_value(value_input->get_text().to_double());
+}
+
+void EditorSpinSlider::_value_input_entered(const String &p_text) {
+ set_value(p_text.to_double());
+ value_input->hide();
+}
+
+void EditorSpinSlider::_grabber_gui_input(const Ref<InputEvent> &p_event) {
+
+ Ref<InputEventMouseButton> mb = p_event;
+ if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT) {
+
+ if (mb->is_pressed()) {
+
+ grabbing_grabber = true;
+ grabbing_ratio = get_as_ratio();
+ grabbing_from = grabber->get_transform().xform(mb->get_position()).x;
+ } else {
+ grabbing_grabber = false;
+ }
+ }
+
+ Ref<InputEventMouseMotion> mm = p_event;
+ if (mm.is_valid() && grabbing_grabber) {
+
+ float grabbing_ofs = (grabber->get_transform().xform(mm->get_position()).x - grabbing_from) / float(grabber_range);
+ set_as_ratio(grabbing_ratio + grabbing_ofs);
+ update();
+ }
+}
+
+void EditorSpinSlider::_notification(int p_what) {
+
+ if (p_what == MainLoop::NOTIFICATION_WM_FOCUS_OUT || p_what == MainLoop::NOTIFICATION_WM_FOCUS_OUT) {
+ if (grabbing_spinner) {
+ Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_VISIBLE);
+ grabbing_spinner = false;
+ grabbing_spinner_attempt = false;
+ }
+ }
+
+ if (p_what == NOTIFICATION_DRAW) {
+
+ updown_offset = -1;
+
+ Ref<StyleBox> sb = get_stylebox("normal", "LineEdit");
+ draw_style_box(sb, Rect2(Vector2(), get_size()));
+ Ref<Font> font = get_font("font", "LineEdit");
+
+ int avail_width = get_size().width - sb->get_minimum_size().width - sb->get_minimum_size().width;
+ avail_width -= font->get_string_size(label).width;
+ Ref<Texture> updown = get_icon("updown", "SpinBox");
+
+ if (get_step() == 1) {
+ avail_width -= updown->get_width();
+ }
+
+ if (has_focus()) {
+ Ref<StyleBox> focus = get_stylebox("focus", "LineEdit");
+ draw_style_box(focus, Rect2(Vector2(), get_size()));
+ }
+
+ String numstr = get_text_value();
+
+ int vofs = (get_size().height - font->get_height()) / 2 + font->get_ascent();
+
+ Color fc = get_color("font_color", "LineEdit");
+
+ int label_ofs = sb->get_offset().x + avail_width;
+ draw_string(font, Vector2(label_ofs, vofs), label, fc * Color(1, 1, 1, 0.5));
+ draw_string(font, Vector2(sb->get_offset().x, vofs), numstr, fc, avail_width);
+
+ if (get_step() == 1) {
+ Ref<Texture> updown = get_icon("updown", "SpinBox");
+ int updown_vofs = (get_size().height - updown->get_height()) / 2;
+ updown_offset = get_size().width - sb->get_margin(MARGIN_RIGHT) - updown->get_width();
+ Color c(1, 1, 1);
+ if (hover_updown) {
+ c *= Color(1.2, 1.2, 1.2);
+ }
+ draw_texture(updown, Vector2(updown_offset, updown_vofs), c);
+ if (grabber->is_visible()) {
+ grabber->hide();
+ }
+ } else if (!hide_slider) {
+ int grabber_w = 4 * EDSCALE;
+ int width = get_size().width - sb->get_minimum_size().width - grabber_w;
+ int ofs = sb->get_offset().x;
+ int svofs = (get_size().height + vofs) / 2 - 1;
+ Color c = fc;
+ c.a = 0.2;
+
+ draw_rect(Rect2(ofs, svofs + 1, width, 2 * EDSCALE), c);
+ int gofs = get_as_ratio() * width;
+ c.a = 0.9;
+ Rect2 grabber_rect = Rect2(ofs + gofs, svofs + 1, grabber_w, 2 * EDSCALE);
+ draw_rect(grabber_rect, c);
+
+ bool display_grabber = (mouse_over_spin || mouse_over_grabber) && !grabbing_spinner;
+ if (grabber->is_visible() != display_grabber) {
+ if (display_grabber) {
+ grabber->show();
+ } else {
+ grabber->hide();
+ }
+ }
+
+ if (display_grabber) {
+ Ref<Texture> grabber_tex;
+ if (mouse_over_grabber) {
+ grabber_tex = get_icon("grabber_highlight", "HSlider");
+ } else {
+ grabber_tex = get_icon("grabber", "HSlider");
+ }
+
+ if (grabber->get_texture() != grabber_tex) {
+ grabber->set_texture(grabber_tex);
+ }
+
+ grabber->set_size(Size2(0, 0));
+ grabber->set_position(get_global_position() + grabber_rect.position + grabber_rect.size * 0.5 - grabber->get_size() * 0.5);
+ grabber_range = width;
+ }
+ }
+ }
+
+ if (p_what == NOTIFICATION_MOUSE_ENTER) {
+
+ mouse_over_spin = true;
+ update();
+ }
+ if (p_what == NOTIFICATION_MOUSE_EXIT) {
+
+ mouse_over_spin = false;
+ update();
+ }
+}
+
+Size2 EditorSpinSlider::get_minimum_size() const {
+
+ Ref<StyleBox> sb = get_stylebox("normal", "LineEdit");
+ Ref<Font> font = get_font("font", "LineEdit");
+
+ Size2 ms = sb->get_minimum_size();
+ ms.height += font->get_height();
+
+ return ms;
+}
+
+void EditorSpinSlider::set_hide_slider(bool p_hide) {
+ hide_slider = p_hide;
+ update();
+}
+
+bool EditorSpinSlider::is_hiding_slider() const {
+ return hide_slider;
+}
+
+void EditorSpinSlider::set_label(const String &p_label) {
+ label = p_label;
+ update();
+}
+
+String EditorSpinSlider::get_label() const {
+ return label;
+}
+
+void EditorSpinSlider::_grabber_mouse_entered() {
+ mouse_over_grabber = true;
+ update();
+}
+
+void EditorSpinSlider::_grabber_mouse_exited() {
+ mouse_over_grabber = false;
+ update();
+}
+
+void EditorSpinSlider::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_label", "label"), &EditorSpinSlider::set_label);
+ ClassDB::bind_method(D_METHOD("get_label"), &EditorSpinSlider::get_label);
+
+ ClassDB::bind_method(D_METHOD("_gui_input"), &EditorSpinSlider::_gui_input);
+ ClassDB::bind_method(D_METHOD("_grabber_mouse_entered"), &EditorSpinSlider::_grabber_mouse_entered);
+ ClassDB::bind_method(D_METHOD("_grabber_mouse_exited"), &EditorSpinSlider::_grabber_mouse_exited);
+ ClassDB::bind_method(D_METHOD("_grabber_gui_input"), &EditorSpinSlider::_grabber_gui_input);
+ ClassDB::bind_method(D_METHOD("_value_input_closed"), &EditorSpinSlider::_value_input_closed);
+ ClassDB::bind_method(D_METHOD("_value_input_entered"), &EditorSpinSlider::_value_input_entered);
+
+ ADD_PROPERTY(PropertyInfo(Variant::STRING, "label"), "set_label", "get_label");
+}
+
+EditorSpinSlider::EditorSpinSlider() {
+
+ grabbing_spinner_attempt = false;
+ grabbing_spinner = false;
+
+ set_focus_mode(FOCUS_ALL);
+ updown_offset = -1;
+ hover_updown = false;
+ grabber = memnew(TextureRect);
+ add_child(grabber);
+ grabber->hide();
+ grabber->set_as_toplevel(true);
+ grabber->set_mouse_filter(MOUSE_FILTER_STOP);
+ grabber->connect("mouse_entered", this, "_grabber_mouse_entered");
+ grabber->connect("mouse_exited", this, "_grabber_mouse_exited");
+ grabber->connect("gui_input", this, "_grabber_gui_input");
+ mouse_over_spin = false;
+ mouse_over_grabber = false;
+ grabbing_grabber = false;
+ grabber_range = 1;
+ value_input = memnew(LineEdit);
+ add_child(value_input);
+ value_input->set_as_toplevel(true);
+ value_input->hide();
+ value_input->connect("modal_closed", this, "_value_input_closed");
+ value_input->connect("text_entered", this, "_value_input_entered");
+ hide_slider = false;
+}
diff --git a/editor/editor_spin_slider.h b/editor/editor_spin_slider.h
new file mode 100644
index 0000000000..ac8d9e15d6
--- /dev/null
+++ b/editor/editor_spin_slider.h
@@ -0,0 +1,57 @@
+#ifndef EDITOR_SPIN_SLIDER_H
+#define EDITOR_SPIN_SLIDER_H
+
+#include "scene/gui/line_edit.h"
+#include "scene/gui/range.h"
+#include "scene/gui/texture_rect.h"
+
+class EditorSpinSlider : public Range {
+ GDCLASS(EditorSpinSlider, Range)
+
+ String label;
+ int updown_offset;
+ bool hover_updown;
+ bool mouse_hover;
+
+ TextureRect *grabber;
+ int grabber_range;
+
+ bool mouse_over_spin;
+ bool mouse_over_grabber;
+
+ bool grabbing_grabber;
+ int grabbing_from;
+ float grabbing_ratio;
+
+ bool grabbing_spinner_attempt;
+ bool grabbing_spinner;
+ Vector2 grabbing_spinner_mouse_pos;
+
+ LineEdit *value_input;
+
+ void _grabber_gui_input(const Ref<InputEvent> &p_event);
+ void _value_input_closed();
+ void _value_input_entered(const String &);
+
+ bool hide_slider;
+
+protected:
+ void _notification(int p_what);
+ void _gui_input(const Ref<InputEvent> &p_event);
+ static void _bind_methods();
+ void _grabber_mouse_entered();
+ void _grabber_mouse_exited();
+
+public:
+ String get_text_value() const;
+ void set_label(const String &p_label);
+ String get_label() const;
+
+ void set_hide_slider(bool p_hide);
+ bool is_hiding_slider() const;
+
+ virtual Size2 get_minimum_size() const;
+ EditorSpinSlider();
+};
+
+#endif // EDITOR_SPIN_SLIDER_H
diff --git a/editor/icons/icon_GUI_slider_grabber.svg b/editor/icons/icon_GUI_slider_grabber.svg
index b1dcf980a5..b8e6f0a654 100644
--- a/editor/icons/icon_GUI_slider_grabber.svg
+++ b/editor/icons/icon_GUI_slider_grabber.svg
@@ -1,5 +1,82 @@
-<svg width="16" height="16" version="1.1" viewBox="0 0 16 15.999999" xmlns="http://www.w3.org/2000/svg">
-<g transform="translate(0 -1036.4)">
-<circle cx="8" cy="1044.4" r="3" fill="#fff" fill-opacity=".78431" stroke-linejoin="round" stroke-opacity=".39216" stroke-width="3"/>
-</g>
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="16"
+ height="16"
+ version="1.1"
+ viewBox="0 0 16 15.999999"
+ id="svg8"
+ sodipodi:docname="icon_GUI_slider_grabber.svg"
+ inkscape:version="0.92.3 (2405546, 2018-03-11)">
+ <metadata
+ id="metadata14">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title></dc:title>
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <defs
+ id="defs12" />
+ <sodipodi:namedview
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1"
+ objecttolerance="10"
+ gridtolerance="10"
+ guidetolerance="10"
+ inkscape:pageopacity="0"
+ inkscape:pageshadow="2"
+ inkscape:window-width="1211"
+ inkscape:window-height="644"
+ id="namedview10"
+ showgrid="false"
+ inkscape:zoom="14.75"
+ inkscape:cx="-5.7627119"
+ inkscape:cy="8"
+ inkscape:window-x="67"
+ inkscape:window-y="27"
+ inkscape:window-maximized="0"
+ inkscape:current-layer="g6" />
+ <g
+ transform="translate(0 -1036.4)"
+ id="g6">
+ <path
+ transform="translate(0 1036.4)"
+ d="m8 1a7 7 0 0 0 -7 7 7 7 0 0 0 7 7 7 7 0 0 0 7 -7 7 7 0 0 0 -7 -7zm0 2a5 5 0 0 1 0.5 0.025391 5 5 0 0 1 0.49414 0.074219 5 5 0 0 1 0.48438 0.12305 5 5 0 0 1 0.46875 0.17188 5 5 0 0 1 0.44922 0.2168 5 5 0 0 1 0.42578 0.26172 5 5 0 0 1 0.39844 0.30273 5 5 0 0 1 0.36524 0.33984 5 5 0 0 1 0.33008 0.37695 5 5 0 0 1 0.29102 0.40625 5 5 0 0 1 0.24805 0.43359 5 5 0 0 1 0.20508 0.45508 5 5 0 0 1 0.1582 0.47461 5 5 0 0 1 0.10938 0.48828 5 5 0 0 1 0.060547 0.49609 5 5 0 0 1 0.011719 0.35352 5 5 0 0 1 -0.025391 0.5 5 5 0 0 1 -0.074218 0.49414 5 5 0 0 1 -0.12305 0.48438 5 5 0 0 1 -0.17188 0.46875 5 5 0 0 1 -0.2168 0.44922 5 5 0 0 1 -0.26172 0.42578 5 5 0 0 1 -0.30273 0.39844 5 5 0 0 1 -0.33984 0.36524 5 5 0 0 1 -0.37695 0.33008 5 5 0 0 1 -0.40625 0.29102 5 5 0 0 1 -0.43359 0.24805 5 5 0 0 1 -0.45508 0.20508 5 5 0 0 1 -0.47461 0.1582 5 5 0 0 1 -0.48828 0.10938 5 5 0 0 1 -0.49609 0.060547 5 5 0 0 1 -0.35352 0.011719 5 5 0 0 1 -0.5 -0.025391 5 5 0 0 1 -0.49414 -0.074218 5 5 0 0 1 -0.48438 -0.12305 5 5 0 0 1 -0.46875 -0.17188 5 5 0 0 1 -0.44922 -0.2168 5 5 0 0 1 -0.42578 -0.26172 5 5 0 0 1 -0.39844 -0.30273 5 5 0 0 1 -0.36523 -0.33984 5 5 0 0 1 -0.33008 -0.37695 5 5 0 0 1 -0.29102 -0.40625 5 5 0 0 1 -0.24805 -0.43359 5 5 0 0 1 -0.20508 -0.45508 5 5 0 0 1 -0.1582 -0.47461 5 5 0 0 1 -0.10938 -0.48828 5 5 0 0 1 -0.060547 -0.49609 5 5 0 0 1 -0.011719 -0.35352 5 5 0 0 1 0.025391 -0.5 5 5 0 0 1 0.074219 -0.49414 5 5 0 0 1 0.12305 -0.48438 5 5 0 0 1 0.17188 -0.46875 5 5 0 0 1 0.2168 -0.44922 5 5 0 0 1 0.26172 -0.42578 5 5 0 0 1 0.30273 -0.39844 5 5 0 0 1 0.33984 -0.36523 5 5 0 0 1 0.37695 -0.33008 5 5 0 0 1 0.40625 -0.29102 5 5 0 0 1 0.43359 -0.24805 5 5 0 0 1 0.45508 -0.20508 5 5 0 0 1 0.47461 -0.1582 5 5 0 0 1 0.48828 -0.10938 5 5 0 0 1 0.49609 -0.060547 5 5 0 0 1 0.35352 -0.011719z"
+ fill="#e0e0e0"
+ id="path2"
+ style="fill:#e0e0e0;fill-opacity:0.28925619" />
+ <circle
+ cx="8"
+ cy="1044.4"
+ r="3"
+ fill="#fff"
+ fill-opacity=".58824"
+ stroke-linecap="round"
+ stroke-linejoin="round"
+ stroke-opacity=".32549"
+ stroke-width="3"
+ id="circle4" />
+ </g>
+ <g
+ transform="translate(-0.06779632,-1036.4)"
+ id="g18">
+ <circle
+ style="fill:#ffffff;fill-opacity:0.78430996;stroke-width:3;stroke-linejoin:round;stroke-opacity:0.39216003"
+ cx="8"
+ cy="1044.4"
+ r="3"
+ id="circle16" />
+ </g>
</svg>
diff --git a/editor/icons/icon_GUI_slider_grabber_hl.svg b/editor/icons/icon_GUI_slider_grabber_hl.svg
index 73252751ce..a04ac44cf6 100644
--- a/editor/icons/icon_GUI_slider_grabber_hl.svg
+++ b/editor/icons/icon_GUI_slider_grabber_hl.svg
@@ -1,6 +1,80 @@
-<svg width="16" height="16" version="1.1" viewBox="0 0 16 15.999999" xmlns="http://www.w3.org/2000/svg">
-<g transform="translate(0 -1036.4)">
-<path transform="translate(0 1036.4)" d="m8 1a7 7 0 0 0 -7 7 7 7 0 0 0 7 7 7 7 0 0 0 7 -7 7 7 0 0 0 -7 -7zm0 2a5 5 0 0 1 0.5 0.025391 5 5 0 0 1 0.49414 0.074219 5 5 0 0 1 0.48438 0.12305 5 5 0 0 1 0.46875 0.17188 5 5 0 0 1 0.44922 0.2168 5 5 0 0 1 0.42578 0.26172 5 5 0 0 1 0.39844 0.30273 5 5 0 0 1 0.36524 0.33984 5 5 0 0 1 0.33008 0.37695 5 5 0 0 1 0.29102 0.40625 5 5 0 0 1 0.24805 0.43359 5 5 0 0 1 0.20508 0.45508 5 5 0 0 1 0.1582 0.47461 5 5 0 0 1 0.10938 0.48828 5 5 0 0 1 0.060547 0.49609 5 5 0 0 1 0.011719 0.35352 5 5 0 0 1 -0.025391 0.5 5 5 0 0 1 -0.074218 0.49414 5 5 0 0 1 -0.12305 0.48438 5 5 0 0 1 -0.17188 0.46875 5 5 0 0 1 -0.2168 0.44922 5 5 0 0 1 -0.26172 0.42578 5 5 0 0 1 -0.30273 0.39844 5 5 0 0 1 -0.33984 0.36524 5 5 0 0 1 -0.37695 0.33008 5 5 0 0 1 -0.40625 0.29102 5 5 0 0 1 -0.43359 0.24805 5 5 0 0 1 -0.45508 0.20508 5 5 0 0 1 -0.47461 0.1582 5 5 0 0 1 -0.48828 0.10938 5 5 0 0 1 -0.49609 0.060547 5 5 0 0 1 -0.35352 0.011719 5 5 0 0 1 -0.5 -0.025391 5 5 0 0 1 -0.49414 -0.074218 5 5 0 0 1 -0.48438 -0.12305 5 5 0 0 1 -0.46875 -0.17188 5 5 0 0 1 -0.44922 -0.2168 5 5 0 0 1 -0.42578 -0.26172 5 5 0 0 1 -0.39844 -0.30273 5 5 0 0 1 -0.36523 -0.33984 5 5 0 0 1 -0.33008 -0.37695 5 5 0 0 1 -0.29102 -0.40625 5 5 0 0 1 -0.24805 -0.43359 5 5 0 0 1 -0.20508 -0.45508 5 5 0 0 1 -0.1582 -0.47461 5 5 0 0 1 -0.10938 -0.48828 5 5 0 0 1 -0.060547 -0.49609 5 5 0 0 1 -0.011719 -0.35352 5 5 0 0 1 0.025391 -0.5 5 5 0 0 1 0.074219 -0.49414 5 5 0 0 1 0.12305 -0.48438 5 5 0 0 1 0.17188 -0.46875 5 5 0 0 1 0.2168 -0.44922 5 5 0 0 1 0.26172 -0.42578 5 5 0 0 1 0.30273 -0.39844 5 5 0 0 1 0.33984 -0.36523 5 5 0 0 1 0.37695 -0.33008 5 5 0 0 1 0.40625 -0.29102 5 5 0 0 1 0.43359 -0.24805 5 5 0 0 1 0.45508 -0.20508 5 5 0 0 1 0.47461 -0.1582 5 5 0 0 1 0.48828 -0.10938 5 5 0 0 1 0.49609 -0.060547 5 5 0 0 1 0.35352 -0.011719z" fill="#e0e0e0"/>
-<circle cx="8" cy="1044.4" r="3" fill="#fff" fill-opacity=".58824" stroke-linecap="round" stroke-linejoin="round" stroke-opacity=".32549" stroke-width="3"/>
-</g>
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="16"
+ height="16"
+ version="1.1"
+ viewBox="0 0 16 15.999999"
+ id="svg8"
+ sodipodi:docname="icon_GUI_slider_grabber_hl.svg"
+ inkscape:version="0.92.3 (2405546, 2018-03-11)">
+ <metadata
+ id="metadata14">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <defs
+ id="defs12" />
+ <sodipodi:namedview
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1"
+ objecttolerance="10"
+ gridtolerance="10"
+ guidetolerance="10"
+ inkscape:pageopacity="0"
+ inkscape:pageshadow="2"
+ inkscape:window-width="944"
+ inkscape:window-height="480"
+ id="namedview10"
+ showgrid="false"
+ inkscape:zoom="14.75"
+ inkscape:cx="8"
+ inkscape:cy="8"
+ inkscape:window-x="67"
+ inkscape:window-y="27"
+ inkscape:window-maximized="0"
+ inkscape:current-layer="svg8" />
+ <g
+ transform="translate(0 -1036.4)"
+ id="g6">
+ <path
+ transform="translate(0 1036.4)"
+ d="m8 1a7 7 0 0 0 -7 7 7 7 0 0 0 7 7 7 7 0 0 0 7 -7 7 7 0 0 0 -7 -7zm0 2a5 5 0 0 1 0.5 0.025391 5 5 0 0 1 0.49414 0.074219 5 5 0 0 1 0.48438 0.12305 5 5 0 0 1 0.46875 0.17188 5 5 0 0 1 0.44922 0.2168 5 5 0 0 1 0.42578 0.26172 5 5 0 0 1 0.39844 0.30273 5 5 0 0 1 0.36524 0.33984 5 5 0 0 1 0.33008 0.37695 5 5 0 0 1 0.29102 0.40625 5 5 0 0 1 0.24805 0.43359 5 5 0 0 1 0.20508 0.45508 5 5 0 0 1 0.1582 0.47461 5 5 0 0 1 0.10938 0.48828 5 5 0 0 1 0.060547 0.49609 5 5 0 0 1 0.011719 0.35352 5 5 0 0 1 -0.025391 0.5 5 5 0 0 1 -0.074218 0.49414 5 5 0 0 1 -0.12305 0.48438 5 5 0 0 1 -0.17188 0.46875 5 5 0 0 1 -0.2168 0.44922 5 5 0 0 1 -0.26172 0.42578 5 5 0 0 1 -0.30273 0.39844 5 5 0 0 1 -0.33984 0.36524 5 5 0 0 1 -0.37695 0.33008 5 5 0 0 1 -0.40625 0.29102 5 5 0 0 1 -0.43359 0.24805 5 5 0 0 1 -0.45508 0.20508 5 5 0 0 1 -0.47461 0.1582 5 5 0 0 1 -0.48828 0.10938 5 5 0 0 1 -0.49609 0.060547 5 5 0 0 1 -0.35352 0.011719 5 5 0 0 1 -0.5 -0.025391 5 5 0 0 1 -0.49414 -0.074218 5 5 0 0 1 -0.48438 -0.12305 5 5 0 0 1 -0.46875 -0.17188 5 5 0 0 1 -0.44922 -0.2168 5 5 0 0 1 -0.42578 -0.26172 5 5 0 0 1 -0.39844 -0.30273 5 5 0 0 1 -0.36523 -0.33984 5 5 0 0 1 -0.33008 -0.37695 5 5 0 0 1 -0.29102 -0.40625 5 5 0 0 1 -0.24805 -0.43359 5 5 0 0 1 -0.20508 -0.45508 5 5 0 0 1 -0.1582 -0.47461 5 5 0 0 1 -0.10938 -0.48828 5 5 0 0 1 -0.060547 -0.49609 5 5 0 0 1 -0.011719 -0.35352 5 5 0 0 1 0.025391 -0.5 5 5 0 0 1 0.074219 -0.49414 5 5 0 0 1 0.12305 -0.48438 5 5 0 0 1 0.17188 -0.46875 5 5 0 0 1 0.2168 -0.44922 5 5 0 0 1 0.26172 -0.42578 5 5 0 0 1 0.30273 -0.39844 5 5 0 0 1 0.33984 -0.36523 5 5 0 0 1 0.37695 -0.33008 5 5 0 0 1 0.40625 -0.29102 5 5 0 0 1 0.43359 -0.24805 5 5 0 0 1 0.45508 -0.20508 5 5 0 0 1 0.47461 -0.1582 5 5 0 0 1 0.48828 -0.10938 5 5 0 0 1 0.49609 -0.060547 5 5 0 0 1 0.35352 -0.011719z"
+ fill="#e0e0e0"
+ id="path2" />
+ <circle
+ cx="8"
+ cy="1044.4"
+ r="3"
+ fill="#fff"
+ fill-opacity=".58824"
+ stroke-linecap="round"
+ stroke-linejoin="round"
+ stroke-opacity=".32549"
+ stroke-width="3"
+ id="circle4" />
+ </g>
+ <g
+ transform="translate(-0.06779632,-1036.4)"
+ id="g18">
+ <circle
+ style="fill:#ffffff;fill-opacity:0.78430996;stroke-width:3;stroke-linejoin:round;stroke-opacity:0.39216003"
+ cx="8"
+ cy="1044.4"
+ r="3"
+ id="circle16" />
+ </g>
</svg>
diff --git a/editor/multi_node_edit.cpp b/editor/multi_node_edit.cpp
index 73e78ddf2a..173be01586 100644
--- a/editor/multi_node_edit.cpp
+++ b/editor/multi_node_edit.cpp
@@ -80,8 +80,8 @@ bool MultiNodeEdit::_set_impl(const StringName &p_name, const Variant &p_value,
ur->add_undo_property(n, name, n->get(name));
}
- ur->add_do_method(EditorNode::get_singleton()->get_property_editor(), "refresh");
- ur->add_undo_method(EditorNode::get_singleton()->get_property_editor(), "refresh");
+ ur->add_do_method(EditorNode::get_singleton()->get_inspector(), "refresh");
+ ur->add_undo_method(EditorNode::get_singleton()->get_inspector(), "refresh");
ur->commit_action();
return true;
diff --git a/editor/plugins/animation_player_editor_plugin.cpp b/editor/plugins/animation_player_editor_plugin.cpp
index b387972558..23c5e36a92 100644
--- a/editor/plugins/animation_player_editor_plugin.cpp
+++ b/editor/plugins/animation_player_editor_plugin.cpp
@@ -85,7 +85,7 @@ void AnimationPlayerEditor::_notification(int p_what) {
}
frame->set_value(player->get_current_animation_position());
key_editor->set_anim_pos(player->get_current_animation_position());
- EditorNode::get_singleton()->get_property_editor()->refresh();
+ EditorNode::get_singleton()->get_inspector()->refresh();
} else if (last_active) {
//need the last frame after it stopped
@@ -1073,7 +1073,7 @@ void AnimationPlayerEditor::_animation_key_editor_seek(float p_pos, bool p_drag)
updating = false;
_seek_value_changed(p_pos, !p_drag);
- EditorNode::get_singleton()->get_property_editor()->refresh();
+ EditorNode::get_singleton()->get_inspector()->refresh();
//seekit
}
diff --git a/editor/plugins/canvas_item_editor_plugin.cpp b/editor/plugins/canvas_item_editor_plugin.cpp
index 93aeca6632..f27796db5e 100644
--- a/editor/plugins/canvas_item_editor_plugin.cpp
+++ b/editor/plugins/canvas_item_editor_plugin.cpp
@@ -520,8 +520,17 @@ void CanvasItemEditor::_get_canvas_items_at_pos(const Point2 &p_pos, Vector<_Sel
node = node->get_parent();
}
+ // Check if the canvas item is already in the list (for groups or scenes)
+ bool duplicate = false;
+ for (int j = 0; j < i; j++) {
+ if (r_items[j].item == canvas_item) {
+ duplicate = true;
+ break;
+ }
+ }
+
//Remove the item if invalid
- if (!canvas_item || (canvas_item != scene && canvas_item->get_owner() != scene && !scene->is_editable_instance(canvas_item->get_owner())) || (canvas_item->has_meta("_edit_lock_") && canvas_item->get_meta("_edit_lock_"))) {
+ if (!canvas_item || duplicate || (canvas_item != scene && canvas_item->get_owner() != scene && !scene->is_editable_instance(canvas_item->get_owner())) || (canvas_item->has_meta("_edit_lock_") && canvas_item->get_meta("_edit_lock_"))) {
r_items.remove(i);
i--;
} else {
diff --git a/editor/plugins/cube_grid_theme_editor_plugin.cpp b/editor/plugins/cube_grid_theme_editor_plugin.cpp
index 81f45b9f55..68d5ea5247 100644
--- a/editor/plugins/cube_grid_theme_editor_plugin.cpp
+++ b/editor/plugins/cube_grid_theme_editor_plugin.cpp
@@ -198,7 +198,7 @@ void MeshLibraryEditor::_menu_cbk(int p_option) {
} break;
case MENU_OPTION_REMOVE_ITEM: {
- String p = editor->get_property_editor()->get_selected_path();
+ String p = editor->get_inspector()->get_selected_path();
if (p.begins_with("/MeshLibrary/item") && p.get_slice_count("/") >= 3) {
to_erase = p.get_slice("/", 3).to_int();
diff --git a/editor/plugins/item_list_editor_plugin.cpp b/editor/plugins/item_list_editor_plugin.cpp
index 8b44f672b0..f75fb0d109 100644
--- a/editor/plugins/item_list_editor_plugin.cpp
+++ b/editor/plugins/item_list_editor_plugin.cpp
@@ -388,7 +388,7 @@ ItemListEditor::ItemListEditor() {
vbc->add_child(property_editor);
property_editor->set_v_size_flags(SIZE_EXPAND_FILL);
- tree = property_editor->get_scene_tree();
+ tree = property_editor->get_property_tree();
}
ItemListEditor::~ItemListEditor() {
diff --git a/editor/project_settings_editor.cpp b/editor/project_settings_editor.cpp
index a4265b4e32..82fd727620 100644
--- a/editor/project_settings_editor.cpp
+++ b/editor/project_settings_editor.cpp
@@ -785,7 +785,7 @@ void ProjectSettingsEditor::popup_project_settings() {
void ProjectSettingsEditor::_item_selected() {
- TreeItem *ti = globals_editor->get_property_editor()->get_scene_tree()->get_selected();
+ TreeItem *ti = globals_editor->get_property_editor()->get_property_tree()->get_selected();
if (!ti)
return;
if (!ti->get_parent())
@@ -1727,7 +1727,7 @@ ProjectSettingsEditor::ProjectSettingsEditor(EditorData *p_data) {
//globals_editor->hide_top_label();
globals_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL);
globals_editor->register_search_box(search_box);
- globals_editor->get_property_editor()->get_scene_tree()->connect("cell_selected", this, "_item_selected");
+ globals_editor->get_property_editor()->get_property_tree()->connect("cell_selected", this, "_item_selected");
globals_editor->get_property_editor()->connect("property_toggled", this, "_item_checked", varray(), CONNECT_DEFERRED);
globals_editor->get_property_editor()->connect("property_edited", this, "_settings_prop_edited");
diff --git a/editor/property_editor.cpp b/editor/property_editor.cpp
index e0063925b1..e912ebe03a 100644
--- a/editor/property_editor.cpp
+++ b/editor/property_editor.cpp
@@ -4212,7 +4212,7 @@ void PropertyEditor::_bind_methods() {
ADD_SIGNAL(MethodInfo("property_edited", PropertyInfo(Variant::STRING, "property")));
}
-Tree *PropertyEditor::get_scene_tree() {
+Tree *PropertyEditor::get_property_tree() {
return tree;
}
@@ -4695,7 +4695,7 @@ SectionedPropertyEditor::SectionedPropertyEditor() {
editor->set_v_size_flags(SIZE_EXPAND_FILL);
right_vb->add_child(editor, true);
- editor->get_scene_tree()->set_column_titles_visible(false);
+ editor->get_property_tree()->set_column_titles_visible(false);
editor->hide_top_label();
diff --git a/editor/property_editor.h b/editor/property_editor.h
index 017a190adb..56743822d2 100644
--- a/editor/property_editor.h
+++ b/editor/property_editor.h
@@ -275,7 +275,7 @@ public:
String get_selected_path() const;
- Tree *get_scene_tree();
+ Tree *get_property_tree();
Label *get_top_label();
void hide_top_label();
void update_tree();
@@ -309,6 +309,7 @@ public:
void collapse_all_folding();
void expand_all_folding();
+
PropertyEditor();
~PropertyEditor();
};
diff --git a/editor/scene_tree_dock.cpp b/editor/scene_tree_dock.cpp
index 8b99a3d503..f5cee4cd65 100644
--- a/editor/scene_tree_dock.cpp
+++ b/editor/scene_tree_dock.cpp
@@ -732,7 +732,7 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
if (node) {
node->set_scene_inherited_state(Ref<SceneState>());
scene_tree->update_tree();
- EditorNode::get_singleton()->get_property_editor()->update_tree();
+ EditorNode::get_singleton()->get_inspector()->update_tree();
}
}
} break;
diff --git a/editor/scene_tree_editor.cpp b/editor/scene_tree_editor.cpp
index 64d278c0c5..dd79ae63d6 100644
--- a/editor/scene_tree_editor.cpp
+++ b/editor/scene_tree_editor.cpp
@@ -70,8 +70,18 @@ void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_i
} else if (p_id == BUTTON_VISIBILITY) {
undo_redo->create_action(TTR("Toggle Visible"));
- undo_redo->add_do_method(this, "toggle_visible", n);
- undo_redo->add_undo_method(this, "toggle_visible", n);
+ _toggle_visible(n);
+ List<Node *> selection = editor_selection->get_selected_node_list();
+ if (selection.size() > 1) {
+ for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
+ Node *nv = E->get();
+ ERR_FAIL_COND(!nv);
+ if (nv == n) {
+ continue;
+ }
+ _toggle_visible(nv);
+ }
+ }
undo_redo->commit_action();
} else if (p_id == BUTTON_LOCK) {
@@ -118,33 +128,13 @@ void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_i
}
}
void SceneTreeEditor::_toggle_visible(Node *p_node) {
- if (p_node->is_class("Spatial")) {
- bool v = bool(p_node->call("is_visible"));
- p_node->call("set_visible", !v);
- } else if (p_node->is_class("CanvasItem")) {
+ if (p_node->has_method("is_visible") && p_node->has_method("set_visible")) {
bool v = bool(p_node->call("is_visible"));
- if (v) {
- p_node->call("hide");
- } else {
- p_node->call("show");
- }
+ undo_redo->add_do_method(p_node, "set_visible", !v);
+ undo_redo->add_undo_method(p_node, "set_visible", v);
}
}
-void SceneTreeEditor::toggle_visible(Node *p_node) {
- _toggle_visible(p_node);
- List<Node *> selection = editor_selection->get_selected_node_list();
- if (selection.size() > 1) {
- for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
- Node *nv = E->get();
- ERR_FAIL_COND(!nv);
- if (nv == p_node) {
- continue;
- }
- _toggle_visible(nv);
- }
- }
-}
bool SceneTreeEditor::_add_nodes(Node *p_node, TreeItem *p_parent) {
if (!p_node)
@@ -968,8 +958,6 @@ void SceneTreeEditor::_bind_methods() {
ClassDB::bind_method("_cell_collapsed", &SceneTreeEditor::_cell_collapsed);
ClassDB::bind_method("_rmb_select", &SceneTreeEditor::_rmb_select);
ClassDB::bind_method("_warning_changed", &SceneTreeEditor::_warning_changed);
- ClassDB::bind_method("_toggle_visible", &SceneTreeEditor::_toggle_visible);
- ClassDB::bind_method("toggle_visible", &SceneTreeEditor::toggle_visible);
ClassDB::bind_method("_node_script_changed", &SceneTreeEditor::_node_script_changed);
ClassDB::bind_method("_node_visibility_changed", &SceneTreeEditor::_node_visibility_changed);
diff --git a/editor/scene_tree_editor.h b/editor/scene_tree_editor.h
index b63eb2a1f0..896fd6c431 100644
--- a/editor/scene_tree_editor.h
+++ b/editor/scene_tree_editor.h
@@ -70,8 +70,6 @@ class SceneTreeEditor : public Control {
void _compute_hash(Node *p_node, uint64_t &hash);
- void toggle_visible(Node *p_node);
-
bool _add_nodes(Node *p_node, TreeItem *p_parent);
void _test_update_tree();
void _update_tree();
diff --git a/editor/script_editor_debugger.cpp b/editor/script_editor_debugger.cpp
index a83de1627d..9ce4305683 100644
--- a/editor/script_editor_debugger.cpp
+++ b/editor/script_editor_debugger.cpp
@@ -1851,7 +1851,7 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) {
ppeer = Ref<PacketPeerStream>(memnew(PacketPeerStream));
ppeer->set_input_buffer_max_size(1024 * 1024 * 8); //8mb should be enough
editor = p_editor;
- editor->get_property_editor()->connect("object_id_selected", this, "_scene_tree_property_select_object");
+ editor->get_inspector()->connect("object_id_selected", this, "_scene_tree_property_select_object");
tabs = memnew(TabContainer);
tabs->set_tab_align(TabContainer::ALIGN_LEFT);
@@ -1936,7 +1936,7 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) {
inspector = memnew(PropertyEditor);
inspector->set_h_size_flags(SIZE_EXPAND_FILL);
inspector->hide_top_label();
- inspector->get_scene_tree()->set_column_title(0, TTR("Variable"));
+ inspector->get_property_tree()->set_column_title(0, TTR("Variable"));
inspector->set_enable_capitalize_paths(false);
inspector->set_read_only(true);
inspector->connect("object_id_selected", this, "_scene_tree_property_select_object");
diff --git a/main/main.cpp b/main/main.cpp
index 92b4e31679..c287bc81cb 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -82,6 +82,8 @@
#include "version.h"
#include "version_hash.gen.h"
+#include "main/timer_sync.h"
+
static ProjectSettings *globals = NULL;
static Engine *engine = NULL;
static InputMap *input_map = NULL;
@@ -1221,227 +1223,8 @@ Error Main::setup2(Thread::ID p_main_tid_override) {
}
// everything the main loop needs to know about frame timings
-struct _FrameTime {
- float animation_step; // time to advance animations for (argument to process())
- int physics_steps; // number of times to iterate the physics engine
-
- void clamp_animation(float min_animation_step, float max_animation_step) {
- if (animation_step < min_animation_step) {
- animation_step = min_animation_step;
- } else if (animation_step > max_animation_step) {
- animation_step = max_animation_step;
- }
- }
-};
-
-class _TimerSync {
- // wall clock time measured on the main thread
- uint64_t last_cpu_ticks_usec;
- uint64_t current_cpu_ticks_usec;
-
- // logical game time since last physics timestep
- float time_accum;
-
- // current difference between wall clock time and reported sum of animation_steps
- float time_deficit;
-
- // number of frames back for keeping accumulated physics steps roughly constant.
- // value of 12 chosen because that is what is required to make 144 Hz monitors
- // behave well with 60 Hz physics updates. The only worse commonly available refresh
- // would be 85, requiring CONTROL_STEPS = 17.
- static const int CONTROL_STEPS = 12;
-
- // sum of physics steps done over the last (i+1) frames
- int accumulated_physics_steps[CONTROL_STEPS];
-
- // typical value for accumulated_physics_steps[i] is either this or this plus one
- int typical_physics_steps[CONTROL_STEPS];
-
-protected:
- // returns the fraction of p_frame_slice required for the timer to overshoot
- // before advance_core considers changing the physics_steps return from
- // the typical values as defined by typical_physics_steps
- float get_physics_jitter_fix() {
- return Engine::get_singleton()->get_physics_jitter_fix();
- }
-
- // gets our best bet for the average number of physics steps per render frame
- // return value: number of frames back this data is consistent
- int get_average_physics_steps(float &p_min, float &p_max) {
- p_min = typical_physics_steps[0];
- p_max = p_min + 1;
-
- for (int i = 1; i < CONTROL_STEPS; ++i) {
- const float typical_lower = typical_physics_steps[i];
- const float current_min = typical_lower / (i + 1);
- if (current_min > p_max)
- return i; // bail out of further restrictions would void the interval
- else if (current_min > p_min)
- p_min = current_min;
- const float current_max = (typical_lower + 1) / (i + 1);
- if (current_max < p_min)
- return i;
- else if (current_max < p_max)
- p_max = current_max;
- }
-
- return CONTROL_STEPS;
- }
-
- // advance physics clock by p_animation_step, return appropriate number of steps to simulate
- _FrameTime advance_core(float p_frame_slice, int p_iterations_per_second, float p_animation_step) {
- _FrameTime ret;
-
- ret.animation_step = p_animation_step;
-
- // simple determination of number of physics iteration
- time_accum += ret.animation_step;
- ret.physics_steps = floor(time_accum * p_iterations_per_second);
-
- int min_typical_steps = typical_physics_steps[0];
- int max_typical_steps = min_typical_steps + 1;
-
- // given the past recorded steps and typcial steps to match, calculate bounds for this
- // step to be typical
- bool update_typical = false;
-
- for (int i = 0; i < CONTROL_STEPS - 1; ++i) {
- int steps_left_to_match_typical = typical_physics_steps[i + 1] - accumulated_physics_steps[i];
- if (steps_left_to_match_typical > max_typical_steps ||
- steps_left_to_match_typical + 1 < min_typical_steps) {
- update_typical = true;
- break;
- }
-
- if (steps_left_to_match_typical > min_typical_steps)
- min_typical_steps = steps_left_to_match_typical;
- if (steps_left_to_match_typical + 1 < max_typical_steps)
- max_typical_steps = steps_left_to_match_typical + 1;
- }
-
- // try to keep it consistent with previous iterations
- if (ret.physics_steps < min_typical_steps) {
- const int max_possible_steps = floor((time_accum)*p_iterations_per_second + get_physics_jitter_fix());
- if (max_possible_steps < min_typical_steps) {
- ret.physics_steps = max_possible_steps;
- update_typical = true;
- } else {
- ret.physics_steps = min_typical_steps;
- }
- } else if (ret.physics_steps > max_typical_steps) {
- const int min_possible_steps = floor((time_accum)*p_iterations_per_second - get_physics_jitter_fix());
- if (min_possible_steps > max_typical_steps) {
- ret.physics_steps = min_possible_steps;
- update_typical = true;
- } else {
- ret.physics_steps = max_typical_steps;
- }
- }
-
- time_accum -= ret.physics_steps * p_frame_slice;
-
- // keep track of accumulated step counts
- for (int i = CONTROL_STEPS - 2; i >= 0; --i) {
- accumulated_physics_steps[i + 1] = accumulated_physics_steps[i] + ret.physics_steps;
- }
- accumulated_physics_steps[0] = ret.physics_steps;
-
- if (update_typical) {
- for (int i = CONTROL_STEPS - 1; i >= 0; --i) {
- if (typical_physics_steps[i] > accumulated_physics_steps[i]) {
- typical_physics_steps[i] = accumulated_physics_steps[i];
- } else if (typical_physics_steps[i] < accumulated_physics_steps[i] - 1) {
- typical_physics_steps[i] = accumulated_physics_steps[i] - 1;
- }
- }
- }
-
- return ret;
- }
-
- // calls advance_core, keeps track of deficit it adds to animaption_step, make sure the deficit sum stays close to zero
- _FrameTime advance_checked(float p_frame_slice, int p_iterations_per_second, float p_animation_step) {
- if (fixed_fps != -1)
- p_animation_step = 1.0 / fixed_fps;
-
- // compensate for last deficit
- p_animation_step += time_deficit;
-
- _FrameTime ret = advance_core(p_frame_slice, p_iterations_per_second, p_animation_step);
-
- // we will do some clamping on ret.animation_step and need to sync those changes to time_accum,
- // that's easiest if we just remember their fixed difference now
- const double animation_minus_accum = ret.animation_step - time_accum;
-
- // first, least important clamping: keep ret.animation_step consistent with typical_physics_steps.
- // this smoothes out the animation steps and culls small but quick variations.
- {
- float min_average_physics_steps, max_average_physics_steps;
- int consistent_steps = get_average_physics_steps(min_average_physics_steps, max_average_physics_steps);
- if (consistent_steps > 3) {
- ret.clamp_animation(min_average_physics_steps * p_frame_slice, max_average_physics_steps * p_frame_slice);
- }
- }
-
- // second clamping: keep abs(time_deficit) < jitter_fix * frame_slise
- float max_clock_deviation = get_physics_jitter_fix() * p_frame_slice;
- ret.clamp_animation(p_animation_step - max_clock_deviation, p_animation_step + max_clock_deviation);
-
- // last clamping: make sure time_accum is between 0 and p_frame_slice for consistency between physics and animation
- ret.clamp_animation(animation_minus_accum, animation_minus_accum + p_frame_slice);
-
- // restore time_accum
- time_accum = ret.animation_step - animation_minus_accum;
-
- // track deficit
- time_deficit = p_animation_step - ret.animation_step;
-
- return ret;
- }
-
- // determine wall clock step since last iteration
- float get_cpu_animation_step() {
- uint64_t cpu_ticks_elapsed = current_cpu_ticks_usec - last_cpu_ticks_usec;
- last_cpu_ticks_usec = current_cpu_ticks_usec;
-
- return cpu_ticks_elapsed / 1000000.0;
- }
-
-public:
- explicit _TimerSync() :
- last_cpu_ticks_usec(0),
- current_cpu_ticks_usec(0),
- time_accum(0),
- time_deficit(0) {
- for (int i = CONTROL_STEPS - 1; i >= 0; --i) {
- typical_physics_steps[i] = i;
- accumulated_physics_steps[i] = i;
- }
- }
-
- // start the clock
- void init(uint64_t p_cpu_ticks_usec) {
- current_cpu_ticks_usec = last_cpu_ticks_usec = p_cpu_ticks_usec;
- }
-
- // set measured wall clock time
- void set_cpu_ticks_usec(uint64_t p_cpu_ticks_usec) {
- current_cpu_ticks_usec = p_cpu_ticks_usec;
- }
-
- // advance one frame, return timesteps to take
- _FrameTime advance(float p_frame_slice, int p_iterations_per_second) {
- float cpu_animation_step = get_cpu_animation_step();
-
- return advance_checked(p_frame_slice, p_iterations_per_second, cpu_animation_step);
- }
-
- void before_start_render() {
- VisualServer::get_singleton()->sync();
- }
-};
-static _TimerSync _timer_sync;
+static MainTimerSync main_timer_sync;
bool Main::start() {
@@ -1457,7 +1240,7 @@ bool Main::start() {
String _export_preset;
bool export_debug = false;
- _timer_sync.init(OS::get_singleton()->get_ticks_usec());
+ main_timer_sync.init(OS::get_singleton()->get_ticks_usec());
List<String> args = OS::get_singleton()->get_cmdline_args();
for (int i = 0; i < args.size(); i++) {
@@ -1958,15 +1741,16 @@ bool Main::iteration() {
uint64_t ticks = OS::get_singleton()->get_ticks_usec();
Engine::get_singleton()->_frame_ticks = ticks;
- _timer_sync.set_cpu_ticks_usec(ticks);
+ main_timer_sync.set_cpu_ticks_usec(ticks);
+ main_timer_sync.set_fixed_fps(fixed_fps);
uint64_t ticks_elapsed = ticks - last_ticks;
int physics_fps = Engine::get_singleton()->get_iterations_per_second();
float frame_slice = 1.0 / physics_fps;
- _FrameTime advance = _timer_sync.advance(frame_slice, physics_fps);
- double step = advance.animation_step;
+ MainFrameTime advance = main_timer_sync.advance(frame_slice, physics_fps);
+ double step = advance.idle_step;
Engine::get_singleton()->_frame_step = step;
@@ -2030,7 +1814,7 @@ bool Main::iteration() {
OS::get_singleton()->get_main_loop()->idle(step * time_scale);
message_queue->flush();
- _timer_sync.before_start_render(); //sync if still drawing from previous frames.
+ VisualServer::get_singleton()->sync(); //sync if still drawing from previous frames.
if (OS::get_singleton()->can_draw() && !disable_render_loop) {
diff --git a/main/timer_sync.cpp b/main/timer_sync.cpp
new file mode 100644
index 0000000000..c33cbafee8
--- /dev/null
+++ b/main/timer_sync.cpp
@@ -0,0 +1,193 @@
+#include "timer_sync.h"
+
+void MainFrameTime::clamp_idle(float min_idle_step, float max_idle_step) {
+ if (idle_step < min_idle_step) {
+ idle_step = min_idle_step;
+ } else if (idle_step > max_idle_step) {
+ idle_step = max_idle_step;
+ }
+}
+
+/////////////////////////////////
+
+// returns the fraction of p_frame_slice required for the timer to overshoot
+// before advance_core considers changing the physics_steps return from
+// the typical values as defined by typical_physics_steps
+float MainTimerSync::get_physics_jitter_fix() {
+ return Engine::get_singleton()->get_physics_jitter_fix();
+}
+
+// gets our best bet for the average number of physics steps per render frame
+// return value: number of frames back this data is consistent
+int MainTimerSync::get_average_physics_steps(float &p_min, float &p_max) {
+ p_min = typical_physics_steps[0];
+ p_max = p_min + 1;
+
+ for (int i = 1; i < CONTROL_STEPS; ++i) {
+ const float typical_lower = typical_physics_steps[i];
+ const float current_min = typical_lower / (i + 1);
+ if (current_min > p_max)
+ return i; // bail out of further restrictions would void the interval
+ else if (current_min > p_min)
+ p_min = current_min;
+ const float current_max = (typical_lower + 1) / (i + 1);
+ if (current_max < p_min)
+ return i;
+ else if (current_max < p_max)
+ p_max = current_max;
+ }
+
+ return CONTROL_STEPS;
+}
+
+// advance physics clock by p_idle_step, return appropriate number of steps to simulate
+MainFrameTime MainTimerSync::advance_core(float p_frame_slice, int p_iterations_per_second, float p_idle_step) {
+ MainFrameTime ret;
+
+ ret.idle_step = p_idle_step;
+
+ // simple determination of number of physics iteration
+ time_accum += ret.idle_step;
+ ret.physics_steps = floor(time_accum * p_iterations_per_second);
+
+ int min_typical_steps = typical_physics_steps[0];
+ int max_typical_steps = min_typical_steps + 1;
+
+ // given the past recorded steps and typcial steps to match, calculate bounds for this
+ // step to be typical
+ bool update_typical = false;
+
+ for (int i = 0; i < CONTROL_STEPS - 1; ++i) {
+ int steps_left_to_match_typical = typical_physics_steps[i + 1] - accumulated_physics_steps[i];
+ if (steps_left_to_match_typical > max_typical_steps ||
+ steps_left_to_match_typical + 1 < min_typical_steps) {
+ update_typical = true;
+ break;
+ }
+
+ if (steps_left_to_match_typical > min_typical_steps)
+ min_typical_steps = steps_left_to_match_typical;
+ if (steps_left_to_match_typical + 1 < max_typical_steps)
+ max_typical_steps = steps_left_to_match_typical + 1;
+ }
+
+ // try to keep it consistent with previous iterations
+ if (ret.physics_steps < min_typical_steps) {
+ const int max_possible_steps = floor((time_accum)*p_iterations_per_second + get_physics_jitter_fix());
+ if (max_possible_steps < min_typical_steps) {
+ ret.physics_steps = max_possible_steps;
+ update_typical = true;
+ } else {
+ ret.physics_steps = min_typical_steps;
+ }
+ } else if (ret.physics_steps > max_typical_steps) {
+ const int min_possible_steps = floor((time_accum)*p_iterations_per_second - get_physics_jitter_fix());
+ if (min_possible_steps > max_typical_steps) {
+ ret.physics_steps = min_possible_steps;
+ update_typical = true;
+ } else {
+ ret.physics_steps = max_typical_steps;
+ }
+ }
+
+ time_accum -= ret.physics_steps * p_frame_slice;
+
+ // keep track of accumulated step counts
+ for (int i = CONTROL_STEPS - 2; i >= 0; --i) {
+ accumulated_physics_steps[i + 1] = accumulated_physics_steps[i] + ret.physics_steps;
+ }
+ accumulated_physics_steps[0] = ret.physics_steps;
+
+ if (update_typical) {
+ for (int i = CONTROL_STEPS - 1; i >= 0; --i) {
+ if (typical_physics_steps[i] > accumulated_physics_steps[i]) {
+ typical_physics_steps[i] = accumulated_physics_steps[i];
+ } else if (typical_physics_steps[i] < accumulated_physics_steps[i] - 1) {
+ typical_physics_steps[i] = accumulated_physics_steps[i] - 1;
+ }
+ }
+ }
+
+ return ret;
+}
+
+// calls advance_core, keeps track of deficit it adds to animaption_step, make sure the deficit sum stays close to zero
+MainFrameTime MainTimerSync::advance_checked(float p_frame_slice, int p_iterations_per_second, float p_idle_step) {
+ if (fixed_fps != -1)
+ p_idle_step = 1.0 / fixed_fps;
+
+ // compensate for last deficit
+ p_idle_step += time_deficit;
+
+ MainFrameTime ret = advance_core(p_frame_slice, p_iterations_per_second, p_idle_step);
+
+ // we will do some clamping on ret.idle_step and need to sync those changes to time_accum,
+ // that's easiest if we just remember their fixed difference now
+ const double idle_minus_accum = ret.idle_step - time_accum;
+
+ // first, least important clamping: keep ret.idle_step consistent with typical_physics_steps.
+ // this smoothes out the idle steps and culls small but quick variations.
+ {
+ float min_average_physics_steps, max_average_physics_steps;
+ int consistent_steps = get_average_physics_steps(min_average_physics_steps, max_average_physics_steps);
+ if (consistent_steps > 3) {
+ ret.clamp_idle(min_average_physics_steps * p_frame_slice, max_average_physics_steps * p_frame_slice);
+ }
+ }
+
+ // second clamping: keep abs(time_deficit) < jitter_fix * frame_slise
+ float max_clock_deviation = get_physics_jitter_fix() * p_frame_slice;
+ ret.clamp_idle(p_idle_step - max_clock_deviation, p_idle_step + max_clock_deviation);
+
+ // last clamping: make sure time_accum is between 0 and p_frame_slice for consistency between physics and idle
+ ret.clamp_idle(idle_minus_accum, idle_minus_accum + p_frame_slice);
+
+ // restore time_accum
+ time_accum = ret.idle_step - idle_minus_accum;
+
+ // track deficit
+ time_deficit = p_idle_step - ret.idle_step;
+
+ return ret;
+}
+
+// determine wall clock step since last iteration
+float MainTimerSync::get_cpu_idle_step() {
+ uint64_t cpu_ticks_elapsed = current_cpu_ticks_usec - last_cpu_ticks_usec;
+ last_cpu_ticks_usec = current_cpu_ticks_usec;
+
+ return cpu_ticks_elapsed / 1000000.0;
+}
+
+MainTimerSync::MainTimerSync() :
+ last_cpu_ticks_usec(0),
+ current_cpu_ticks_usec(0),
+ time_accum(0),
+ time_deficit(0),
+ fixed_fps(0) {
+ for (int i = CONTROL_STEPS - 1; i >= 0; --i) {
+ typical_physics_steps[i] = i;
+ accumulated_physics_steps[i] = i;
+ }
+}
+
+// start the clock
+void MainTimerSync::init(uint64_t p_cpu_ticks_usec) {
+ current_cpu_ticks_usec = last_cpu_ticks_usec = p_cpu_ticks_usec;
+}
+
+// set measured wall clock time
+void MainTimerSync::set_cpu_ticks_usec(uint64_t p_cpu_ticks_usec) {
+ current_cpu_ticks_usec = p_cpu_ticks_usec;
+}
+
+void MainTimerSync::set_fixed_fps(int p_fixed_fps) {
+ fixed_fps = p_fixed_fps;
+}
+
+// advance one frame, return timesteps to take
+MainFrameTime MainTimerSync::advance(float p_frame_slice, int p_iterations_per_second) {
+ float cpu_idle_step = get_cpu_idle_step();
+
+ return advance_checked(p_frame_slice, p_iterations_per_second, cpu_idle_step);
+}
diff --git a/main/timer_sync.h b/main/timer_sync.h
new file mode 100644
index 0000000000..6ef4254270
--- /dev/null
+++ b/main/timer_sync.h
@@ -0,0 +1,71 @@
+#ifndef TIMER_SYNC_H
+#define TIMER_SYNC_H
+
+#include "core/engine.h"
+
+struct MainFrameTime {
+ float idle_step; // time to advance idles for (argument to process())
+ int physics_steps; // number of times to iterate the physics engine
+
+ void clamp_idle(float min_idle_step, float max_idle_step);
+};
+
+class MainTimerSync {
+ // wall clock time measured on the main thread
+ uint64_t last_cpu_ticks_usec;
+ uint64_t current_cpu_ticks_usec;
+
+ // logical game time since last physics timestep
+ float time_accum;
+
+ // current difference between wall clock time and reported sum of idle_steps
+ float time_deficit;
+
+ // number of frames back for keeping accumulated physics steps roughly constant.
+ // value of 12 chosen because that is what is required to make 144 Hz monitors
+ // behave well with 60 Hz physics updates. The only worse commonly available refresh
+ // would be 85, requiring CONTROL_STEPS = 17.
+ static const int CONTROL_STEPS = 12;
+
+ // sum of physics steps done over the last (i+1) frames
+ int accumulated_physics_steps[CONTROL_STEPS];
+
+ // typical value for accumulated_physics_steps[i] is either this or this plus one
+ int typical_physics_steps[CONTROL_STEPS];
+
+ int fixed_fps;
+
+protected:
+ // returns the fraction of p_frame_slice required for the timer to overshoot
+ // before advance_core considers changing the physics_steps return from
+ // the typical values as defined by typical_physics_steps
+ float get_physics_jitter_fix();
+
+ // gets our best bet for the average number of physics steps per render frame
+ // return value: number of frames back this data is consistent
+ int get_average_physics_steps(float &p_min, float &p_max);
+
+ // advance physics clock by p_idle_step, return appropriate number of steps to simulate
+ MainFrameTime advance_core(float p_frame_slice, int p_iterations_per_second, float p_idle_step);
+
+ // calls advance_core, keeps track of deficit it adds to animaption_step, make sure the deficit sum stays close to zero
+ MainFrameTime advance_checked(float p_frame_slice, int p_iterations_per_second, float p_idle_step);
+
+ // determine wall clock step since last iteration
+ float get_cpu_idle_step();
+
+public:
+ MainTimerSync();
+
+ // start the clock
+ void init(uint64_t p_cpu_ticks_usec);
+ // set measured wall clock time
+ void set_cpu_ticks_usec(uint64_t p_cpu_ticks_usec);
+ //set fixed fps
+ void set_fixed_fps(int p_fixed_fps);
+
+ // advance one frame, return timesteps to take
+ MainFrameTime advance(float p_frame_slice, int p_iterations_per_second);
+};
+
+#endif // TIMER_SYNC_H
diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index bbe245951e..161e62c81f 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -782,7 +782,7 @@ void CSharpLanguage::reload_assemblies_if_needed(bool p_soft_reload) {
}
if (Engine::get_singleton()->is_editor_hint()) {
- EditorNode::get_singleton()->get_property_editor()->update_tree();
+ EditorNode::get_singleton()->get_inspector()->update_tree();
NodeDock::singleton->update_lists();
}
}
diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp
index eb10c5e99f..dfaa873b13 100644
--- a/modules/visual_script/visual_script_editor.cpp
+++ b/modules/visual_script/visual_script_editor.cpp
@@ -268,7 +268,7 @@ protected:
if (String(p_name) == "export") {
script->set_variable_export(var, p_value);
- EditorNode::get_singleton()->get_property_editor()->update_tree();
+ EditorNode::get_singleton()->get_inspector()->update_tree();
return true;
}
diff --git a/platform/server/os_server.cpp b/platform/server/os_server.cpp
index a8be4fbc35..3b1be780d4 100644
--- a/platform/server/os_server.cpp
+++ b/platform/server/os_server.cpp
@@ -30,6 +30,7 @@
#include "os_server.h"
#include "drivers/dummy/audio_driver_dummy.h"
#include "drivers/dummy/rasterizer_dummy.h"
+#include "drivers/dummy/texture_loader_dummy.h"
#include "print_string.h"
#include "servers/visual/visual_server_raster.h"
#include <stdio.h>
@@ -83,6 +84,9 @@ Error OS_Server::initialize(const VideoMode &p_desired, int p_video_driver, int
_ensure_user_data_dir();
+ resource_loader_dummy = memnew(ResourceFormatDummyTexture);
+ ResourceLoader::add_resource_format_loader(resource_loader_dummy);
+
return OK;
}
@@ -99,6 +103,8 @@ void OS_Server::finalize() {
memdelete(power_manager);
+ memdelete(resource_loader_dummy);
+
args.clear();
}
diff --git a/platform/server/os_server.h b/platform/server/os_server.h
index 2cc6f0c47e..f1a880ecc2 100644
--- a/platform/server/os_server.h
+++ b/platform/server/os_server.h
@@ -32,6 +32,7 @@
#include "../x11/crash_handler_x11.h"
#include "../x11/power_x11.h"
+#include "drivers/dummy/texture_loader_dummy.h"
#include "drivers/rtaudio/audio_driver_rtaudio.h"
#include "drivers/unix/os_unix.h"
#include "main/input_default.h"
@@ -65,6 +66,8 @@ class OS_Server : public OS_Unix {
CrashHandler crash_handler;
+ ResourceFormatDummyTexture *resource_loader_dummy;
+
protected:
virtual int get_video_driver_count() const;
virtual const char *get_video_driver_name(int p_driver) const;
diff --git a/scene/2d/audio_stream_player_2d.cpp b/scene/2d/audio_stream_player_2d.cpp
index f998f23d3b..3878559b60 100644
--- a/scene/2d/audio_stream_player_2d.cpp
+++ b/scene/2d/audio_stream_player_2d.cpp
@@ -462,7 +462,7 @@ void AudioStreamPlayer2D::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "playing", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "_set_playing", "is_playing");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "autoplay"), "set_autoplay", "is_autoplay_enabled");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "max_distance", PROPERTY_HINT_RANGE, "1,65536,1"), "set_max_distance", "get_max_distance");
- ADD_PROPERTY(PropertyInfo(Variant::REAL, "attenuation", PROPERTY_HINT_EXP_EASING), "set_attenuation", "get_attenuation");
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "attenuation", PROPERTY_HINT_EXP_EASING, "attenuation"), "set_attenuation", "get_attenuation");
ADD_PROPERTY(PropertyInfo(Variant::STRING, "bus", PROPERTY_HINT_ENUM, ""), "set_bus", "get_bus");
ADD_PROPERTY(PropertyInfo(Variant::INT, "area_mask", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_area_mask", "get_area_mask");
diff --git a/scene/3d/light.cpp b/scene/3d/light.cpp
index 240bd631a1..4d854ff578 100644
--- a/scene/3d/light.cpp
+++ b/scene/3d/light.cpp
@@ -375,7 +375,7 @@ void DirectionalLight::_bind_methods() {
ADD_PROPERTYI(PropertyInfo(Variant::REAL, "directional_shadow_normal_bias", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_param", "get_param", PARAM_SHADOW_NORMAL_BIAS);
ADD_PROPERTYI(PropertyInfo(Variant::REAL, "directional_shadow_bias_split_scale", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param", "get_param", PARAM_SHADOW_BIAS_SPLIT_SCALE);
ADD_PROPERTY(PropertyInfo(Variant::INT, "directional_shadow_depth_range", PROPERTY_HINT_ENUM, "Stable,Optimized"), "set_shadow_depth_range", "get_shadow_depth_range");
- ADD_PROPERTYI(PropertyInfo(Variant::REAL, "directional_shadow_max_distance", PROPERTY_HINT_RANGE, "0,65536,0.1"), "set_param", "get_param", PARAM_SHADOW_MAX_DISTANCE);
+ ADD_PROPERTYI(PropertyInfo(Variant::REAL, "directional_shadow_max_distance", PROPERTY_HINT_EXP_RANGE, "0,65536,0.1"), "set_param", "get_param", PARAM_SHADOW_MAX_DISTANCE);
BIND_ENUM_CONSTANT(SHADOW_ORTHOGONAL);
BIND_ENUM_CONSTANT(SHADOW_PARALLEL_2_SPLITS);
@@ -428,8 +428,8 @@ void OmniLight::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_shadow_detail"), &OmniLight::get_shadow_detail);
ADD_GROUP("Omni", "omni_");
- ADD_PROPERTYI(PropertyInfo(Variant::REAL, "omni_range", PROPERTY_HINT_RANGE, "0,65536,0.1"), "set_param", "get_param", PARAM_RANGE);
- ADD_PROPERTYI(PropertyInfo(Variant::REAL, "omni_attenuation", PROPERTY_HINT_EXP_EASING), "set_param", "get_param", PARAM_ATTENUATION);
+ ADD_PROPERTYI(PropertyInfo(Variant::REAL, "omni_range", PROPERTY_HINT_EXP_RANGE, "0,4096,0.1"), "set_param", "get_param", PARAM_RANGE);
+ ADD_PROPERTYI(PropertyInfo(Variant::REAL, "omni_attenuation", PROPERTY_HINT_EXP_EASING, "attenuation"), "set_param", "get_param", PARAM_ATTENUATION);
ADD_PROPERTY(PropertyInfo(Variant::INT, "omni_shadow_mode", PROPERTY_HINT_ENUM, "Dual Paraboloid,Cube"), "set_shadow_mode", "get_shadow_mode");
ADD_PROPERTY(PropertyInfo(Variant::INT, "omni_shadow_detail", PROPERTY_HINT_ENUM, "Vertical,Horizontal"), "set_shadow_detail", "get_shadow_detail");
@@ -450,8 +450,8 @@ OmniLight::OmniLight() :
void SpotLight::_bind_methods() {
ADD_GROUP("Spot", "spot_");
- ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_range", PROPERTY_HINT_RANGE, "0,65536,0.1"), "set_param", "get_param", PARAM_RANGE);
- ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_attenuation", PROPERTY_HINT_EXP_EASING), "set_param", "get_param", PARAM_ATTENUATION);
+ ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_range", PROPERTY_HINT_EXP_RANGE, "0,4096,0.1"), "set_param", "get_param", PARAM_RANGE);
+ ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_attenuation", PROPERTY_HINT_EXP_EASING, "attenuation"), "set_param", "get_param", PARAM_ATTENUATION);
ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_angle", PROPERTY_HINT_RANGE, "0,180,0.1"), "set_param", "get_param", PARAM_SPOT_ANGLE);
- ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_angle_attenuation", PROPERTY_HINT_EXP_EASING), "set_param", "get_param", PARAM_SPOT_ATTENUATION);
+ ADD_PROPERTYI(PropertyInfo(Variant::REAL, "spot_angle_attenuation", PROPERTY_HINT_EXP_EASING, "attenuation"), "set_param", "get_param", PARAM_SPOT_ATTENUATION);
}
diff --git a/scene/gui/color_picker.cpp b/scene/gui/color_picker.cpp
index 6f34f3e49f..1e0db6e8cd 100644
--- a/scene/gui/color_picker.cpp
+++ b/scene/gui/color_picker.cpp
@@ -656,8 +656,9 @@ ColorPicker::ColorPicker() :
void ColorPickerButton::_color_changed(const Color &p_color) {
+ color = p_color;
update();
- emit_signal("color_changed", p_color);
+ emit_signal("color_changed", color);
}
void ColorPickerButton::_modal_closed() {
@@ -667,6 +668,7 @@ void ColorPickerButton::_modal_closed() {
void ColorPickerButton::pressed() {
+ _update_picker();
popup->set_position(get_global_position() - picker->get_combined_minimum_size());
popup->popup();
picker->set_focus_on_line_edit();
@@ -679,7 +681,7 @@ void ColorPickerButton::_notification(int p_what) {
Ref<StyleBox> normal = get_stylebox("normal");
Rect2 r = Rect2(normal->get_offset(), get_size() - normal->get_minimum_size());
draw_texture_rect(Control::get_icon("bg", "ColorPickerButton"), r, true);
- draw_rect(r, picker->get_pick_color());
+ draw_rect(r, color);
}
if (p_what == MainLoop::NOTIFICATION_WM_QUIT_REQUEST) {
@@ -689,27 +691,34 @@ void ColorPickerButton::_notification(int p_what) {
void ColorPickerButton::set_pick_color(const Color &p_color) {
- picker->set_pick_color(p_color);
+ color = p_color;
+ if (picker) {
+ picker->set_pick_color(p_color);
+ }
+
update();
- emit_signal("color_changed", p_color);
}
Color ColorPickerButton::get_pick_color() const {
- return picker->get_pick_color();
+ return color;
}
void ColorPickerButton::set_edit_alpha(bool p_show) {
- picker->set_edit_alpha(p_show);
+ edit_alpha = p_show;
+ if (picker) {
+ picker->set_edit_alpha(p_show);
+ }
}
bool ColorPickerButton::is_editing_alpha() const {
- return picker->is_editing_alpha();
+ return edit_alpha;
}
-ColorPicker *ColorPickerButton::get_picker() const {
+ColorPicker *ColorPickerButton::get_picker() {
+ _update_picker();
return picker;
}
@@ -718,6 +727,19 @@ PopupPanel *ColorPickerButton::get_popup() const {
return popup;
}
+void ColorPickerButton::_update_picker() {
+ if (!picker) {
+ popup = memnew(PopupPanel);
+ picker = memnew(ColorPicker);
+ popup->add_child(picker);
+ add_child(popup);
+ picker->connect("color_changed", this, "_color_changed");
+ popup->connect("modal_closed", this, "_modal_closed");
+ picker->set_pick_color(color);
+ picker->set_edit_alpha(edit_alpha);
+ }
+}
+
void ColorPickerButton::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_pick_color", "color"), &ColorPickerButton::set_pick_color);
@@ -737,12 +759,7 @@ void ColorPickerButton::_bind_methods() {
ColorPickerButton::ColorPickerButton() {
- popup = memnew(PopupPanel);
- picker = memnew(ColorPicker);
- popup->add_child(picker);
-
- picker->connect("color_changed", this, "_color_changed");
- popup->connect("modal_closed", this, "_modal_closed");
-
- add_child(popup);
+ picker = NULL;
+ popup = NULL;
+ edit_alpha = true;
}
diff --git a/scene/gui/color_picker.h b/scene/gui/color_picker.h
index 7d1a554ada..6b63e5fe60 100644
--- a/scene/gui/color_picker.h
+++ b/scene/gui/color_picker.h
@@ -118,12 +118,16 @@ class ColorPickerButton : public Button {
PopupPanel *popup;
ColorPicker *picker;
+ Color color;
+ bool edit_alpha;
void _color_changed(const Color &p_color);
void _modal_closed();
virtual void pressed();
+ void _update_picker();
+
protected:
void _notification(int);
static void _bind_methods();
@@ -135,7 +139,7 @@ public:
void set_edit_alpha(bool p_show);
bool is_editing_alpha() const;
- ColorPicker *get_picker() const;
+ ColorPicker *get_picker();
PopupPanel *get_popup() const;
ColorPickerButton();
diff --git a/scene/gui/container.cpp b/scene/gui/container.cpp
index 7cb0ad5707..177582c87c 100644
--- a/scene/gui/container.cpp
+++ b/scene/gui/container.cpp
@@ -34,9 +34,9 @@
void Container::_child_minsize_changed() {
- Size2 ms = get_combined_minimum_size();
- if (ms.width > get_size().width || ms.height > get_size().height)
- minimum_size_changed();
+ //Size2 ms = get_combined_minimum_size();
+ //if (ms.width > get_size().width || ms.height > get_size().height) {
+ minimum_size_changed();
queue_sort();
}
diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp
index b7c1d35fd7..3097ecaf16 100644
--- a/scene/gui/control.cpp
+++ b/scene/gui/control.cpp
@@ -155,12 +155,21 @@ Size2 Control::get_custom_minimum_size() const {
return data.custom_minimum_size;
}
-Size2 Control::get_combined_minimum_size() const {
+void Control::_update_minimum_size_cache() {
Size2 minsize = get_minimum_size();
minsize.x = MAX(minsize.x, data.custom_minimum_size.x);
minsize.y = MAX(minsize.y, data.custom_minimum_size.y);
- return minsize;
+ data.minimum_size_cache = minsize;
+ data.minimum_size_valid = true;
+}
+
+Size2 Control::get_combined_minimum_size() const {
+
+ if (!data.minimum_size_valid) {
+ const_cast<Control *>(this)->_update_minimum_size_cache();
+ }
+ return data.minimum_size_cache;
}
Size2 Control::_edit_get_minimum_size() const {
@@ -259,14 +268,17 @@ void Control::_update_minimum_size() {
if (!is_inside_tree())
return;
- data.pending_min_size_update = false;
Size2 minsize = get_combined_minimum_size();
if (minsize.x > data.size_cache.x ||
minsize.y > data.size_cache.y) {
_size_changed();
}
- emit_signal(SceneStringNames::get_singleton()->minimum_size_changed);
+ data.updating_last_minimum_size = false;
+
+ if (minsize != data.last_minimum_size) {
+ emit_signal(SceneStringNames::get_singleton()->minimum_size_changed);
+ }
}
bool Control::_get(const StringName &p_name, Variant &r_ret) const {
@@ -437,8 +449,12 @@ void Control::_notification(int p_notification) {
case NOTIFICATION_ENTER_TREE: {
- _size_changed();
-
+ } break;
+ case NOTIFICATION_POST_ENTER_TREE: {
+ if (is_visible_in_tree()) {
+ data.minimum_size_valid = false;
+ _size_changed();
+ }
} break;
case NOTIFICATION_EXIT_TREE: {
@@ -620,13 +636,12 @@ void Control::_notification(int p_notification) {
if (is_inside_tree()) {
_modal_stack_remove();
- minimum_size_changed();
}
//remove key focus
//remove modalness
} else {
-
+ data.minimum_size_valid = false;
_size_changed();
}
@@ -2464,17 +2479,25 @@ void Control::minimum_size_changed() {
if (!is_inside_tree() || data.block_minimum_size_adjust)
return;
- if (data.pending_min_size_update)
+ Control *invalidate = this;
+
+ //invalidate cache upwards
+ while (invalidate && invalidate->data.minimum_size_valid) {
+ invalidate->data.minimum_size_valid = false;
+ if (invalidate->is_set_as_toplevel())
+ break; // do not go further up
+ invalidate = invalidate->data.parent;
+ }
+
+ if (!is_visible_in_tree())
+ return;
+
+ if (data.updating_last_minimum_size)
return;
- data.pending_min_size_update = true;
- MessageQueue::get_singleton()->push_call(this, "_update_minimum_size");
+ data.updating_last_minimum_size = true;
- if (!is_toplevel_control()) {
- Control *pc = get_parent_control();
- if (pc)
- pc->minimum_size_changed();
- }
+ MessageQueue::get_singleton()->push_call(this, "_update_minimum_size");
}
int Control::get_v_size_flags() const {
@@ -2985,7 +3008,6 @@ Control::Control() {
data.h_size_flags = SIZE_FILL;
data.v_size_flags = SIZE_FILL;
data.expand = 1;
- data.pending_min_size_update = false;
data.rotation = 0;
data.parent_canvas_item = NULL;
data.scale = Vector2(1, 1);
@@ -2995,6 +3017,8 @@ Control::Control() {
data.disable_visibility_clip = false;
data.h_grow = GROW_DIRECTION_END;
data.v_grow = GROW_DIRECTION_END;
+ data.minimum_size_valid = false;
+ data.updating_last_minimum_size = false;
data.clip_contents = false;
for (int i = 0; i < 4; i++) {
diff --git a/scene/gui/control.h b/scene/gui/control.h
index b5453e60f5..9124256624 100644
--- a/scene/gui/control.h
+++ b/scene/gui/control.h
@@ -148,6 +148,11 @@ private:
Point2 pos_cache;
Size2 size_cache;
+ Size2 minimum_size_cache;
+ bool minimum_size_valid;
+
+ Size2 last_minimum_size;
+ bool updating_last_minimum_size;
float margin[4];
float anchor[4];
@@ -164,7 +169,6 @@ private:
int h_size_flags;
int v_size_flags;
float expand;
- bool pending_min_size_update;
Point2 custom_minimum_size;
bool pass_on_modal_close_click;
@@ -244,6 +248,8 @@ private:
void _modal_stack_remove();
void _modal_set_prev_focus_owner(ObjectID p_prev);
+ void _update_minimum_size_cache();
+
protected:
virtual void add_child_notify(Node *p_child);
virtual void remove_child_notify(Node *p_child);
diff --git a/scene/gui/range.cpp b/scene/gui/range.cpp
index cd6c6bb65c..caafda2c65 100644
--- a/scene/gui/range.cpp
+++ b/scene/gui/range.cpp
@@ -136,9 +136,9 @@ void Range::set_as_ratio(double p_value) {
double v;
- if (shared->exp_ratio && get_min() > 0) {
+ if (shared->exp_ratio && get_min() >= 0) {
- double exp_min = Math::log(get_min()) / Math::log((double)2);
+ double exp_min = get_min() == 0 ? 0.0 : Math::log(get_min()) / Math::log((double)2);
double exp_max = Math::log(get_max()) / Math::log((double)2);
v = Math::pow(2, exp_min + (exp_max - exp_min) * p_value);
} else {
@@ -155,9 +155,9 @@ void Range::set_as_ratio(double p_value) {
}
double Range::get_as_ratio() const {
- if (shared->exp_ratio && get_min() > 0) {
+ if (shared->exp_ratio && get_min() >= 0) {
- double exp_min = Math::log(get_min()) / Math::log((double)2);
+ double exp_min = get_min() == 0 ? 0.0 : Math::log(get_min()) / Math::log((double)2);
double exp_max = Math::log(get_max()) / Math::log((double)2);
double v = Math::log(get_value()) / Math::log((double)2);
diff --git a/scene/gui/scroll_container.cpp b/scene/gui/scroll_container.cpp
index a1dcf3b002..2dd5c64378 100644
--- a/scene/gui/scroll_container.cpp
+++ b/scene/gui/scroll_container.cpp
@@ -37,6 +37,7 @@ bool ScrollContainer::clips_input() const {
Size2 ScrollContainer::get_minimum_size() const {
+ Ref<StyleBox> sb = get_stylebox("bg");
Size2 min_size;
for (int i = 0; i < get_child_count(); i++) {
@@ -64,8 +65,9 @@ Size2 ScrollContainer::get_minimum_size() const {
if (v_scroll->is_visible_in_tree()) {
min_size.x += v_scroll->get_minimum_size().x;
}
+ min_size += sb->get_minimum_size();
return min_size;
-};
+}
void ScrollContainer::_cancel_drag() {
set_physics_process_internal(false);
@@ -233,6 +235,12 @@ void ScrollContainer::_notification(int p_what) {
child_max_size = Size2(0, 0);
Size2 size = get_size();
+ Point2 ofs;
+
+ Ref<StyleBox> sb = get_stylebox("bg");
+ size -= sb->get_minimum_size();
+ ofs += sb->get_offset();
+
if (h_scroll->is_visible_in_tree())
size.y -= h_scroll->get_minimum_size().y;
@@ -268,6 +276,7 @@ void ScrollContainer::_notification(int p_what) {
else
r.size.height = minsize.height;
}
+ r.position += ofs;
fit_child_in_rect(c, r);
}
update();
@@ -275,6 +284,9 @@ void ScrollContainer::_notification(int p_what) {
if (p_what == NOTIFICATION_DRAW) {
+ Ref<StyleBox> sb = get_stylebox("bg");
+ draw_style_box(sb, Rect2(Vector2(), get_size()));
+
update_scrollbars();
}
@@ -353,6 +365,8 @@ void ScrollContainer::_notification(int p_what) {
void ScrollContainer::update_scrollbars() {
Size2 size = get_size();
+ Ref<StyleBox> sb = get_stylebox("bg");
+ size -= sb->get_minimum_size();
Size2 hmin = h_scroll->get_combined_minimum_size();
Size2 vmin = v_scroll->get_combined_minimum_size();
diff --git a/scene/gui/text_edit.cpp b/scene/gui/text_edit.cpp
index b8e27bd322..553c2b7c39 100644
--- a/scene/gui/text_edit.cpp
+++ b/scene/gui/text_edit.cpp
@@ -117,7 +117,6 @@ void TextEdit::Text::set_indent_size(int p_indent_size) {
void TextEdit::Text::_update_line_cache(int p_line) const {
int w = 0;
- int tab_w = font->get_char_size(' ').width * indent_size;
int len = text[p_line].data.length();
const CharType *str = text[p_line].data.c_str();
@@ -125,22 +124,13 @@ void TextEdit::Text::_update_line_cache(int p_line) const {
//update width
for (int i = 0; i < len; i++) {
- if (str[i] == '\t') {
-
- int left = w % tab_w;
- if (left == 0)
- w += tab_w;
- else
- w += tab_w - w % tab_w; // is right...
-
- } else {
-
- w += font->get_char_size(str[i], str[i + 1]).width;
- }
+ w += get_char_width(str[i], str[i + 1], w);
}
text[p_line].width_cache = w;
+ text[p_line].wrap_amount_cache = -1;
+
//update regions
text[p_line].region_info.clear();
@@ -242,10 +232,32 @@ int TextEdit::Text::get_line_width(int p_line) const {
return text[p_line].width_cache;
}
-void TextEdit::Text::clear_caches() {
+void TextEdit::Text::set_line_wrap_amount(int p_line, int p_wrap_amount) const {
+
+ ERR_FAIL_INDEX(p_line, text.size());
+
+ text[p_line].wrap_amount_cache = p_wrap_amount;
+}
+
+int TextEdit::Text::get_line_wrap_amount(int p_line) const {
+
+ ERR_FAIL_INDEX_V(p_line, text.size(), -1);
+
+ return text[p_line].wrap_amount_cache;
+}
+
+void TextEdit::Text::clear_width_cache() {
- for (int i = 0; i < text.size(); i++)
+ for (int i = 0; i < text.size(); i++) {
text[i].width_cache = -1;
+ }
+}
+
+void TextEdit::Text::clear_wrap_cache() {
+
+ for (int i = 0; i < text.size(); i++) {
+ text[i].wrap_amount_cache = -1;
+ }
}
void TextEdit::Text::clear() {
@@ -270,6 +282,7 @@ void TextEdit::Text::set(int p_line, const String &p_text) {
ERR_FAIL_INDEX(p_line, text.size());
text[p_line].width_cache = -1;
+ text[p_line].wrap_amount_cache = -1;
text[p_line].data = p_text;
}
@@ -280,6 +293,7 @@ void TextEdit::Text::insert(int p_at, const String &p_text) {
line.breakpoint = false;
line.hidden = false;
line.width_cache = -1;
+ line.wrap_amount_cache = -1;
line.data = p_text;
text.insert(p_at, line);
}
@@ -288,6 +302,25 @@ void TextEdit::Text::remove(int p_at) {
text.remove(p_at);
}
+int TextEdit::Text::get_char_width(char c, char next_c, int px) const {
+
+ int tab_w = font->get_char_size(' ').width * indent_size;
+ int w = 0;
+
+ if (c == '\t') {
+
+ int left = px % tab_w;
+ if (left == 0)
+ w = tab_w;
+ else
+ w = tab_w - px % tab_w; // is right...
+ } else {
+
+ w = font->get_char_size(c, next_c).width;
+ }
+ return w;
+}
+
void TextEdit::_update_scrollbars() {
Size2 size = get_size();
@@ -303,7 +336,11 @@ void TextEdit::_update_scrollbars() {
int hscroll_rows = ((hmin.height - 1) / get_row_height()) + 1;
int visible_rows = get_visible_rows();
- int total_rows = (is_hiding_enabled() ? get_total_unhidden_rows() : text.size());
+ int first_vis_line = get_first_visible_line();
+ int wi;
+ int num_rows = MAX(visible_rows, num_lines_from_rows(first_vis_line, cursor.wrap_ofs, visible_rows, wi));
+
+ int total_rows = get_total_visible_rows();
if (scroll_past_end_of_file_enabled) {
total_rows += visible_rows - 1;
}
@@ -349,28 +386,24 @@ void TextEdit::_update_scrollbars() {
if (use_vscroll) {
v_scroll->show();
- v_scroll->set_max(total_rows);
- v_scroll->set_page(visible_rows);
+ v_scroll->set_max(total_rows + get_visible_rows_offset());
+ v_scroll->set_page(visible_rows + get_visible_rows_offset());
if (smooth_scroll_enabled) {
v_scroll->set_step(0.25);
} else {
v_scroll->set_step(1);
}
-
- update_line_scroll_pos();
- if (fabs(v_scroll->get_value() - get_line_scroll_pos()) >= 1) {
- cursor.line_ofs += v_scroll->get_value() - get_line_scroll_pos();
- }
+ set_v_scroll(get_v_scroll());
} else {
cursor.line_ofs = 0;
- line_scroll_pos = 0;
+ cursor.wrap_ofs = 0;
v_scroll->set_value(0);
v_scroll->hide();
}
- if (use_hscroll) {
+ if (use_hscroll && !is_wrap_enabled()) {
h_scroll->show();
h_scroll->set_max(total_width);
@@ -421,8 +454,8 @@ void TextEdit::_update_selection_mode_pointer() {
select(selection.selecting_line, selection.selecting_column, row, col);
- cursor_set_line(row);
- cursor_set_column(col);
+ cursor_set_line(row, false);
+ cursor_set_column(col, false);
update();
click_select_held->start();
@@ -475,7 +508,7 @@ void TextEdit::_update_selection_mode_word() {
cursor_set_column(selection.to_column);
}
}
- cursor_set_line(row);
+ cursor_set_line(row, false);
update();
click_select_held->start();
@@ -490,15 +523,15 @@ void TextEdit::_update_selection_mode_line() {
col = 0;
if (row < selection.selecting_line) {
// cursor is above us
- cursor_set_line(row - 1);
+ cursor_set_line(row - 1, false);
selection.selecting_column = text[selection.selecting_line].length();
} else {
// cursor is below us
- cursor_set_line(row + 1);
+ cursor_set_line(row + 1, false);
selection.selecting_column = 0;
col = text[row].length();
}
- cursor_set_column(0);
+ cursor_set_column(0, false);
select(selection.selecting_line, selection.selecting_column, row, col);
update();
@@ -516,13 +549,13 @@ void TextEdit::_notification(int p_what) {
MessageQueue::get_singleton()->push_call(this, "_cursor_changed_emit");
if (text_changed_dirty)
MessageQueue::get_singleton()->push_call(this, "_text_changed_emit");
-
+ update_wrap_at();
} break;
case NOTIFICATION_RESIZED: {
cache.size = get_size();
- adjust_viewport_to_cursor();
-
+ _update_scrollbars();
+ update_wrap_at();
} break;
case NOTIFICATION_THEME_CHANGED: {
@@ -539,17 +572,17 @@ void TextEdit::_notification(int p_what) {
update();
} break;
case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
- if (scrolling && v_scroll->get_value() != target_v_scroll) {
- double target_y = target_v_scroll - v_scroll->get_value();
+ if (scrolling && get_v_scroll() != target_v_scroll) {
+ double target_y = target_v_scroll - get_v_scroll();
double dist = sqrt(target_y * target_y);
double vel = ((target_y / dist) * v_scroll_speed) * get_physics_process_delta_time();
if (Math::abs(vel) >= dist) {
- v_scroll->set_value(target_v_scroll);
+ set_v_scroll(target_v_scroll);
scrolling = false;
set_physics_process_internal(false);
} else {
- v_scroll->set_value(v_scroll->get_value() + vel);
+ set_v_scroll(get_v_scroll() + vel);
}
} else {
scrolling = false;
@@ -776,12 +809,14 @@ void TextEdit::_notification(int p_what) {
String highlighted_text = get_selection_text();
String line_num_padding = line_numbers_zero_padded ? "0" : " ";
- update_line_scroll_pos();
- int line = cursor.line_ofs - 1;
- // another row may be visible during smooth scrolling
- int draw_amount = visible_rows + (smooth_scroll_enabled ? 1 : 0);
+ int cursor_wrap_index = get_cursor_wrap_index();
+
FontDrawer drawer(cache.font, Color(1, 1, 1));
+
+ int line = get_first_visible_line() - 1;
+ int draw_amount = visible_rows + (smooth_scroll_enabled ? 1 : 0);
+ draw_amount += times_line_wraps(line + 1);
for (int i = 0; i < draw_amount; i++) {
line++;
@@ -799,269 +834,360 @@ void TextEdit::_notification(int p_what) {
if (line < 0 || line >= (int)text.size())
continue;
- const String &str = text[line];
+ const String &fullstr = text[line];
- int char_margin = xmargin_beg - cursor.x_ofs;
- int char_ofs = 0;
-
- int ofs_readonly = 0;
- int ofs_x = 0;
+ Map<int, HighlighterInfo> color_map;
+ if (syntax_coloring) {
+ color_map = _get_line_syntax_highlighting(line);
+ }
+ // ensure we at least use the font color
+ Color current_color = cache.font_color;
if (readonly) {
- ofs_readonly = cache.style_readonly->get_offset().y / 2;
- ofs_x = cache.style_readonly->get_offset().x / 2;
+ current_color.a *= readonly_alpha;
}
- int ofs_y = (i * get_row_height() + cache.line_spacing / 2) + ofs_readonly;
- if (smooth_scroll_enabled)
- ofs_y -= ((v_scroll->get_value() - get_line_scroll_pos()) * get_row_height());
bool underlined = false;
- // check if line contains highlighted word
- int highlighted_text_col = -1;
- int search_text_col = -1;
- int highlighted_word_col = -1;
+ int line_wrap_amount = times_line_wraps(line);
+ int last_wrap_column = 0;
+ Vector<String> wrap_rows = get_wrap_rows_text(line);
- if (!search_text.empty())
- search_text_col = _get_column_pos_of_word(search_text, str, search_flags, 0);
+ for (int line_wrap_index = 0; line_wrap_index < line_wrap_amount + 1; line_wrap_index++) {
+ if (line_wrap_index != 0) {
+ i++;
+ if (i >= draw_amount)
+ break;
+ }
- if (highlighted_text.length() != 0 && highlighted_text != search_text)
- highlighted_text_col = _get_column_pos_of_word(highlighted_text, str, SEARCH_MATCH_CASE | SEARCH_WHOLE_WORDS, 0);
+ const String &str = wrap_rows[line_wrap_index];
+ int indent_px = line_wrap_index != 0 ? get_indent_level(line) * cache.font->get_char_size(' ').width : 0;
- if (select_identifiers_enabled && highlighted_word.length() != 0) {
- if (_is_char(highlighted_word[0])) {
- highlighted_word_col = _get_column_pos_of_word(highlighted_word, str, SEARCH_MATCH_CASE | SEARCH_WHOLE_WORDS, 0);
+ if (line_wrap_index > 0)
+ last_wrap_column += wrap_rows[line_wrap_index - 1].length();
+
+ int char_margin = xmargin_beg - cursor.x_ofs;
+ char_margin += indent_px;
+ int char_ofs = 0;
+
+ int ofs_readonly = 0;
+ int ofs_x = 0;
+ if (readonly) {
+ ofs_readonly = cache.style_readonly->get_offset().y / 2;
+ ofs_x = cache.style_readonly->get_offset().x / 2;
}
- }
- if (text.is_marked(line)) {
+ int ofs_y = (i * get_row_height() + cache.line_spacing / 2) + ofs_readonly;
+ ofs_y -= cursor.wrap_ofs * get_row_height();
+ if (smooth_scroll_enabled)
+ ofs_y += (-get_v_scroll_offset()) * get_row_height();
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, xmargin_end - xmargin_beg, get_row_height()), cache.mark_color);
- }
+ // check if line contains highlighted word
+ int highlighted_text_col = -1;
+ int search_text_col = -1;
+ int highlighted_word_col = -1;
+
+ if (!search_text.empty())
+ search_text_col = _get_column_pos_of_word(search_text, str, search_flags, 0);
- if (str.length() == 0) {
- // draw line background if empty as we won't loop at at all
- if (line == cursor.line && highlight_current_line) {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(ofs_x, ofs_y, xmargin_end, get_row_height()), cache.current_line_color);
+ if (highlighted_text.length() != 0 && highlighted_text != search_text)
+ highlighted_text_col = _get_column_pos_of_word(highlighted_text, str, SEARCH_MATCH_CASE | SEARCH_WHOLE_WORDS, 0);
+
+ if (select_identifiers_enabled && highlighted_word.length() != 0) {
+ if (_is_char(highlighted_word[0])) {
+ highlighted_word_col = _get_column_pos_of_word(highlighted_word, fullstr, SEARCH_MATCH_CASE | SEARCH_WHOLE_WORDS, 0);
+ }
}
- // give visual indication of empty selected line
- if (selection.active && line >= selection.from_line && line <= selection.to_line && char_margin >= xmargin_beg) {
- int char_w = cache.font->get_char_size(' ').width;
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, char_w, get_row_height()), cache.selection_color);
+ if (text.is_marked(line)) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, xmargin_end - xmargin_beg, get_row_height()), cache.mark_color);
}
- } else {
- // if it has text, then draw current line marker in the margin, as line number etc will draw over it, draw the rest of line marker later.
- if (line == cursor.line && highlight_current_line) {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(0, ofs_y, xmargin_beg + ofs_x, get_row_height()), cache.current_line_color);
+
+ if (str.length() == 0) {
+ // draw line background if empty as we won't loop at at all
+ if (line == cursor.line && cursor_wrap_index == line_wrap_index && highlight_current_line) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(ofs_x, ofs_y, xmargin_end, get_row_height()), cache.current_line_color);
+ }
+
+ // give visual indication of empty selected line
+ if (selection.active && line >= selection.from_line && line <= selection.to_line && char_margin >= xmargin_beg) {
+ int char_w = cache.font->get_char_size(' ').width;
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, char_w, get_row_height()), cache.selection_color);
+ }
+ } else {
+ // if it has text, then draw current line marker in the margin, as line number etc will draw over it, draw the rest of line marker later.
+ if (line == cursor.line && cursor_wrap_index == line_wrap_index && highlight_current_line) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(0, ofs_y, xmargin_beg, get_row_height()), cache.current_line_color);
+ }
}
- }
- if (text.is_breakpoint(line) && !draw_breakpoint_gutter) {
+ if (line_wrap_index == 0) {
+ // only do these if we are on the first wrapped part of a line
+
+ if (text.is_breakpoint(line) && !draw_breakpoint_gutter) {
#ifdef TOOLS_ENABLED
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y + get_row_height() - EDSCALE, xmargin_end - xmargin_beg, EDSCALE), cache.breakpoint_color);
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y + get_row_height() - EDSCALE, xmargin_end - xmargin_beg, EDSCALE), cache.breakpoint_color);
#else
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, xmargin_end - xmargin_beg, get_row_height()), cache.breakpoint_color);
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, xmargin_end - xmargin_beg, get_row_height()), cache.breakpoint_color);
#endif
- }
+ }
- // draw breakpoint marker
- if (text.is_breakpoint(line)) {
- if (draw_breakpoint_gutter) {
- int vertical_gap = (get_row_height() * 40) / 100;
- int horizontal_gap = (cache.breakpoint_gutter_width * 30) / 100;
- int marker_height = get_row_height() - (vertical_gap * 2);
- int marker_width = cache.breakpoint_gutter_width - (horizontal_gap * 2);
- // no transparency on marker
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cache.style_normal->get_margin(MARGIN_LEFT) + horizontal_gap - 2, ofs_y + vertical_gap, marker_width, marker_height), Color(cache.breakpoint_color.r, cache.breakpoint_color.g, cache.breakpoint_color.b));
- }
- }
+ // draw breakpoint marker
+ if (text.is_breakpoint(line)) {
+ if (draw_breakpoint_gutter) {
+ int vertical_gap = (get_row_height() * 40) / 100;
+ int horizontal_gap = (cache.breakpoint_gutter_width * 30) / 100;
+ int marker_height = get_row_height() - (vertical_gap * 2);
+ int marker_width = cache.breakpoint_gutter_width - (horizontal_gap * 2);
+ // no transparency on marker
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cache.style_normal->get_margin(MARGIN_LEFT) + horizontal_gap - 2, ofs_y + vertical_gap, marker_width, marker_height), Color(cache.breakpoint_color.r, cache.breakpoint_color.g, cache.breakpoint_color.b));
+ }
+ }
- // draw fold markers
- if (draw_fold_gutter) {
- int horizontal_gap = (cache.fold_gutter_width * 30) / 100;
- int gutter_left = cache.style_normal->get_margin(MARGIN_LEFT) + cache.breakpoint_gutter_width + cache.line_number_w;
- if (is_folded(line)) {
- int xofs = horizontal_gap - (cache.can_fold_icon->get_width()) / 2;
- int yofs = (get_row_height() - cache.folded_icon->get_height()) / 2;
- cache.folded_icon->draw(ci, Point2(gutter_left + xofs + ofs_x, ofs_y + yofs), cache.code_folding_color);
- } else if (can_fold(line)) {
- int xofs = -cache.can_fold_icon->get_width() / 2 - horizontal_gap + 3;
- int yofs = (get_row_height() - cache.can_fold_icon->get_height()) / 2;
- cache.can_fold_icon->draw(ci, Point2(gutter_left + xofs + ofs_x, ofs_y + yofs), cache.code_folding_color);
- }
- }
+ // draw fold markers
+ if (draw_fold_gutter) {
+ int horizontal_gap = (cache.fold_gutter_width * 30) / 100;
+ int gutter_left = cache.style_normal->get_margin(MARGIN_LEFT) + cache.breakpoint_gutter_width + cache.line_number_w;
+ if (is_folded(line)) {
+ int xofs = horizontal_gap - (cache.can_fold_icon->get_width()) / 2;
+ int yofs = (get_row_height() - cache.folded_icon->get_height()) / 2;
+ cache.folded_icon->draw(ci, Point2(gutter_left + xofs + ofs_x, ofs_y + yofs), cache.code_folding_color);
+ } else if (can_fold(line)) {
+ int xofs = -cache.can_fold_icon->get_width() / 2 - horizontal_gap + 3;
+ int yofs = (get_row_height() - cache.can_fold_icon->get_height()) / 2;
+ cache.can_fold_icon->draw(ci, Point2(gutter_left + xofs + ofs_x, ofs_y + yofs), cache.code_folding_color);
+ }
+ }
+
+ // draw line numbers
+ if (cache.line_number_w) {
+ String fc = String::num(line + 1);
+ while (fc.length() < line_number_char_count) {
+ fc = line_num_padding + fc;
+ }
- if (cache.line_number_w) {
- String fc = String::num(line + 1);
- while (fc.length() < line_number_char_count) {
- fc = line_num_padding + fc;
+ cache.font->draw(ci, Point2(cache.style_normal->get_margin(MARGIN_LEFT) + cache.breakpoint_gutter_width + ofs_x, ofs_y + cache.font->get_ascent()), fc, cache.line_number_color);
+ }
}
- cache.font->draw(ci, Point2(cache.style_normal->get_margin(MARGIN_LEFT) + cache.breakpoint_gutter_width + ofs_x, ofs_y + cache.font->get_ascent()), fc, cache.line_number_color);
- }
+ //loop through characters in one line
+ for (int j = 0; j < str.length(); j++) {
- //loop through characters in one line
- Map<int, HighlighterInfo> color_map;
- if (syntax_coloring) {
- color_map = _get_line_syntax_highlighting(line);
- }
+ if (syntax_coloring) {
+ if (color_map.has(last_wrap_column + j)) {
+ current_color = color_map[last_wrap_column + j].color;
+ if (readonly) {
+ current_color.a *= readonly_alpha;
+ }
+ }
+ color = current_color;
+ }
- // ensure we at least use the font color
- Color current_color = cache.font_color;
- if (readonly) {
- current_color.a *= readonly_alpha;
- }
- for (int j = 0; j < str.length(); j++) {
+ int char_w;
+
+ //handle tabulator
+ char_w = text.get_char_width(str[j], str[j + 1], char_ofs);
+
+ if ((char_ofs + char_margin) < xmargin_beg) {
+ char_ofs += char_w;
- if (syntax_coloring) {
- if (color_map.has(j)) {
- current_color = color_map[j].color;
- if (readonly) {
- current_color.a *= readonly_alpha;
+ // line highlighting handle horizontal clipping
+ if (line == cursor.line && cursor_wrap_index == line_wrap_index && highlight_current_line) {
+
+ if (j == str.length() - 1) {
+ // end of line when last char is skipped
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, xmargin_end - (char_ofs + char_margin + char_w), get_row_height()), cache.current_line_color);
+ } else if ((char_ofs + char_margin) > xmargin_beg) {
+ // char next to margin is skipped
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, (char_ofs + char_margin) - (xmargin_beg + ofs_x), get_row_height()), cache.current_line_color);
+ }
}
+ continue;
}
- color = current_color;
- }
- int char_w;
- //handle tabulator
+ if ((char_ofs + char_margin + char_w) >= xmargin_end) {
+ if (syntax_coloring)
+ continue;
+ else
+ break;
+ }
- if (str[j] == '\t') {
- int left = char_ofs % tab_w;
- if (left == 0)
- char_w = tab_w;
- else
- char_w = tab_w - char_ofs % tab_w; // is right...
+ bool in_search_result = false;
- } else {
- char_w = cache.font->get_char_size(str[j], str[j + 1]).width;
- }
+ if (search_text_col != -1) {
+ // if we are at the end check for new search result on same line
+ if (j >= search_text_col + search_text.length())
+ search_text_col = _get_column_pos_of_word(search_text, str, search_flags, j);
- if ((char_ofs + char_margin) < xmargin_beg) {
- char_ofs += char_w;
+ in_search_result = j >= search_text_col && j < search_text_col + search_text.length();
- // line highlighting handle horizontal clipping
- if (line == cursor.line && highlight_current_line) {
+ if (in_search_result) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin, ofs_y), Size2i(char_w, get_row_height())), cache.search_result_color);
+ }
+ }
- if (j == str.length() - 1) {
- // end of line when last char is skipped
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, xmargin_end - (xmargin_beg + ofs_x), get_row_height()), cache.current_line_color);
+ //current line highlighting
+ bool in_selection = (selection.active && line >= selection.from_line && line <= selection.to_line && (line > selection.from_line || last_wrap_column + j >= selection.from_column) && (line < selection.to_line || last_wrap_column + j < selection.to_column));
- } else if ((char_ofs + char_margin) > xmargin_beg) {
- // char next to margin is skipped
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(xmargin_beg + ofs_x, ofs_y, (char_ofs + char_margin) - xmargin_beg, get_row_height()), cache.current_line_color);
+ if (line == cursor.line && cursor_wrap_index == line_wrap_index && highlight_current_line) {
+ // draw the wrap indent offset highlight
+ if (line_wrap_index != 0 && j == 0) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(char_ofs + char_margin - indent_px, ofs_y, (char_ofs + char_margin), get_row_height()), cache.current_line_color);
+ }
+ // if its the last char draw to end of the line
+ if (j == str.length() - 1) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(char_ofs + char_margin + char_w, ofs_y, xmargin_end - (char_ofs + char_margin + char_w), get_row_height()), cache.current_line_color);
+ }
+ // actual text
+ if (!in_selection) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(char_w, get_row_height())), cache.current_line_color);
}
}
- continue;
- }
- if ((char_ofs + char_margin + char_w) >= xmargin_end) {
- if (syntax_coloring)
- continue;
- else
- break;
- }
-
- bool in_search_result = false;
+ if (in_selection) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(char_w, get_row_height())), cache.selection_color);
+ }
- if (search_text_col != -1) {
- // if we are at the end check for new search result on same line
- if (j >= search_text_col + search_text.length())
- search_text_col = _get_column_pos_of_word(search_text, str, search_flags, j);
+ if (in_search_result) {
+ Color border_color = (line == search_result_line && j >= search_result_col && j < search_result_col + search_text.length()) ? cache.font_color : cache.search_result_border_color;
- in_search_result = j >= search_text_col && j < search_text_col + search_text.length();
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(char_w, 1)), border_color);
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y + get_row_height() - 1), Size2i(char_w, 1)), border_color);
- if (in_search_result) {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin, ofs_y), Size2i(char_w, get_row_height())), cache.search_result_color);
+ if (j == search_text_col)
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(1, get_row_height())), border_color);
+ if (j == search_text_col + search_text.length() - 1)
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + char_w + ofs_x - 1, ofs_y), Size2i(1, get_row_height())), border_color);
}
- }
- //current line highlighting
- bool in_selection = (selection.active && line >= selection.from_line && line <= selection.to_line && (line > selection.from_line || j >= selection.from_column) && (line < selection.to_line || j < selection.to_column));
+ if (highlight_all_occurrences) {
+ if (highlighted_text_col != -1) {
+
+ // if we are at the end check for new word on same line
+ if (j > highlighted_text_col + highlighted_text.length()) {
+ highlighted_text_col = _get_column_pos_of_word(highlighted_text, str, SEARCH_MATCH_CASE | SEARCH_WHOLE_WORDS, j);
+ }
+
+ bool in_highlighted_word = (j >= highlighted_text_col && j < highlighted_text_col + highlighted_text.length());
- if (line == cursor.line && highlight_current_line) {
- // if its the last char draw to end of the line
- if (j == str.length() - 1) {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(char_ofs + char_margin + char_w, ofs_y, xmargin_end - (char_ofs + char_margin + char_w), get_row_height()), cache.current_line_color);
+ // if this is the original highlighted text we don't want to highlight it again
+ if (cursor.line == line && cursor_wrap_index == line_wrap_index && (cursor.column >= highlighted_text_col && cursor.column <= highlighted_text_col + highlighted_text.length())) {
+ in_highlighted_word = false;
+ }
+
+ if (in_highlighted_word) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(char_w, get_row_height())), cache.word_highlighted_color);
+ }
+ }
}
- // actual text
- if (!in_selection) {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(char_w, get_row_height())), cache.current_line_color);
+
+ if (highlighted_word_col != -1) {
+ if (j + last_wrap_column > highlighted_word_col + highlighted_word.length()) {
+ highlighted_word_col = _get_column_pos_of_word(highlighted_word, fullstr, SEARCH_MATCH_CASE | SEARCH_WHOLE_WORDS, j + last_wrap_column);
+ }
+ underlined = (j + last_wrap_column >= highlighted_word_col && j + last_wrap_column < highlighted_word_col + highlighted_word.length());
}
- }
- if (in_selection) {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(char_w, get_row_height())), cache.selection_color);
- }
+ if (brace_matching_enabled) {
+ if ((brace_open_match_line == line && brace_open_match_column == last_wrap_column + j) ||
+ (cursor.column == last_wrap_column + j && cursor.line == line && cursor_wrap_index == line_wrap_index && (brace_open_matching || brace_open_mismatch))) {
- if (in_search_result) {
- Color border_color = (line == search_result_line && j >= search_result_col && j < search_result_col + search_text.length()) ? cache.font_color : cache.search_result_border_color;
+ if (brace_open_mismatch)
+ color = cache.brace_mismatch_color;
+ drawer.draw_char(ci, Point2i(char_ofs + char_margin + ofs_x, ofs_y + ascent), '_', str[j + 1], in_selection && override_selected_font_color ? cache.font_selected_color : color);
+ }
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(char_w, 1)), border_color);
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y + get_row_height() - 1), Size2i(char_w, 1)), border_color);
+ if ((brace_close_match_line == line && brace_close_match_column == last_wrap_column + j) ||
+ (cursor.column == last_wrap_column + j + 1 && cursor.line == line && cursor_wrap_index == line_wrap_index && (brace_close_matching || brace_close_mismatch))) {
- if (j == search_text_col)
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(1, get_row_height())), border_color);
- if (j == search_text_col + search_text.length() - 1)
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + char_w + ofs_x - 1, ofs_y), Size2i(1, get_row_height())), border_color);
- }
+ if (brace_close_mismatch)
+ color = cache.brace_mismatch_color;
+ drawer.draw_char(ci, Point2i(char_ofs + char_margin + ofs_x, ofs_y + ascent), '_', str[j + 1], in_selection && override_selected_font_color ? cache.font_selected_color : color);
+ }
+ }
+
+ if (cursor.column == last_wrap_column + j && cursor.line == line && cursor_wrap_index == line_wrap_index) {
- if (highlight_all_occurrences) {
- if (highlighted_text_col != -1) {
+ cursor_pos = Point2i(char_ofs + char_margin + ofs_x, ofs_y);
- // if we are at the end check for new word on same line
- if (j > highlighted_text_col + highlighted_text.length()) {
- highlighted_text_col = _get_column_pos_of_word(highlighted_text, str, SEARCH_MATCH_CASE | SEARCH_WHOLE_WORDS, j);
+ if (insert_mode) {
+ cursor_pos.y += (get_row_height() - 3);
}
- bool in_highlighted_word = (j >= highlighted_text_col && j < highlighted_text_col + highlighted_text.length());
+ int caret_w = (str[j] == '\t') ? cache.font->get_char_size(' ').width : char_w;
+ if (ime_text.length() > 0) {
+ int ofs = 0;
+ while (true) {
+ if (ofs >= ime_text.length())
+ break;
- /* if this is the original highlighted text we don't want to highlight it again */
- if (cursor.line == line && (cursor.column >= highlighted_text_col && cursor.column <= highlighted_text_col + highlighted_text.length())) {
- in_highlighted_word = false;
- }
+ CharType cchar = ime_text[ofs];
+ CharType next = ime_text[ofs + 1];
+ int im_char_width = cache.font->get_char_size(cchar, next).width;
+
+ if ((char_ofs + char_margin + im_char_width) >= xmargin_end)
+ break;
- if (in_highlighted_word) {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2i(char_ofs + char_margin + ofs_x, ofs_y), Size2i(char_w, get_row_height())), cache.word_highlighted_color);
+ bool selected = ofs >= ime_selection.x && ofs < ime_selection.x + ime_selection.y;
+ if (selected) {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(char_ofs + char_margin, ofs_y + get_row_height()), Size2(im_char_width, 3)), color);
+ } else {
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(char_ofs + char_margin, ofs_y + get_row_height()), Size2(im_char_width, 1)), color);
+ }
+
+ drawer.draw_char(ci, Point2(char_ofs + char_margin + ofs_x, ofs_y + ascent), cchar, next, color);
+
+ char_ofs += im_char_width;
+ ofs++;
+ }
+ }
+ if (ime_text.length() == 0) {
+ if (draw_caret) {
+ if (insert_mode) {
+ int caret_h = (block_caret) ? 4 : 1;
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cursor_pos, Size2i(caret_w, caret_h)), cache.caret_color);
+ } else {
+ caret_w = (block_caret) ? caret_w : 1;
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cursor_pos, Size2i(caret_w, get_row_height())), cache.caret_color);
+ }
+ }
}
}
- }
- if (highlighted_word_col != -1) {
- if (j > highlighted_word_col + highlighted_word.length()) {
- highlighted_word_col = _get_column_pos_of_word(highlighted_word, str, SEARCH_MATCH_CASE | SEARCH_WHOLE_WORDS, j);
+ if (cursor.column == last_wrap_column + j && cursor.line == line && cursor_wrap_index == line_wrap_index && block_caret && draw_caret && !insert_mode) {
+ color = cache.caret_background_color;
+ } else if (!syntax_coloring && block_caret) {
+ color = cache.font_color;
+ color.a *= readonly_alpha;
}
- underlined = (j >= highlighted_word_col && j < highlighted_word_col + highlighted_word.length());
- }
-
- if (brace_matching_enabled) {
- if ((brace_open_match_line == line && brace_open_match_column == j) ||
- (cursor.column == j && cursor.line == line && (brace_open_matching || brace_open_mismatch))) {
- if (brace_open_mismatch)
- color = cache.brace_mismatch_color;
- drawer.draw_char(ci, Point2i(char_ofs + char_margin + ofs_x, ofs_y + ascent), '_', str[j + 1], in_selection && override_selected_font_color ? cache.font_selected_color : color);
+ if (str[j] >= 32) {
+ int w = drawer.draw_char(ci, Point2i(char_ofs + char_margin + ofs_x, ofs_y + ascent), str[j], str[j + 1], in_selection && override_selected_font_color ? cache.font_selected_color : color);
+ if (underlined) {
+ draw_rect(Rect2(char_ofs + char_margin + ofs_x, ofs_y + ascent + 2, w, 1), in_selection && override_selected_font_color ? cache.font_selected_color : color);
+ }
+ } else if (draw_tabs && str[j] == '\t') {
+ int yofs = (get_row_height() - cache.tab_icon->get_height()) / 2;
+ cache.tab_icon->draw(ci, Point2(char_ofs + char_margin + ofs_x, ofs_y + yofs), in_selection && override_selected_font_color ? cache.font_selected_color : color);
}
- if (
- (brace_close_match_line == line && brace_close_match_column == j) ||
- (cursor.column == j + 1 && cursor.line == line && (brace_close_matching || brace_close_mismatch))) {
+ char_ofs += char_w;
- if (brace_close_mismatch)
- color = cache.brace_mismatch_color;
- drawer.draw_char(ci, Point2i(char_ofs + char_margin + ofs_x, ofs_y + ascent), '_', str[j + 1], in_selection && override_selected_font_color ? cache.font_selected_color : color);
+ if (line_wrap_index == line_wrap_amount && j == str.length() - 1 && is_folded(line)) {
+ int yofs = (get_row_height() - cache.folded_eol_icon->get_height()) / 2;
+ int xofs = cache.folded_eol_icon->get_width() / 2;
+ Color eol_color = cache.code_folding_color;
+ eol_color.a = 1;
+ cache.folded_eol_icon->draw(ci, Point2(char_ofs + char_margin + xofs + ofs_x, ofs_y + yofs), eol_color);
}
}
- if (cursor.column == j && cursor.line == line) {
+ if (cursor.column == last_wrap_column + str.length() && cursor.line == line && cursor_wrap_index == line_wrap_index && (char_ofs + char_margin) >= xmargin_beg) {
cursor_pos = Point2i(char_ofs + char_margin + ofs_x, ofs_y);
if (insert_mode) {
cursor_pos.y += (get_row_height() - 3);
}
-
- int caret_w = (str[j] == '\t') ? cache.font->get_char_size(' ').width : char_w;
if (ime_text.length() > 0) {
int ofs = 0;
while (true) {
@@ -1091,92 +1217,17 @@ void TextEdit::_notification(int p_what) {
if (ime_text.length() == 0) {
if (draw_caret) {
if (insert_mode) {
+ int char_w = cache.font->get_char_size(' ').width;
int caret_h = (block_caret) ? 4 : 1;
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cursor_pos, Size2i(caret_w, caret_h)), cache.caret_color);
+ VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cursor_pos, Size2i(char_w, caret_h)), cache.caret_color);
} else {
- caret_w = (block_caret) ? caret_w : 1;
+ int char_w = cache.font->get_char_size(' ').width;
+ int caret_w = (block_caret) ? char_w : 1;
VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cursor_pos, Size2i(caret_w, get_row_height())), cache.caret_color);
}
}
}
}
-
- if (cursor.column == j && cursor.line == line && block_caret && draw_caret && !insert_mode) {
- color = cache.caret_background_color;
- } else if (!syntax_coloring && block_caret) {
- color = cache.font_color;
- color.a *= readonly_alpha;
- }
-
- if (str[j] >= 32) {
- int w = drawer.draw_char(ci, Point2i(char_ofs + char_margin + ofs_x, ofs_y + ascent), str[j], str[j + 1], in_selection && override_selected_font_color ? cache.font_selected_color : color);
- if (underlined) {
- draw_rect(Rect2(char_ofs + char_margin + ofs_x, ofs_y + ascent + 2, w, 1), in_selection && override_selected_font_color ? cache.font_selected_color : color);
- }
- }
-
- else if (draw_tabs && str[j] == '\t') {
- int yofs = (get_row_height() - cache.tab_icon->get_height()) / 2;
- cache.tab_icon->draw(ci, Point2(char_ofs + char_margin + ofs_x, ofs_y + yofs), in_selection && override_selected_font_color ? cache.font_selected_color : color);
- }
-
- char_ofs += char_w;
-
- if (j == str.length() - 1 && is_folded(line)) {
- int yofs = (get_row_height() - cache.folded_eol_icon->get_height()) / 2;
- int xofs = cache.folded_eol_icon->get_width() / 2;
- Color eol_color = cache.code_folding_color;
- eol_color.a = 1;
- cache.folded_eol_icon->draw(ci, Point2(char_ofs + char_margin + xofs + ofs_x, ofs_y + yofs), eol_color);
- }
- }
-
- if (cursor.column == str.length() && cursor.line == line && (char_ofs + char_margin) >= xmargin_beg) {
-
- cursor_pos = Point2i(char_ofs + char_margin + ofs_x, ofs_y);
-
- if (insert_mode) {
- cursor_pos.y += (get_row_height() - 3);
- }
- if (ime_text.length() > 0) {
- int ofs = 0;
- while (true) {
- if (ofs >= ime_text.length())
- break;
-
- CharType cchar = ime_text[ofs];
- CharType next = ime_text[ofs + 1];
- int im_char_width = cache.font->get_char_size(cchar, next).width;
-
- if ((char_ofs + char_margin + im_char_width) >= xmargin_end)
- break;
-
- bool selected = ofs >= ime_selection.x && ofs < ime_selection.x + ime_selection.y;
- if (selected) {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(char_ofs + char_margin, ofs_y + get_row_height()), Size2(im_char_width, 3)), color);
- } else {
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(char_ofs + char_margin, ofs_y + get_row_height()), Size2(im_char_width, 1)), color);
- }
-
- drawer.draw_char(ci, Point2(char_ofs + char_margin + ofs_x, ofs_y + ascent), cchar, next, color);
-
- char_ofs += im_char_width;
- ofs++;
- }
- }
- if (ime_text.length() == 0) {
- if (draw_caret) {
- if (insert_mode) {
- int char_w = cache.font->get_char_size(' ').width;
- int caret_h = (block_caret) ? 4 : 1;
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cursor_pos, Size2i(char_w, caret_h)), cache.caret_color);
- } else {
- int char_w = cache.font->get_char_size(' ').width;
- int caret_w = (block_caret) ? char_w : 1;
- VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(cursor_pos, Size2i(caret_w, get_row_height())), cache.caret_color);
- }
- }
- }
}
}
@@ -1603,16 +1654,17 @@ void TextEdit::_get_mouse_pos(const Point2i &p_mouse, int &r_row, int &r_col) co
float rows = p_mouse.y;
rows -= cache.style_normal->get_margin(MARGIN_TOP);
- rows += (CLAMP(v_scroll->get_value() - get_line_scroll_pos(true), 0, 1) * get_row_height());
rows /= get_row_height();
- int first_vis_line = CLAMP(cursor.line_ofs, 0, text.size() - 1);
+ rows += get_v_scroll_offset();
+ int first_vis_line = get_first_visible_line();
int row = first_vis_line + Math::floor(rows);
+ int wrap_index = 0;
+
+ if (is_wrap_enabled() || is_hiding_enabled()) {
- if (is_hiding_enabled()) {
- // row will be offset by the hidden rows
- int f_ofs = num_lines_from(first_vis_line, rows + 1) - 1;
+ int f_ofs = num_lines_from_rows(first_vis_line, cursor.wrap_ofs, rows + 1, wrap_index) - 1;
row = first_vis_line + f_ofs;
- row = CLAMP(row, 0, text.size() - num_lines_from(text.size() - 1, -1));
+ row = CLAMP(row, 0, get_last_visible_line() + 1);
}
if (row < 0)
@@ -1626,9 +1678,19 @@ void TextEdit::_get_mouse_pos(const Point2i &p_mouse, int &r_row, int &r_col) co
col = text[row].size();
} else {
- col = p_mouse.x - (cache.style_normal->get_margin(MARGIN_LEFT) + cache.line_number_w + cache.breakpoint_gutter_width + cache.fold_gutter_width);
- col += cursor.x_ofs;
- col = get_char_pos_for(col, get_line(row));
+ int colx = p_mouse.x - (cache.style_normal->get_margin(MARGIN_LEFT) + cache.line_number_w + cache.breakpoint_gutter_width + cache.fold_gutter_width);
+ colx += cursor.x_ofs;
+ col = get_char_pos_for_line(colx, row, wrap_index);
+ if (is_wrap_enabled() && wrap_index < times_line_wraps(row)) {
+ // move back one if we are at the end of the row
+ Vector<String> rows = get_wrap_rows_text(row);
+ int row_end_col = 0;
+ for (int i = 0; i < wrap_index + 1; i++) {
+ row_end_col += rows[i].length();
+ }
+ if (col >= row_end_col)
+ col -= 1;
+ }
}
r_row = row;
@@ -1703,7 +1765,6 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
_reset_caret_blink_timer();
int row, col;
- update_line_scroll_pos();
_get_mouse_pos(Point2i(mb->get_position().x, mb->get_position().y), row, col);
if (mb->get_command() && highlighted_word != String()) {
@@ -1835,7 +1896,6 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
_reset_caret_blink_timer();
int row, col;
- update_line_scroll_pos();
_get_mouse_pos(Point2i(mb->get_position().x, mb->get_position().y), row, col);
if (is_right_click_moving_caret()) {
@@ -2573,11 +2633,25 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
break;
}
- if (k->get_command())
+ if (k->get_command()) {
cursor_set_line(0);
- else
+ } else
#endif
- cursor_set_line(cursor_get_line() - num_lines_from(CLAMP(cursor.line - 1, 0, text.size() - 1), -1));
+ {
+ int cur_wrap_index = get_cursor_wrap_index();
+ if (cur_wrap_index > 0) {
+ cursor_set_line(cursor.line, true, false, cur_wrap_index - 1);
+ } else if (cursor.line == 0) {
+ cursor_set_column(0);
+ } else {
+ int new_line = cursor.line - num_lines_from(cursor.line - 1, -1);
+ if (line_wraps(new_line)) {
+ cursor_set_line(new_line, true, false, times_line_wraps(new_line));
+ } else {
+ cursor_set_line(new_line, true, false);
+ }
+ }
+ }
if (k->get_shift())
_post_shift_selection();
@@ -2605,22 +2679,25 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
break;
}
- {
#else
if (k->get_command() && k->get_alt()) {
_scroll_lines_down();
break;
}
- if (k->get_command())
- cursor_set_line(text.size() - 1, true, false);
- else {
+ if (k->get_command()) {
+ cursor_set_line(get_last_unhidden_line(), true, false, 9999);
+ } else
#endif
- if (!is_last_visible_line(cursor.line)) {
- cursor_set_line(cursor_get_line() + num_lines_from(CLAMP(cursor.line + 1, 0, text.size() - 1), 1), true, false);
+ {
+ int cur_wrap_index = get_cursor_wrap_index();
+ if (cur_wrap_index < times_line_wraps(cursor.line)) {
+ cursor_set_line(cursor.line, true, false, cur_wrap_index + 1);
+ } else if (cursor.line == get_last_unhidden_line()) {
+ cursor_set_column(text[cursor.line].length());
} else {
- cursor_set_line(text.size() - 1);
- cursor_set_column(get_line(cursor.line).length(), true);
+ int new_line = cursor.line + num_lines_from(CLAMP(cursor.line + 1, 0, text.size() - 1), 1);
+ cursor_set_line(new_line, true, false, 0);
}
}
@@ -2629,7 +2706,6 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
_cancel_code_hint();
} break;
-
case KEY_DELETE: {
if (readonly)
@@ -2736,19 +2812,31 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
cursor_set_line(0);
cursor_set_column(0);
} else {
- // compute whitespace symbols seq length
- int current_line_whitespace_len = 0;
- while (current_line_whitespace_len < text[cursor.line].length()) {
- CharType c = text[cursor.line][current_line_whitespace_len];
- if (c != '\t' && c != ' ')
- break;
- current_line_whitespace_len++;
+
+ // move cursor column to start of wrapped row and then to start of text
+ Vector<String> rows = get_wrap_rows_text(cursor.line);
+ int wi = get_cursor_wrap_index();
+ int row_start_col = 0;
+ for (int i = 0; i < wi; i++) {
+ row_start_col += rows[i].length();
}
+ if (cursor.column == row_start_col || wi == 0) {
+ // compute whitespace symbols seq length
+ int current_line_whitespace_len = 0;
+ while (current_line_whitespace_len < text[cursor.line].length()) {
+ CharType c = text[cursor.line][current_line_whitespace_len];
+ if (c != '\t' && c != ' ')
+ break;
+ current_line_whitespace_len++;
+ }
- if (cursor_get_column() == current_line_whitespace_len)
- cursor_set_column(0);
- else
- cursor_set_column(current_line_whitespace_len);
+ if (cursor_get_column() == current_line_whitespace_len)
+ cursor_set_column(0);
+ else
+ cursor_set_column(current_line_whitespace_len);
+ } else {
+ cursor_set_column(row_start_col);
+ }
}
if (k->get_shift())
@@ -2773,7 +2861,7 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
if (k->get_shift())
_pre_shift_selection();
- cursor_set_line(text.size() - 1, true, false);
+ cursor_set_line(get_last_unhidden_line(), true, false, 9999);
if (k->get_shift())
_post_shift_selection();
@@ -2788,8 +2876,20 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
_pre_shift_selection();
if (k->get_command())
- cursor_set_line(text.size() - 1, true, false);
- cursor_set_column(text[cursor.line].length());
+ cursor_set_line(get_last_unhidden_line(), true, false, 9999);
+
+ // move cursor column to end of wrapped row and then to end of text
+ Vector<String> rows = get_wrap_rows_text(cursor.line);
+ int wi = get_cursor_wrap_index();
+ int row_end_col = -1;
+ for (int i = 0; i < wi + 1; i++) {
+ row_end_col += rows[i].length();
+ }
+ if (wi == rows.size() - 1 || cursor.column == row_end_col) {
+ cursor_set_column(text[cursor.line].length());
+ } else {
+ cursor_set_column(row_end_col);
+ }
if (k->get_shift())
_post_shift_selection();
@@ -2813,7 +2913,9 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
if (k->get_shift())
_pre_shift_selection();
- cursor_set_line(cursor_get_line() - num_lines_from(cursor.line, -get_visible_rows()), true, false);
+ int wi;
+ int n_line = cursor.line - num_lines_from_rows(cursor.line, get_cursor_wrap_index(), -get_visible_rows(), wi) + 1;
+ cursor_set_line(n_line, true, false, wi);
if (k->get_shift())
_post_shift_selection();
@@ -2827,14 +2929,16 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
scancode_handled = false;
break;
}
- // numlock disabled. fallthrough to key_pageup
+ // numlock disabled. fallthrough to key_pagedown
}
case KEY_PAGEDOWN: {
if (k->get_shift())
_pre_shift_selection();
- cursor_set_line(cursor_get_line() + num_lines_from(cursor.line, get_visible_rows()), true, false);
+ int wi;
+ int n_line = cursor.line + num_lines_from_rows(cursor.line, get_cursor_wrap_index(), get_visible_rows(), wi) - 1;
+ cursor_set_line(n_line, true, false, wi);
if (k->get_shift())
_post_shift_selection();
@@ -3079,7 +3183,7 @@ void TextEdit::_scroll_up(real_t p_delta) {
if (scrolling) {
target_v_scroll = (target_v_scroll - p_delta);
} else {
- target_v_scroll = (v_scroll->get_value() - p_delta);
+ target_v_scroll = (get_v_scroll() - p_delta);
}
if (smooth_scroll_enabled) {
@@ -3093,7 +3197,7 @@ void TextEdit::_scroll_up(real_t p_delta) {
set_physics_process_internal(true);
}
} else {
- v_scroll->set_value(target_v_scroll);
+ set_v_scroll(target_v_scroll);
}
}
@@ -3105,20 +3209,15 @@ void TextEdit::_scroll_down(real_t p_delta) {
if (scrolling) {
target_v_scroll = (target_v_scroll + p_delta);
} else {
- target_v_scroll = (v_scroll->get_value() + p_delta);
+ target_v_scroll = (get_v_scroll() + p_delta);
}
if (smooth_scroll_enabled) {
- int max_v_scroll = get_total_unhidden_rows();
- if (!scroll_past_end_of_file_enabled) {
- max_v_scroll -= get_visible_rows();
- max_v_scroll = CLAMP(max_v_scroll, 0, get_total_unhidden_rows());
- }
-
+ int max_v_scroll = v_scroll->get_max() - v_scroll->get_page();
if (target_v_scroll > max_v_scroll) {
target_v_scroll = max_v_scroll;
+ v_scroll->set_value(target_v_scroll);
}
-
if (Math::abs(target_v_scroll - v_scroll->get_value()) < 1.0) {
v_scroll->set_value(target_v_scroll);
} else {
@@ -3126,7 +3225,7 @@ void TextEdit::_scroll_down(real_t p_delta) {
set_physics_process_internal(true);
}
} else {
- v_scroll->set_value(target_v_scroll);
+ set_v_scroll(target_v_scroll);
}
}
@@ -3157,35 +3256,37 @@ void TextEdit::_scroll_lines_up() {
scrolling = false;
// adjust the vertical scroll
- if (get_v_scroll() >= 0) {
- set_v_scroll(get_v_scroll() - 1);
- }
+ set_v_scroll(get_v_scroll() - 1);
+
+ // adjust the cursor to viewport
+ if (!selection.active) {
+ int cur_line = cursor.line;
+ int cur_wrap = get_cursor_wrap_index();
+ int last_vis_line = get_last_visible_line();
+ int last_vis_wrap = get_last_visible_line_wrap_index();
- // adjust the cursor
- int num_lines = num_lines_from(CLAMP(cursor.line_ofs, 0, text.size() - 1), get_visible_rows());
- if (cursor.line >= cursor.line_ofs + num_lines && !selection.active) {
- cursor_set_line(cursor.line_ofs + num_lines, false, false);
+ if (cur_line > last_vis_line || (cur_line == last_vis_line && cur_wrap > last_vis_wrap)) {
+ cursor_set_line(last_vis_line, false, false, last_vis_wrap);
+ }
}
}
void TextEdit::_scroll_lines_down() {
scrolling = false;
- // calculate the maximum vertical scroll position
- int max_v_scroll = get_total_unhidden_rows();
- if (!scroll_past_end_of_file_enabled) {
- max_v_scroll -= get_visible_rows();
- max_v_scroll = CLAMP(max_v_scroll, 0, get_total_unhidden_rows());
- }
-
// adjust the vertical scroll
- if (get_v_scroll() < max_v_scroll) {
- set_v_scroll(get_v_scroll() + 1);
- }
+ set_v_scroll(get_v_scroll() + 1);
- // adjust the cursor
- if (cursor.line <= cursor.line_ofs - 1 && !selection.active) {
- cursor_set_line(cursor.line_ofs, false, false);
+ // adjust the cursor to viewport
+ if (!selection.active) {
+ int cur_line = cursor.line;
+ int cur_wrap = get_cursor_wrap_index();
+ int first_vis_line = get_first_visible_line();
+ int first_vis_wrap = cursor.wrap_ofs;
+
+ if (cur_line < first_vis_line || (cur_line == first_vis_line && cur_wrap < first_vis_wrap)) {
+ cursor_set_line(first_vis_line, false, false, first_vis_wrap);
+ }
}
}
@@ -3239,6 +3340,8 @@ void TextEdit::_base_insert_text(int p_line, int p_char, const String &p_text, i
text.set_hidden(p_line, false);
}
+ text.set_line_wrap_amount(p_line, -1);
+
r_end_line = p_line + substrings.size() - 1;
r_end_column = text[r_end_line].length() - postinsert_text.length();
@@ -3293,6 +3396,8 @@ void TextEdit::_base_remove_text(int p_from_line, int p_from_column, int p_to_li
text.set(p_from_line, pre_text + post_text);
+ text.set_line_wrap_amount(p_from_line, -1);
+
if (!text_changed_dirty && !setting_text) {
if (is_inside_tree())
MessageQueue::get_singleton()->push_call(this, "_text_changed_emit");
@@ -3451,61 +3556,63 @@ int TextEdit::get_visible_rows() const {
int total = cache.size.height;
total -= cache.style_normal->get_minimum_size().height;
+ if (h_scroll->is_visible_in_tree())
+ total -= h_scroll->get_size().height;
total /= get_row_height();
return total;
}
-int TextEdit::get_total_unhidden_rows() const {
- if (!is_hiding_enabled())
+int TextEdit::get_total_visible_rows() const {
+
+ // returns the total amount of rows we need in the editor.
+ // This skips hidden lines and counts each wrapping of a line.
+ if (!is_hiding_enabled() && !is_wrap_enabled())
return text.size();
- int total_unhidden = 0;
+ int total_rows = 0;
for (int i = 0; i < text.size(); i++) {
- if (!text.is_hidden(i))
- total_unhidden++;
+ if (!text.is_hidden(i)) {
+ total_rows++;
+ total_rows += times_line_wraps(i);
+ }
}
- return total_unhidden;
+ return total_rows;
}
-double TextEdit::get_line_scroll_pos(bool p_recalculate) const {
+void TextEdit::update_wrap_at() {
- if (!is_hiding_enabled())
- return cursor.line_ofs;
- if (!p_recalculate)
- return line_scroll_pos;
+ wrap_at = cache.size.width - cache.style_normal->get_minimum_size().width - cache.line_number_w - cache.breakpoint_gutter_width - cache.fold_gutter_width - wrap_right_offset;
+ update_cursor_wrap_offset();
+ text.clear_wrap_cache();
- // count num unhidden lines to the cursor line ofs
- double new_line_scroll_pos = 0;
- int to = CLAMP(cursor.line_ofs, 0, text.size() - 1);
- for (int i = 0; i < to; i++) {
- if (!text.is_hidden(i))
- new_line_scroll_pos++;
+ for (int i = 0; i < text.size(); i++) {
+ // update all values that wrap
+ if (!line_wraps(i))
+ continue;
+ Vector<String> rows = get_wrap_rows_text(i);
+ text.set_line_wrap_amount(i, rows.size() - 1);
}
- return new_line_scroll_pos;
}
-void TextEdit::update_line_scroll_pos() {
+void TextEdit::adjust_viewport_to_cursor() {
- if (!is_hiding_enabled()) {
- line_scroll_pos = cursor.line_ofs;
- return;
- }
+ // make sure cursor is visible on the screen
+ scrolling = false;
- // count num unhidden lines to the cursor line ofs
- double new_line_scroll_pos = 0;
- int to = CLAMP(cursor.line_ofs, 0, text.size() - 1);
- for (int i = 0; i < to; i++) {
- if (!text.is_hidden(i))
- new_line_scroll_pos++;
- }
- line_scroll_pos = new_line_scroll_pos;
-}
+ int cur_line = cursor.line;
+ int cur_wrap = get_cursor_wrap_index();
-void TextEdit::adjust_viewport_to_cursor() {
- scrolling = false;
+ int first_vis_line = get_first_visible_line();
+ int first_vis_wrap = cursor.wrap_ofs;
+ int last_vis_line = get_last_visible_line();
+ int last_vis_wrap = get_last_visible_line_wrap_index();
- if (cursor.line_ofs > cursor.line) {
- cursor.line_ofs = cursor.line;
+ if (cur_line < first_vis_line || (cur_line == first_vis_line && cur_wrap < first_vis_wrap)) {
+ // cursor is above screen
+ set_line_as_first_visible(cur_line, cur_wrap);
+ } else if (cur_line > last_vis_line || (cur_line == last_vis_line && cur_wrap > last_vis_wrap)) {
+ // cursor is below screen
+ set_line_as_last_visible(cur_line, cur_wrap);
}
int visible_width = cache.size.width - cache.style_normal->get_minimum_size().width - cache.line_number_w - cache.breakpoint_gutter_width - cache.fold_gutter_width;
@@ -3513,91 +3620,174 @@ void TextEdit::adjust_viewport_to_cursor() {
visible_width -= v_scroll->get_combined_minimum_size().width;
visible_width -= 20; // give it a little more space
- int visible_rows = get_visible_rows();
- if (h_scroll->is_visible_in_tree() && !scroll_past_end_of_file_enabled)
- visible_rows -= ((h_scroll->get_combined_minimum_size().height - 1) / get_row_height());
- int num_rows = num_lines_from(CLAMP(cursor.line_ofs, 0, text.size() - 1), MIN(visible_rows, text.size() - 1 - cursor.line_ofs));
-
- // make sure the cursor is on the screen
- // above the caret
- if (cursor.line > (cursor.line_ofs + MAX(num_rows, visible_rows))) {
- cursor.line_ofs = cursor.line - num_lines_from(cursor.line, -visible_rows) + 1;
- }
- // below the caret
- if (cursor.line_ofs == cursor.line) {
- cursor.line_ofs = cursor.line - 2;
- }
- int line_ofs_max = text.size() - 1;
- if (!scroll_past_end_of_file_enabled) {
- line_ofs_max -= num_lines_from(text.size() - 1, -visible_rows) - 1;
- line_ofs_max += (h_scroll->is_visible_in_tree() ? 1 : 0);
- line_ofs_max += (cursor.line == text.size() - 1 ? 1 : 0);
- }
- line_ofs_max = MAX(line_ofs_max, 0);
- cursor.line_ofs = CLAMP(cursor.line_ofs, 0, line_ofs_max);
-
- // adjust x offset
- int cursor_x = get_column_x_offset(cursor.column, text[cursor.line]);
-
- if (cursor_x > (cursor.x_ofs + visible_width))
- cursor.x_ofs = cursor_x - visible_width + 1;
+ if (is_wrap_enabled()) {
+ // adjust x offset
+ int cursor_x = get_column_x_offset(cursor.column, text[cursor.line]);
- if (cursor_x < cursor.x_ofs)
- cursor.x_ofs = cursor_x;
+ if (cursor_x > (cursor.x_ofs + visible_width))
+ cursor.x_ofs = cursor_x - visible_width + 1;
- updating_scrolls = true;
- h_scroll->set_value(cursor.x_ofs);
- update_line_scroll_pos();
- double new_v_scroll = get_line_scroll_pos();
- // keep offset if smooth scroll is enabled
- if (smooth_scroll_enabled) {
- new_v_scroll += fmod(v_scroll->get_value(), 1.0);
+ if (cursor_x < cursor.x_ofs)
+ cursor.x_ofs = cursor_x;
+ } else {
+ cursor.x_ofs = 0;
}
- v_scroll->set_value(new_v_scroll);
- updating_scrolls = false;
+ h_scroll->set_value(cursor.x_ofs);
+
update();
}
void TextEdit::center_viewport_to_cursor() {
- scrolling = false;
- if (cursor.line_ofs > cursor.line)
- cursor.line_ofs = cursor.line;
+ // move viewport so the cursor is in the center of the screen
+ scrolling = false;
if (is_line_hidden(cursor.line))
unfold_line(cursor.line);
+ set_line_as_center_visible(cursor.line, get_cursor_wrap_index());
int visible_width = cache.size.width - cache.style_normal->get_minimum_size().width - cache.line_number_w - cache.breakpoint_gutter_width - cache.fold_gutter_width;
if (v_scroll->is_visible_in_tree())
visible_width -= v_scroll->get_combined_minimum_size().width;
visible_width -= 20; // give it a little more space
- int visible_rows = get_visible_rows();
- if (h_scroll->is_visible_in_tree())
- visible_rows -= ((h_scroll->get_combined_minimum_size().height - 1) / get_row_height());
- if (text.size() >= visible_rows) {
- int max_ofs = text.size() - (scroll_past_end_of_file_enabled ? 1 : MAX(num_lines_from(text.size() - 1, -visible_rows), 0));
- cursor.line_ofs = CLAMP(cursor.line - num_lines_from(MAX(cursor.line - visible_rows / 2, 0), -visible_rows / 2), 0, max_ofs);
+ if (is_wrap_enabled()) {
+ // center x offset
+ int cursor_x = get_column_x_offset_for_line(cursor.column, cursor.line);
+
+ if (cursor_x > (cursor.x_ofs + visible_width))
+ cursor.x_ofs = cursor_x - visible_width + 1;
+
+ if (cursor_x < cursor.x_ofs)
+ cursor.x_ofs = cursor_x;
+ } else {
+ cursor.x_ofs = 0;
}
- int cursor_x = get_column_x_offset(cursor.column, text[cursor.line]);
+ h_scroll->set_value(cursor.x_ofs);
- if (cursor_x > (cursor.x_ofs + visible_width))
- cursor.x_ofs = cursor_x - visible_width + 1;
+ update();
+}
- if (cursor_x < cursor.x_ofs)
- cursor.x_ofs = cursor_x;
+void TextEdit::update_cursor_wrap_offset() {
+ int first_vis_line = get_first_visible_line();
+ if (line_wraps(first_vis_line)) {
+ cursor.wrap_ofs = MIN(cursor.wrap_ofs, times_line_wraps(first_vis_line));
+ } else {
+ cursor.wrap_ofs = 0;
+ }
+ set_line_as_first_visible(cursor.line_ofs, cursor.wrap_ofs);
+}
- updating_scrolls = true;
- h_scroll->set_value(cursor.x_ofs);
- update_line_scroll_pos();
- double new_v_scroll = get_line_scroll_pos();
- // keep offset if smooth scroll is enabled
- if (smooth_scroll_enabled) {
- new_v_scroll += fmod(v_scroll->get_value(), 1.0);
+bool TextEdit::line_wraps(int line) const {
+
+ ERR_FAIL_INDEX_V(line, text.size(), 0);
+ if (!is_wrap_enabled())
+ return false;
+ return text.get_line_width(line) > wrap_at;
+}
+
+int TextEdit::times_line_wraps(int line) const {
+
+ ERR_FAIL_INDEX_V(line, text.size(), 0);
+ if (!line_wraps(line))
+ return 0;
+
+ int wrap_amount = text.get_line_wrap_amount(line);
+ if (wrap_amount == -1) {
+ // update the value
+ Vector<String> rows = get_wrap_rows_text(line);
+ wrap_amount = rows.size() - 1;
+ text.set_line_wrap_amount(line, wrap_amount);
}
- v_scroll->set_value(new_v_scroll);
- updating_scrolls = false;
- update();
+
+ return wrap_amount;
+}
+
+Vector<String> TextEdit::get_wrap_rows_text(int p_line) const {
+
+ ERR_FAIL_INDEX_V(p_line, text.size(), Vector<String>());
+
+ Vector<String> lines;
+ if (!line_wraps(p_line)) {
+ lines.push_back(text[p_line]);
+ return lines;
+ }
+
+ int px = 0;
+ int col = 0;
+ String line_text = text[p_line];
+ String wrap_substring = "";
+
+ int word_px = 0;
+ String word_str = "";
+ int cur_wrap_index = 0;
+
+ int tab_offset_px = get_indent_level(p_line) * cache.font->get_char_size(' ').width;
+
+ while (col < line_text.length()) {
+ char c = line_text[col];
+ int w = text.get_char_width(c, line_text[col + 1], px + word_px);
+
+ int indent_ofs = (cur_wrap_index != 0 ? tab_offset_px : 0);
+
+ word_str += c;
+ word_px += w;
+ if (c == ' ') {
+ // end of a word; add this word to the substring
+ wrap_substring += word_str;
+ px += word_px;
+ word_str = "";
+ word_px = 0;
+ }
+
+ if ((indent_ofs + px + word_px) > wrap_at) {
+ // do not want to add this word
+ if (indent_ofs + word_px > wrap_at) {
+ // not enough space; add it anyway
+ wrap_substring += word_str;
+ px += word_px;
+ word_str = "";
+ word_px = 0;
+ }
+ lines.push_back(wrap_substring);
+ // reset for next wrap
+ cur_wrap_index++;
+ wrap_substring = "";
+ px = 0;
+ }
+ col++;
+ }
+ // line ends before hit wrap_at; add this word to the substring
+ wrap_substring += word_str;
+ px += word_px;
+ lines.push_back(wrap_substring);
+ return lines;
+}
+
+int TextEdit::get_cursor_wrap_index() const {
+
+ return get_line_wrap_index_at_col(cursor.line, cursor.column);
+}
+
+int TextEdit::get_line_wrap_index_at_col(int p_line, int p_column) const {
+
+ ERR_FAIL_INDEX_V(p_line, text.size(), 0);
+
+ if (!line_wraps(p_line))
+ return 0;
+
+ // loop through wraps in the line text until we get to the column
+ int wrap_index = 0;
+ int col = 0;
+ Vector<String> rows = get_wrap_rows_text(p_line);
+ for (int i = 0; i < rows.size(); i++) {
+ wrap_index = i;
+ String s = rows[wrap_index];
+ col += s.length();
+ if (col > p_column)
+ break;
+ }
+ return wrap_index;
}
void TextEdit::cursor_set_column(int p_col, bool p_adjust_viewport) {
@@ -3609,7 +3799,7 @@ void TextEdit::cursor_set_column(int p_col, bool p_adjust_viewport) {
if (cursor.column > get_line(cursor.line).length())
cursor.column = get_line(cursor.line).length();
- cursor.last_fit_x = get_column_x_offset(cursor.column, get_line(cursor.line));
+ cursor.last_fit_x = get_column_x_offset_for_line(cursor.column, cursor.line);
if (p_adjust_viewport)
adjust_viewport_to_cursor();
@@ -3621,7 +3811,7 @@ void TextEdit::cursor_set_column(int p_col, bool p_adjust_viewport) {
}
}
-void TextEdit::cursor_set_line(int p_row, bool p_adjust_viewport, bool p_can_be_hidden) {
+void TextEdit::cursor_set_line(int p_row, bool p_adjust_viewport, bool p_can_be_hidden, int p_wrap_index) {
if (setting_row)
return;
@@ -3630,8 +3820,8 @@ void TextEdit::cursor_set_line(int p_row, bool p_adjust_viewport, bool p_can_be_
if (p_row < 0)
p_row = 0;
- if (p_row >= (int)text.size())
- p_row = (int)text.size() - 1;
+ if (p_row >= text.size())
+ p_row = text.size() - 1;
if (!p_can_be_hidden) {
if (is_line_hidden(CLAMP(p_row, 0, text.size() - 1))) {
@@ -3649,7 +3839,18 @@ void TextEdit::cursor_set_line(int p_row, bool p_adjust_viewport, bool p_can_be_
}
}
cursor.line = p_row;
- cursor.column = get_char_pos_for(cursor.last_fit_x, get_line(cursor.line));
+
+ int n_col = get_char_pos_for_line(cursor.last_fit_x, p_row, p_wrap_index);
+ if (is_wrap_enabled() && p_wrap_index < times_line_wraps(p_row)) {
+ Vector<String> rows = get_wrap_rows_text(p_row);
+ int row_end_col = 0;
+ for (int i = 0; i < p_wrap_index + 1; i++) {
+ row_end_col += rows[i].length();
+ }
+ if (n_col >= row_end_col)
+ n_col -= 1;
+ }
+ cursor.column = n_col;
if (p_adjust_viewport)
adjust_viewport_to_cursor();
@@ -3726,9 +3927,25 @@ void TextEdit::_scroll_moved(double p_to_val) {
if (h_scroll->is_visible_in_tree())
cursor.x_ofs = h_scroll->get_value();
if (v_scroll->is_visible_in_tree()) {
- double val = v_scroll->get_value();
- cursor.line_ofs = num_lines_from(0, (int)floor(val));
- line_scroll_pos = (int)floor(val);
+
+ // set line ofs and wrap ofs
+ int v_scroll_i = floor(get_v_scroll());
+ int sc = 0;
+ int n_line;
+ for (n_line = 0; n_line < text.size(); n_line++) {
+ if (!is_line_hidden(n_line)) {
+ sc++;
+ sc += times_line_wraps(n_line);
+ if (sc > v_scroll_i)
+ break;
+ }
+ }
+ int line_wrap_amount = times_line_wraps(n_line);
+ int wi = line_wrap_amount - (sc - v_scroll_i - 1);
+ wi = CLAMP(wi, 0, line_wrap_amount);
+
+ cursor.line_ofs = n_line;
+ cursor.wrap_ofs = wi;
}
update();
}
@@ -3738,29 +3955,73 @@ int TextEdit::get_row_height() const {
return cache.font->get_height() + cache.line_spacing;
}
-int TextEdit::get_char_pos_for(int p_px, String p_str) const {
+int TextEdit::get_char_pos_for_line(int p_px, int p_line, int p_wrap_index) const {
- int px = 0;
- int c = 0;
+ ERR_FAIL_INDEX_V(p_line, text.size(), 0);
- int tab_w = cache.font->get_char_size(' ').width * indent_size;
+ if (line_wraps(p_line)) {
- while (c < p_str.length()) {
+ int line_wrap_amount = times_line_wraps(p_line);
+ int wrap_offset_px = get_indent_level(p_line) * cache.font->get_char_size(' ').width;
+ if (p_wrap_index > line_wrap_amount)
+ p_wrap_index = line_wrap_amount;
+ if (p_wrap_index > 0)
+ p_px -= wrap_offset_px;
+ else
+ p_wrap_index = 0;
+ Vector<String> rows = get_wrap_rows_text(p_line);
+ int c_pos = get_char_pos_for(p_px, rows[p_wrap_index]);
+ for (int i = 0; i < p_wrap_index; i++) {
+ String s = rows[i];
+ c_pos += s.length();
+ }
- int w = 0;
+ return c_pos;
+ } else {
- if (p_str[c] == '\t') {
+ return get_char_pos_for(p_px, text[p_line]);
+ }
+}
- int left = px % tab_w;
- if (left == 0)
- w = tab_w;
- else
- w = tab_w - px % tab_w; // is right...
+int TextEdit::get_column_x_offset_for_line(int p_char, int p_line) const {
- } else {
+ ERR_FAIL_INDEX_V(p_line, text.size(), 0);
- w = cache.font->get_char_size(p_str[c], p_str[c + 1]).width;
+ if (line_wraps(p_line)) {
+
+ int n_char = p_char;
+ int col = 0;
+ Vector<String> rows = get_wrap_rows_text(p_line);
+ int wrap_index = 0;
+ for (int i = 0; i < rows.size(); i++) {
+ wrap_index = i;
+ String s = rows[wrap_index];
+ col += s.length();
+ if (col > p_char)
+ break;
+ n_char -= s.length();
}
+ int px = get_column_x_offset(n_char, rows[wrap_index]);
+
+ int wrap_offset_px = get_indent_level(p_line) * cache.font->get_char_size(' ').width;
+ if (wrap_index != 0)
+ px += wrap_offset_px;
+
+ return px;
+ } else {
+
+ return get_column_x_offset(p_char, text[p_line]);
+ }
+}
+
+int TextEdit::get_char_pos_for(int p_px, String p_str) const {
+
+ int px = 0;
+ int c = 0;
+
+ while (c < p_str.length()) {
+
+ int w = text.get_char_width(p_str[c], p_str[c + 1], px);
if (p_px < (px + w / 2))
break;
@@ -3771,28 +4032,16 @@ int TextEdit::get_char_pos_for(int p_px, String p_str) const {
return c;
}
-int TextEdit::get_column_x_offset(int p_char, String p_str) {
+int TextEdit::get_column_x_offset(int p_char, String p_str) const {
int px = 0;
- int tab_w = cache.font->get_char_size(' ').width * indent_size;
-
for (int i = 0; i < p_char; i++) {
if (i >= p_str.length())
break;
- if (p_str[i] == '\t') {
-
- int left = px % tab_w;
- if (left == 0)
- px += tab_w;
- else
- px += tab_w - px % tab_w; // is right...
-
- } else {
- px += cache.font->get_char_size(p_str[i], p_str[i + 1]).width;
- }
+ px += text.get_char_width(p_str[i], p_str[i + 1], px);
}
return px;
@@ -3868,7 +4117,7 @@ void TextEdit::set_text(String p_text) {
cursor.line = 0;
cursor.x_ofs = 0;
cursor.line_ofs = 0;
- line_scroll_pos = 0;
+ cursor.wrap_ofs = 0;
cursor.last_fit_x = 0;
cursor_set_line(0);
cursor_set_column(0);
@@ -3954,7 +4203,7 @@ void TextEdit::_clear() {
cursor.line = 0;
cursor.x_ofs = 0;
cursor.line_ofs = 0;
- line_scroll_pos = 0;
+ cursor.wrap_ofs = 0;
cursor.last_fit_x = 0;
}
@@ -3976,14 +4225,14 @@ bool TextEdit::is_readonly() const {
return readonly;
}
-void TextEdit::set_wrap(bool p_wrap) {
+void TextEdit::set_wrap_enabled(bool p_wrap_enabled) {
- wrap = p_wrap;
+ wrap_enabled = p_wrap_enabled;
}
-bool TextEdit::is_wrapping() const {
+bool TextEdit::is_wrap_enabled() const {
- return wrap;
+ return wrap_enabled;
}
void TextEdit::set_max_chars(int p_max_chars) {
@@ -4132,7 +4381,7 @@ void TextEdit::clear_colors() {
keywords.clear();
color_regions.clear();
color_region_cache.clear();
- text.clear_caches();
+ text.clear_width_cache();
}
void TextEdit::add_keyword_color(const String &p_keyword, const Color &p_color) {
@@ -4152,7 +4401,7 @@ Color TextEdit::get_keyword_color(String p_keyword) const {
void TextEdit::add_color_region(const String &p_begin_key, const String &p_end_key, const Color &p_color, bool p_line_only) {
color_regions.push_back(ColorRegion(p_begin_key, p_end_key, p_color, p_line_only));
- text.clear_caches();
+ text.clear_width_cache();
update();
}
@@ -4649,52 +4898,99 @@ void TextEdit::unhide_all_lines() {
update();
}
-int TextEdit::num_lines_from(int p_line_from, int unhidden_amount) const {
+int TextEdit::num_lines_from(int p_line_from, int visible_amount) const {
- // returns the number of hidden and unhidden lines from p_line_from to p_line_from + amount of visible lines
- ERR_FAIL_INDEX_V(p_line_from, text.size(), ABS(unhidden_amount));
+ // returns the number of lines (hidden and unhidden) from p_line_from to (p_line_from + visible_amount of unhidden lines)
+ ERR_FAIL_INDEX_V(p_line_from, text.size(), ABS(visible_amount));
if (!is_hiding_enabled())
- return ABS(unhidden_amount);
+ return ABS(visible_amount);
+
int num_visible = 0;
int num_total = 0;
- if (unhidden_amount >= 0) {
+ if (visible_amount >= 0) {
for (int i = p_line_from; i < text.size(); i++) {
num_total++;
- if (!is_line_hidden(i))
+ if (!is_line_hidden(i)) {
num_visible++;
- if (num_visible >= unhidden_amount)
+ }
+ if (num_visible >= visible_amount)
break;
}
} else {
- unhidden_amount = ABS(unhidden_amount);
+ visible_amount = ABS(visible_amount);
for (int i = p_line_from; i >= 0; i--) {
num_total++;
- if (!is_line_hidden(i))
+ if (!is_line_hidden(i)) {
num_visible++;
- if (num_visible >= unhidden_amount)
+ }
+ if (num_visible >= visible_amount)
break;
}
}
return num_total;
}
-bool TextEdit::is_last_visible_line(int p_line) const {
+int TextEdit::num_lines_from_rows(int p_line_from, int p_wrap_index_from, int visible_amount, int &wrap_index) const {
- ERR_FAIL_INDEX_V(p_line, text.size(), false);
+ // returns the number of lines (hidden and unhidden) from (p_line_from + p_wrap_index_from) row to (p_line_from + visible_amount of unhidden and wrapped rows)
+ // wrap index is set to the wrap index of the last line
+ wrap_index = 0;
+ ERR_FAIL_INDEX_V(p_line_from, text.size(), ABS(visible_amount));
- if (p_line == text.size() - 1)
- return true;
+ if (!is_hiding_enabled() && !is_wrap_enabled())
+ return ABS(visible_amount);
+
+ int num_visible = 0;
+ int num_total = 0;
+ if (visible_amount == 0) {
+ num_total = 0;
+ wrap_index = 0;
+ } else if (visible_amount > 0) {
+ int i;
+ num_visible -= p_wrap_index_from;
+ for (i = p_line_from; i < text.size(); i++) {
+ num_total++;
+ if (!is_line_hidden(i)) {
+ num_visible++;
+ num_visible += times_line_wraps(i);
+ }
+ if (num_visible >= visible_amount)
+ break;
+ }
+ wrap_index = times_line_wraps(MIN(i, text.size() - 1)) - (num_visible - visible_amount);
+ } else {
+ visible_amount = ABS(visible_amount);
+ int i;
+ num_visible -= times_line_wraps(p_line_from) - p_wrap_index_from;
+ for (i = p_line_from; i >= 0; i--) {
+ num_total++;
+ if (!is_line_hidden(i)) {
+ num_visible++;
+ num_visible += times_line_wraps(i);
+ }
+ if (num_visible >= visible_amount)
+ break;
+ }
+ wrap_index = (num_visible - visible_amount);
+ }
+ wrap_index = MAX(wrap_index, 0);
+ return num_total;
+}
+
+int TextEdit::get_last_unhidden_line() const {
+ // returns the last line in the text that is not hidden
if (!is_hiding_enabled())
- return false;
+ return text.size() - 1;
- for (int i = p_line + 1; i < text.size(); i++) {
- if (!is_line_hidden(i))
- return false;
+ int last_line;
+ for (last_line = text.size() - 1; last_line > 0; last_line--) {
+ if (!is_line_hidden(last_line)) {
+ break;
+ }
}
-
- return true;
+ return last_line;
}
int TextEdit::get_indent_level(int p_line) const {
@@ -4714,7 +5010,7 @@ int TextEdit::get_indent_level(int p_line) const {
break;
}
}
- return tab_count + whitespace_count / indent_size;
+ return tab_count * indent_size + whitespace_count;
}
bool TextEdit::is_line_comment(int p_line) const {
@@ -5062,6 +5358,7 @@ bool TextEdit::is_drawing_tabs() const {
void TextEdit::set_override_selected_font_color(bool p_override_selected_font_color) {
override_selected_font_color = p_override_selected_font_color;
}
+
bool TextEdit::is_overriding_selected_font_color() const {
return override_selected_font_color;
}
@@ -5082,58 +5379,143 @@ bool TextEdit::is_insert_text_operation() {
uint32_t TextEdit::get_version() const {
return current_op.version;
}
+
uint32_t TextEdit::get_saved_version() const {
return saved_version;
}
+
void TextEdit::tag_saved_version() {
saved_version = get_version();
}
-int TextEdit::get_v_scroll() const {
+double TextEdit::get_scroll_pos_for_line(int p_line, int p_wrap_index) const {
- return v_scroll->get_value();
-}
-void TextEdit::set_v_scroll(int p_scroll) {
+ if (!is_wrap_enabled() && !is_hiding_enabled())
+ return p_line;
- if (p_scroll < 0) {
- p_scroll = 0;
- }
- if (!scroll_past_end_of_file_enabled) {
- if (p_scroll + get_visible_rows() > get_total_unhidden_rows()) {
- int num_rows = num_lines_from(CLAMP(p_scroll, 0, text.size() - 1), MIN(get_visible_rows(), text.size() - 1 - p_scroll));
- p_scroll = text.size() - num_rows;
+ // count the number of visible lines up to this line
+ double new_line_scroll_pos = 0;
+ int to = CLAMP(p_line, 0, text.size() - 1);
+ for (int i = 0; i < to; i++) {
+ if (!text.is_hidden(i)) {
+ new_line_scroll_pos++;
+ new_line_scroll_pos += times_line_wraps(i);
}
}
+ new_line_scroll_pos += p_wrap_index;
+ return new_line_scroll_pos;
+}
+
+void TextEdit::set_line_as_first_visible(int p_line, int p_wrap_index) {
+
+ set_v_scroll(get_scroll_pos_for_line(p_line, p_wrap_index));
+}
+
+void TextEdit::set_line_as_center_visible(int p_line, int p_wrap_index) {
+
+ int visible_rows = get_visible_rows();
+ int wi;
+ int first_line = p_line - num_lines_from_rows(p_line, p_wrap_index, -visible_rows / 2, wi) + 1;
+
+ set_v_scroll(get_scroll_pos_for_line(first_line, wi));
+}
+
+void TextEdit::set_line_as_last_visible(int p_line, int p_wrap_index) {
+
+ int wi;
+ int first_line = p_line - num_lines_from_rows(p_line, p_wrap_index, -get_visible_rows() - 1, wi) + 1;
+
+ set_v_scroll(get_scroll_pos_for_line(first_line, wi) + get_visible_rows_offset());
+}
+
+int TextEdit::get_first_visible_line() const {
+
+ return CLAMP(cursor.line_ofs, 0, text.size() - 1);
+}
+
+int TextEdit::get_last_visible_line() const {
+
+ int first_vis_line = get_first_visible_line();
+ int last_vis_line = 0;
+ int wi;
+ last_vis_line = first_vis_line + num_lines_from_rows(first_vis_line, cursor.wrap_ofs, get_visible_rows() + 1, wi) - 1;
+ last_vis_line = CLAMP(last_vis_line, 0, text.size() - 1);
+ return last_vis_line;
+}
+
+int TextEdit::get_last_visible_line_wrap_index() const {
+
+ int first_vis_line = get_first_visible_line();
+ int last_vis_line = 0;
+ int wi;
+ last_vis_line = first_vis_line + num_lines_from_rows(first_vis_line, cursor.wrap_ofs, get_visible_rows() + 1, wi) - 1;
+ return wi;
+}
+
+double TextEdit::get_visible_rows_offset() const {
+
+ double total = cache.size.height;
+ total -= cache.style_normal->get_minimum_size().height;
+ if (h_scroll->is_visible_in_tree())
+ total -= h_scroll->get_size().height;
+ total /= (double)get_row_height();
+ total = total - floor(total);
+ total = -CLAMP(total, 0.001, 1) + 1;
+ return total;
+}
+
+double TextEdit::get_v_scroll_offset() const {
+
+ double val = get_v_scroll() - floor(get_v_scroll());
+ return CLAMP(val, 0, 1);
+}
+
+double TextEdit::get_v_scroll() const {
+
+ return v_scroll->get_value();
+}
+
+void TextEdit::set_v_scroll(double p_scroll) {
+
v_scroll->set_value(p_scroll);
- cursor.line_ofs = num_lines_from(0, p_scroll);
- line_scroll_pos = p_scroll;
+ int max_v_scroll = v_scroll->get_max() - v_scroll->get_page();
+ if (p_scroll >= max_v_scroll - 1.0)
+ _scroll_moved(v_scroll->get_value());
}
int TextEdit::get_h_scroll() const {
return h_scroll->get_value();
}
+
void TextEdit::set_h_scroll(int p_scroll) {
+ if (p_scroll < 0) {
+ p_scroll = 0;
+ }
h_scroll->set_value(p_scroll);
}
void TextEdit::set_smooth_scroll_enabled(bool p_enable) {
+
v_scroll->set_smooth_scroll_enabled(p_enable);
smooth_scroll_enabled = p_enable;
}
bool TextEdit::is_smooth_scroll_enabled() const {
+
return smooth_scroll_enabled;
}
void TextEdit::set_v_scroll_speed(float p_speed) {
+
v_scroll_speed = p_speed;
}
float TextEdit::get_v_scroll_speed() const {
+
return v_scroll_speed;
}
@@ -5630,8 +6012,8 @@ void TextEdit::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_readonly", "enable"), &TextEdit::set_readonly);
ClassDB::bind_method(D_METHOD("is_readonly"), &TextEdit::is_readonly);
- ClassDB::bind_method(D_METHOD("set_wrap", "enable"), &TextEdit::set_wrap);
- ClassDB::bind_method(D_METHOD("is_wrapping"), &TextEdit::is_wrapping);
+ ClassDB::bind_method(D_METHOD("set_wrap_enabled", "enable"), &TextEdit::set_wrap_enabled);
+ ClassDB::bind_method(D_METHOD("is_wrap_enabled"), &TextEdit::is_wrap_enabled);
// ClassDB::bind_method(D_METHOD("set_max_chars", "amount"), &TextEdit::set_max_chars);
// ClassDB::bind_method(D_METHOD("get_max_char"), &TextEdit::get_max_chars);
ClassDB::bind_method(D_METHOD("set_context_menu_enabled", "enable"), &TextEdit::set_context_menu_enabled);
@@ -5709,7 +6091,7 @@ void TextEdit::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_scrolling"), "set_smooth_scroll_enable", "is_smooth_scroll_enabled");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "v_scroll_speed"), "set_v_scroll_speed", "get_v_scroll_speed");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "hiding_enabled"), "set_hiding_enabled", "is_hiding_enabled");
- ADD_PROPERTY(PropertyInfo(Variant::BOOL, "wrap_lines"), "set_wrap", "is_wrapping");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "wrap_enabled"), "set_wrap_enabled", "is_wrap_enabled");
// ADD_PROPERTY(PropertyInfo(Variant::BOOL, "max_chars"), "set_max_chars", "get_max_chars");
ADD_GROUP("Caret", "caret_");
@@ -5744,7 +6126,8 @@ TextEdit::TextEdit() {
draw_caret = true;
max_chars = 0;
clear();
- wrap = false;
+ wrap_enabled = false;
+ wrap_right_offset = 10;
set_focus_mode(FOCUS_ALL);
syntax_highlighter = NULL;
_update_caches();
diff --git a/scene/gui/text_edit.h b/scene/gui/text_edit.h
index 60c6ab4929..6f4eb01a70 100644
--- a/scene/gui/text_edit.h
+++ b/scene/gui/text_edit.h
@@ -76,6 +76,7 @@ public:
bool marked : 1;
bool breakpoint : 1;
bool hidden : 1;
+ int wrap_amount_cache : 24;
Map<int, ColorRegionInfo> region_info;
String data;
};
@@ -94,6 +95,9 @@ public:
void set_color_regions(const Vector<ColorRegion> *p_regions) { color_regions = p_regions; }
int get_line_width(int p_line) const;
int get_max_width(bool p_exclude_hidden = false) const;
+ int get_char_width(char c, char next_c, int px) const;
+ void set_line_wrap_amount(int p_line, int p_wrap_amount) const;
+ int get_line_wrap_amount(int p_line) const;
const Map<int, ColorRegionInfo> &get_color_region_info(int p_line) const;
void set(int p_line, const String &p_text);
void set_marked(int p_line, bool p_marked) { text[p_line].marked = p_marked; }
@@ -106,7 +110,8 @@ public:
void remove(int p_at);
int size() const { return text.size(); }
void clear();
- void clear_caches();
+ void clear_width_cache();
+ void clear_wrap_cache();
_FORCE_INLINE_ const String &operator[](int p_line) const { return text[p_line].data; }
Text() { indent_size = 4; }
};
@@ -115,7 +120,7 @@ private:
struct Cursor {
int last_fit_x;
int line, column; ///< cursor
- int x_ofs, line_ofs;
+ int x_ofs, line_ofs, wrap_ofs;
} cursor;
struct Selection {
@@ -263,8 +268,11 @@ private:
bool block_caret;
bool right_click_moves_caret;
+ bool wrap_enabled;
+ int wrap_at;
+ int wrap_right_offset;
+
bool setting_row;
- bool wrap;
bool draw_tabs;
bool override_selected_font_color;
bool cursor_changed_dirty;
@@ -321,19 +329,34 @@ private:
int search_result_line;
int search_result_col;
- double line_scroll_pos;
-
bool context_menu_enabled;
int get_visible_rows() const;
- int get_total_unhidden_rows() const;
- double get_line_scroll_pos(bool p_recalculate = false) const;
- void update_line_scroll_pos();
-
+ int get_total_visible_rows() const;
+
+ void update_cursor_wrap_offset();
+ void update_wrap_at();
+ bool line_wraps(int line) const;
+ int times_line_wraps(int line) const;
+ Vector<String> get_wrap_rows_text(int p_line) const;
+ int get_cursor_wrap_index() const;
+ int get_line_wrap_index_at_col(int p_line, int p_column) const;
int get_char_count();
+ double get_scroll_pos_for_line(int p_line, int p_wrap_index = 0) const;
+ void set_line_as_first_visible(int p_line, int p_wrap_index = 0);
+ void set_line_as_center_visible(int p_line, int p_wrap_index = 0);
+ void set_line_as_last_visible(int p_line, int p_wrap_index = 0);
+ int get_first_visible_line() const;
+ int get_last_visible_line() const;
+ int get_last_visible_line_wrap_index() const;
+ double get_visible_rows_offset() const;
+ double get_v_scroll_offset() const;
+
+ int get_char_pos_for_line(int p_px, int p_line, int p_wrap_index = 0) const;
+ int get_column_x_offset_for_line(int p_char, int p_line) const;
int get_char_pos_for(int p_px, String p_str) const;
- int get_column_x_offset(int p_char, String p_str);
+ int get_column_x_offset(int p_char, String p_str) const;
void adjust_viewport_to_cursor();
double get_scroll_line_diff() const;
@@ -455,8 +478,10 @@ public:
bool is_line_hidden(int p_line) const;
void fold_all_lines();
void unhide_all_lines();
- int num_lines_from(int p_line_from, int unhidden_amount) const;
- bool is_last_visible_line(int p_line) const;
+ int num_lines_from(int p_line_from, int visible_amount) const;
+ int num_lines_from_rows(int p_line_from, int p_wrap_index_from, int visible_amount, int &wrap_index) const;
+ int get_last_unhidden_line() const;
+
bool can_fold(int p_line) const;
bool is_folded(int p_line) const;
void fold_line(int p_line);
@@ -493,7 +518,7 @@ public:
void center_viewport_to_cursor();
void cursor_set_column(int p_col, bool p_adjust_viewport = true);
- void cursor_set_line(int p_row, bool p_adjust_viewport = true, bool p_can_be_hidden = true);
+ void cursor_set_line(int p_row, bool p_adjust_viewport = true, bool p_can_be_hidden = true, int p_wrap_index = 0);
int cursor_get_column() const;
int cursor_get_line() const;
@@ -516,8 +541,8 @@ public:
void set_max_chars(int p_max_chars);
int get_max_chars() const;
- void set_wrap(bool p_wrap);
- bool is_wrapping() const;
+ void set_wrap_enabled(bool p_wrap_enabled);
+ bool is_wrap_enabled() const;
void clear();
@@ -578,8 +603,8 @@ public:
Color get_member_color(String p_member) const;
void clear_member_keywords();
- int get_v_scroll() const;
- void set_v_scroll(int p_scroll);
+ double get_v_scroll() const;
+ void set_v_scroll(double p_scroll);
int get_h_scroll() const;
void set_h_scroll(int p_scroll);
diff --git a/scene/main/node.cpp b/scene/main/node.cpp
index e6ea4e4b4a..3643aedb85 100644
--- a/scene/main/node.cpp
+++ b/scene/main/node.cpp
@@ -176,6 +176,9 @@ void Node::_propagate_ready() {
data.children[i]->_propagate_ready();
}
data.blocked--;
+
+ notification(NOTIFICATION_POST_ENTER_TREE);
+
if (data.ready_first) {
data.ready_first = false;
notification(NOTIFICATION_READY);
diff --git a/scene/main/node.h b/scene/main/node.h
index 4ff1247e14..540f34cba7 100644
--- a/scene/main/node.h
+++ b/scene/main/node.h
@@ -237,6 +237,7 @@ public:
NOTIFICATION_TRANSLATION_CHANGED = 24,
NOTIFICATION_INTERNAL_PROCESS = 25,
NOTIFICATION_INTERNAL_PHYSICS_PROCESS = 26,
+ NOTIFICATION_POST_ENTER_TREE = 27,
};
diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp
index 295f131db3..5a3447bec0 100644
--- a/scene/main/viewport.cpp
+++ b/scene/main/viewport.cpp
@@ -1345,7 +1345,7 @@ void Viewport::_gui_show_tooltip() {
gui.tooltip_label->set_anchor_and_margin(MARGIN_RIGHT, Control::ANCHOR_END, -ttp->get_margin(MARGIN_RIGHT));
gui.tooltip_label->set_anchor_and_margin(MARGIN_BOTTOM, Control::ANCHOR_END, -ttp->get_margin(MARGIN_BOTTOM));
gui.tooltip_label->set_text(tooltip.strip_edges());
- Rect2 r(gui.tooltip_pos + Point2(10, 10), gui.tooltip_label->get_combined_minimum_size() + ttp->get_minimum_size());
+ Rect2 r(gui.tooltip_pos + Point2(10, 10), gui.tooltip_label->get_minimum_size() + ttp->get_minimum_size());
Rect2 vr = gui.tooltip_label->get_viewport_rect();
if (r.size.x + r.position.x > vr.size.x)
r.position.x = vr.size.x - r.size.x;
diff --git a/scene/resources/default_theme/default_theme.cpp b/scene/resources/default_theme/default_theme.cpp
index 5ac9344f31..3ea856541e 100644
--- a/scene/resources/default_theme/default_theme.cpp
+++ b/scene/resources/default_theme/default_theme.cpp
@@ -544,6 +544,11 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const
theme->set_icon("updown", "SpinBox", make_icon(spinbox_updown_png));
+ //scroll container
+ Ref<StyleBoxEmpty> empty;
+ empty.instance();
+ theme->set_stylebox("bg", "ScrollContainer", empty);
+
// WindowDialog
theme->set_stylebox("panel", "WindowDialog", sb_expand(make_stylebox(popup_window_png, 10, 26, 10, 8), 8, 24, 8, 6));