editor_inspector.cpp | Explore in Territory

/**************************************************************************/
/*  editor_inspector.cpp                                                  */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "editor_inspector.h"
#include "editor_inspector.compat.inc"

#include "core/os/keyboard.h"
#include "editor/add_metadata_dialog.h"
#include "editor/doc_tools.h"
#include "editor/editor_feature_profile.h"
#include "editor/editor_main_screen.h"
#include "editor/editor_node.h"
#include "editor/editor_property_name_processor.h"
#include "editor/editor_settings.h"
#include "editor/editor_string_names.h"
#include "editor/editor_undo_redo_manager.h"
#include "editor/gui/editor_validation_panel.h"
#include "editor/inspector_dock.h"
#include "editor/multi_node_edit.h"
#include "editor/plugins/script_editor_plugin.h"
#include "editor/themes/editor_scale.h"
#include "editor/themes/editor_theme_manager.h"
#include "scene/gui/margin_container.h"
#include "scene/gui/spin_box.h"
#include "scene/gui/texture_rect.h"
#include "scene/property_utils.h"
#include "scene/resources/packed_scene.h"
#include "scene/resources/style_box_flat.h"
#include "scene/scene_string_names.h"

bool EditorInspector::_property_path_matches(const String &p_property_path, const String &p_filter, EditorPropertyNameProcessor::Style p_style) { … }

Size2 EditorProperty::get_minimum_size() const { … }

void EditorProperty::emit_changed(const StringName &p_property, const Variant &p_value, const StringName &p_field, bool p_changing) { … }

void EditorProperty::_notification(int p_what) { … }

void EditorProperty::set_label(const String &p_label) { … }

String EditorProperty::get_label() const { … }

Object *EditorProperty::get_edited_object() { … }

StringName EditorProperty::get_edited_property() const { … }

EditorInspector *EditorProperty::get_parent_inspector() const { … }

void EditorProperty::set_doc_path(const String &p_doc_path) { … }

void EditorProperty::set_internal(bool p_internal) { … }

void EditorProperty::update_property() { … }

void EditorProperty::_set_read_only(bool p_read_only) { … }

void EditorProperty::set_read_only(bool p_read_only) { … }

bool EditorProperty::is_read_only() const { … }

Variant EditorPropertyRevert::get_property_revert_value(Object *p_object, const StringName &p_property, bool *r_is_valid) { … }

bool EditorPropertyRevert::can_property_revert(Object *p_object, const StringName &p_property, const Variant *p_custom_current_value) { … }

StringName EditorProperty::_get_revert_property() const { … }

void EditorProperty::_update_property_bg() { … }

void EditorProperty::update_editor_property_status() { … }

bool EditorProperty::use_keying_next() const { … }

void EditorProperty::set_checkable(bool p_checkable) { … }

bool EditorProperty::is_checkable() const { … }

void EditorProperty::set_checked(bool p_checked) { … }

bool EditorProperty::is_checked() const { … }

void EditorProperty::set_draw_warning(bool p_draw_warning) { … }

void EditorProperty::set_keying(bool p_keying) { … }

void EditorProperty::set_deletable(bool p_deletable) { … }

bool EditorProperty::is_deletable() const { … }

bool EditorProperty::is_keying() const { … }

bool EditorProperty::is_draw_warning() const { … }

void EditorProperty::_focusable_focused(int p_index) { … }

void EditorProperty::add_focusable(Control *p_control) { … }

void EditorProperty::grab_focus(int p_focusable) { … }

void EditorProperty::select(int p_focusable) { … }

void EditorProperty::deselect() { … }

bool EditorProperty::is_selected() const { … }

void EditorProperty::gui_input(const Ref<InputEvent> &p_event) { … }

void EditorProperty::shortcut_input(const Ref<InputEvent> &p_event) { … }

const Color *EditorProperty::_get_property_colors() { … }

void EditorProperty::set_label_reference(Control *p_control) { … }

void EditorProperty::set_bottom_editor(Control *p_control) { … }

Variant EditorProperty::_get_cache_value(const StringName &p_prop, bool &r_valid) const { … }

bool EditorProperty::is_cache_valid() const { … }
void EditorProperty::update_cache() { … }
Variant EditorProperty::get_drag_data(const Point2 &p_point) { … }

void EditorProperty::set_use_folding(bool p_use_folding) { … }

bool EditorProperty::is_using_folding() const { … }

void EditorProperty::expand_all_folding() { … }

void EditorProperty::collapse_all_folding() { … }

void EditorProperty::expand_revertable() { … }

void EditorProperty::set_selectable(bool p_selectable) { … }

bool EditorProperty::is_selectable() const { … }

void EditorProperty::set_name_split_ratio(float p_ratio) { … }

float EditorProperty::get_name_split_ratio() const { … }

void EditorProperty::set_object_and_property(Object *p_object, const StringName &p_property) { … }

static bool _is_value_potential_override(Node *p_node, const String &p_property) { … }

void EditorProperty::_update_pin_flags() { … }

Control *EditorProperty::make_custom_tooltip(const String &p_text) const { … }

void EditorProperty::menu_option(int p_option) { … }

void EditorProperty::_bind_methods() { … }

EditorProperty::EditorProperty() { … }

void EditorProperty::_update_popup() { … }

////////////////////////////////////////////////
////////////////////////////////////////////////

void EditorInspectorPlugin::add_custom_control(Control *control) { … }

void EditorInspectorPlugin::add_property_editor(const String &p_for_property, Control *p_prop, bool p_add_to_end, const String &p_label) { … }

void EditorInspectorPlugin::add_property_editor_for_multiple_properties(const String &p_label, const Vector<String> &p_properties, Control *p_prop) { … }

bool EditorInspectorPlugin::can_handle(Object *p_object) { … }

void EditorInspectorPlugin::parse_begin(Object *p_object) { … }

void EditorInspectorPlugin::parse_category(Object *p_object, const String &p_category) { … }

void EditorInspectorPlugin::parse_group(Object *p_object, const String &p_group) { … }

bool EditorInspectorPlugin::parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide) { … }

void EditorInspectorPlugin::parse_end(Object *p_object) { … }

void EditorInspectorPlugin::_bind_methods() { … }

////////////////////////////////////////////////
////////////////////////////////////////////////

void EditorInspectorCategory::_notification(int p_what) { … }

Control *EditorInspectorCategory::make_custom_tooltip(const String &p_text) const { … }

Size2 EditorInspectorCategory::get_minimum_size() const { … }

void EditorInspectorCategory::_handle_menu_option(int p_option) { … }

void EditorInspectorCategory::gui_input(const Ref<InputEvent> &p_event) { … }

EditorInspectorCategory::EditorInspectorCategory() { … }

////////////////////////////////////////////////
////////////////////////////////////////////////

void EditorInspectorSection::_test_unfold() { … }

Ref<Texture2D> EditorInspectorSection::_get_arrow() { … }

int EditorInspectorSection::_get_header_height() { … }

void EditorInspectorSection::_notification(int p_what) { … }

Size2 EditorInspectorSection::get_minimum_size() const { … }

void EditorInspectorSection::setup(const String &p_section, const String &p_label, Object *p_object, const Color &p_bg_color, bool p_foldable, int p_indent_depth, int p_level) { … }

void EditorInspectorSection::gui_input(const Ref<InputEvent> &p_event) { … }

VBoxContainer *EditorInspectorSection::get_vbox() { … }

void EditorInspectorSection::unfold() { … }

void EditorInspectorSection::fold() { … }

void EditorInspectorSection::set_bg_color(const Color &p_bg_color) { … }

bool EditorInspectorSection::has_revertable_properties() const { … }

void EditorInspectorSection::property_can_revert_changed(const String &p_path, bool p_can_revert) { … }

void EditorInspectorSection::_bind_methods() { … }

EditorInspectorSection::EditorInspectorSection() { … }

EditorInspectorSection::~EditorInspectorSection() { … }

////////////////////////////////////////////////
////////////////////////////////////////////////

int EditorInspectorArray::_get_array_count() { … }

void EditorInspectorArray::_add_button_pressed() { … }

void EditorInspectorArray::_paginator_page_changed(int p_page) { … }

void EditorInspectorArray::_rmb_popup_id_pressed(int p_id) { … }

void EditorInspectorArray::_control_dropping_draw() { … }

void EditorInspectorArray::_vbox_visibility_changed() { … }

void EditorInspectorArray::_panel_draw(int p_index) { … }

void EditorInspectorArray::_panel_gui_input(Ref<InputEvent> p_event, int p_index) { … }

void EditorInspectorArray::_move_element(int p_element_index, int p_to_pos) { … }

void EditorInspectorArray::_clear_array() { … }

void EditorInspectorArray::_resize_array(int p_size) { … }

Array EditorInspectorArray::_extract_properties_as_array(const List<PropertyInfo> &p_list) { … }

int EditorInspectorArray::_drop_position() const { … }

void EditorInspectorArray::_resize_dialog_confirmed() { … }

void EditorInspectorArray::_new_size_spin_box_value_changed(float p_value) { … }

void EditorInspectorArray::_new_size_spin_box_text_submitted(const String &p_text) { … }

void EditorInspectorArray::_setup() { … }

void EditorInspectorArray::_remove_item(int p_index) { … }

Variant EditorInspectorArray::get_drag_data_fw(const Point2 &p_point, Control *p_from) { … }

void EditorInspectorArray::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) { … }

bool EditorInspectorArray::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const { … }

void EditorInspectorArray::_notification(int p_what) { … }

void EditorInspectorArray::_bind_methods() { … }

void EditorInspectorArray::setup_with_move_element_function(Object *p_object, const String &p_label, const StringName &p_array_element_prefix, int p_page, const Color &p_bg_color, bool p_foldable, bool p_movable, bool p_numbered, int p_page_length, const String &p_add_item_text) { … }

void EditorInspectorArray::setup_with_count_property(Object *p_object, const String &p_label, const StringName &p_count_property, const StringName &p_array_element_prefix, int p_page, const Color &p_bg_color, bool p_foldable, bool p_movable, bool p_numbered, int p_page_length, const String &p_add_item_text, const String &p_swap_method) { … }

VBoxContainer *EditorInspectorArray::get_vbox(int p_index) { … }

EditorInspectorArray::EditorInspectorArray(bool p_read_only) { … }

////////////////////////////////////////////////
////////////////////////////////////////////////

void EditorPaginator::_first_page_button_pressed() { … }

void EditorPaginator::_prev_page_button_pressed() { … }

void EditorPaginator::_page_line_edit_text_submitted(const String &p_text) { … }

void EditorPaginator::_next_page_button_pressed() { … }

void EditorPaginator::_last_page_button_pressed() { … }

void EditorPaginator::update(int p_page, int p_max_page) { … }

void EditorPaginator::_notification(int p_what) { … }

void EditorPaginator::_bind_methods() { … }

EditorPaginator::EditorPaginator() { … }

////////////////////////////////////////////////
////////////////////////////////////////////////

Ref<EditorInspectorPlugin> EditorInspector::inspector_plugins[MAX_PLUGINS];
int EditorInspector::inspector_plugin_count = …;

EditorProperty *EditorInspector::instantiate_property_editor(Object *p_object, const Variant::Type p_type, const String &p_path, PropertyHint p_hint, const String &p_hint_text, const uint32_t p_usage, const bool p_wide) { … }

void EditorInspector::add_inspector_plugin(const Ref<EditorInspectorPlugin> &p_plugin) { … }

void EditorInspector::remove_inspector_plugin(const Ref<EditorInspectorPlugin> &p_plugin) { … }

void EditorInspector::cleanup_plugins() { … }

Button *EditorInspector::create_inspector_action_button(const String &p_text) { … }

bool EditorInspector::is_main_editor_inspector() const { … }

String EditorInspector::get_selected_path() const { … }

void EditorInspector::_parse_added_editors(VBoxContainer *current_vbox, EditorInspectorSection *p_section, Ref<EditorInspectorPlugin> ped) { … }

bool EditorInspector::_is_property_disabled_by_feature_profile(const StringName &p_property) { … }

void EditorInspector::update_tree() { … }

void EditorInspector::update_property(const String &p_prop) { … }

void EditorInspector::_clear(bool p_hide_plugins) { … }

Object *EditorInspector::get_edited_object() { … }

Object *EditorInspector::get_next_edited_object() { … }

void EditorInspector::edit(Object *p_object) { … }

void EditorInspector::set_keying(bool p_active) { … }

void EditorInspector::_keying_changed() { … }

void EditorInspector::set_read_only(bool p_read_only) { … }

EditorPropertyNameProcessor::Style EditorInspector::get_property_name_style() const { … }

void EditorInspector::set_property_name_style(EditorPropertyNameProcessor::Style p_style) { … }

void EditorInspector::set_use_settings_name_style(bool p_enable) { … }

void EditorInspector::set_autoclear(bool p_enable) { … }

void EditorInspector::set_show_categories(bool p_show_standard, bool p_show_custom) { … }

void EditorInspector::set_use_doc_hints(bool p_enable) { … }

void EditorInspector::set_hide_script(bool p_hide) { … }

void EditorInspector::set_hide_metadata(bool p_hide) { … }

void EditorInspector::set_use_filter(bool p_use) { … }

void EditorInspector::register_text_enter(Node *p_line_edit) { … }

void EditorInspector::_filter_changed(const String &p_text) { … }

void EditorInspector::set_use_folding(bool p_use_folding, bool p_update_tree) { … }

bool EditorInspector::is_using_folding() { … }

void EditorInspector::collapse_all_folding() { … }

void EditorInspector::expand_all_folding() { … }

void EditorInspector::expand_revertable() { … }

void EditorInspector::set_scroll_offset(int p_offset) { … }

int EditorInspector::get_scroll_offset() const { … }

void EditorInspector::set_use_wide_editors(bool p_enable) { … }

void EditorInspector::set_root_inspector(EditorInspector *p_root_inspector) { … }

void EditorInspector::set_use_deletable_properties(bool p_enabled) { … }

void EditorInspector::_page_change_request(int p_new_page, const StringName &p_array_prefix) { … }

void EditorInspector::_edit_request_change(Object *p_object, const String &p_property) { … }

void EditorInspector::_edit_set(const String &p_name, const Variant &p_value, bool p_refresh_all, const String &p_changed_field) { … }

void EditorInspector::_property_changed(const String &p_path, const Variant &p_value, const String &p_name, bool p_changing, bool p_update_all) { … }

void EditorInspector::_multiple_properties_changed(const Vector<String> &p_paths, const Array &p_values, bool p_changing) { … }

void EditorInspector::_property_keyed(const String &p_path, bool p_advance) { … }

void EditorInspector::_property_deleted(const String &p_path) { … }

void EditorInspector::_property_keyed_with_value(const String &p_path, const Variant &p_value, bool p_advance) { … }

void EditorInspector::_property_checked(const String &p_path, bool p_checked) { … }

void EditorInspector::_property_pinned(const String &p_path, bool p_pinned) { … }

void EditorInspector::_property_selected(const String &p_path, int p_focusable) { … }

void EditorInspector::_object_id_selected(const String &p_path, ObjectID p_id) { … }

void EditorInspector::_resource_selected(const String &p_path, Ref<Resource> p_resource) { … }

void EditorInspector::_node_removed(Node *p_node) { … }

void EditorInspector::_notification(int p_what) { … }

void EditorInspector::_changed_callback() { … }

void EditorInspector::_vscroll_changed(double p_offset) { … }

void EditorInspector::set_property_prefix(const String &p_prefix) { … }

String EditorInspector::get_property_prefix() const { … }

void EditorInspector::add_custom_property_description(const String &p_class, const String &p_property, const String &p_description) { … }

String EditorInspector::get_custom_property_description(const String &p_property) const { … }

void EditorInspector::set_object_class(const String &p_class) { … }

String EditorInspector::get_object_class() const { … }

void EditorInspector::_feature_profile_changed() { … }

void EditorInspector::set_restrict_to_basic_settings(bool p_restrict) { … }

void EditorInspector::set_property_clipboard(const Variant &p_value) { … }

Variant EditorInspector::get_property_clipboard() const { … }

void EditorInspector::_show_add_meta_dialog() { … }

void EditorInspector::_add_meta_confirm() { … }

void EditorInspector::_bind_methods() { … }

EditorInspector::EditorInspector() { … }
godot/editor/editor_inspector.cpp
