+ Vector<StringName> valid_types;

+ switch (adding_track_type) {

+ case Animation::TYPE_BLEND_SHAPE: {

+ // Blend Shape is a property of MeshInstance3D.

+ valid_types.push_back(SNAME("MeshInstance3D"));

+ } break;

+ case Animation::TYPE_POSITION_3D:

+ case Animation::TYPE_ROTATION_3D:

+ case Animation::TYPE_SCALE_3D: {

+ // 3D Properties come from nodes inheriting Node3D.

+ valid_types.push_back(SNAME("Node3D"));

+ } break;

+ case Animation::TYPE_AUDIO: {

+ valid_types.push_back(SNAME("AudioStreamPlayer"));

+ valid_types.push_back(SNAME("AudioStreamPlayer2D"));

+ valid_types.push_back(SNAME("AudioStreamPlayer3D"));

+ } break;

+ case Animation::TYPE_ANIMATION: {

+ valid_types.push_back(SNAME("AnimationPlayer"));

+ } break;

+ }

+ pick_track->set_valid_types(valid_types);

+ Array quit_keys = DebuggerMarshalls::serialize_key_shortcut(ED_GET_SHORTCUT("editor/stop_running_project"));

+ _put_msg("scene:setup_scene", quit_keys);

+

+void ScriptEditorDebugger::_resources_reimported(const PackedStringArray &p_resources) {

+ Array msg;

+ msg.push_back(p_resources);

+ _put_msg("scene:reload_cached_files", msg);

+}

+

+ EditorFileSystem::get_singleton()->connect("resources_reimported", callable_mp(this, &ScriptEditorDebugger::_resources_reimported));

+ void _resources_reimported(const PackedStringArray &p_resources);

+

+ Color solo_color_darkened = solo_color.darkened(darkening_factor);

+ Color mute_color_darkened = mute_color.darkened(darkening_factor);

+ Color bypass_color_darkened = bypass_color.darkened(darkening_factor);

+ Ref<StyleBoxFlat>(solo->get_theme_stylebox(SceneStringName(pressed)))->set_border_color(solo_color_darkened);

+ Ref<StyleBoxFlat>(mute->get_theme_stylebox(SceneStringName(pressed)))->set_border_color(mute_color_darkened);

+ Ref<StyleBoxFlat>(bypass->get_theme_stylebox(SceneStringName(pressed)))->set_border_color(bypass_color_darkened);

+ Ref<StyleBoxFlat>(solo->get_theme_stylebox("hover_pressed"))->set_border_color(solo_color_darkened);

+ Ref<StyleBoxFlat>(mute->get_theme_stylebox("hover_pressed"))->set_border_color(mute_color_darkened);

+ Ref<StyleBoxFlat>(bypass->get_theme_stylebox("hover_pressed"))->set_border_color(bypass_color_darkened);

+ solo->add_theme_color_override("icon_hover_pressed_color", solo_color_darkened);

+ mute->add_theme_color_override("icon_hover_pressed_color", mute_color_darkened);

+ bypass->add_theme_color_override("icon_hover_pressed_color", bypass_color_darkened);

+ child->add_theme_style_override("hover_mirrored", sbempty);

+ child->add_theme_style_override("focus_mirrored", sbempty);

+ child->add_theme_style_override("pressed_mirrored", sbflat);

+ child->add_theme_style_override("hover_pressed", sbflat);

+ child->add_theme_style_override("hover_pressed_mirrored", sbflat);

+ TTRC("Game View"),

+ TTRC("Provides tools for selecting and debugging nodes at runtime."),

+ "game",

+void EditorProperty::set_favoritable(bool p_favoritable) {

+ can_favorite = p_favoritable;

+}

+

+bool EditorProperty::is_favoritable() const {

+ return can_favorite;

+}

+

+

+ _update_flags();

+void EditorProperty::_update_flags() {

+

+

+ case MENU_FAVORITE_PROPERTY: {

+ emit_signal(SNAME("property_favorited"), property, !favorited);

+ queue_redraw();

+ } break;

+ ADD_SIGNAL(MethodInfo("property_favorited", PropertyInfo(Variant::STRING_NAME, "property"), PropertyInfo(Variant::BOOL, "favorited")));

+ if (can_favorite || !pin_hidden) {

+ }

+

+ if (can_favorite) {

+ if (favorited) {

+ menu->add_icon_item(get_editor_theme_icon(SNAME("Unfavorite")), TTR("Unfavorite Property"), MENU_FAVORITE_PROPERTY);

+ menu->set_item_tooltip(menu->get_item_index(MENU_FAVORITE_PROPERTY), TTR("Make this property be put back at its original place."));

+ } else {

+ menu->add_icon_item(get_editor_theme_icon(SNAME("Favorites")), TTR("Favorite Property"), MENU_FAVORITE_PROPERTY);

+ menu->set_item_tooltip(menu->get_item_index(MENU_FAVORITE_PROPERTY), TTR("Make this property be placed at the top for all objects of this class."));

+ }

+ }

+

+ if (!pin_hidden) {

+ if (menu) {

+ if (is_favorite) {

+ menu->set_item_icon(menu->get_item_index(EditorInspector::MENU_UNFAVORITE_ALL), get_editor_theme_icon(SNAME("Unfavorite")));

+ } else {

+ menu->set_item_icon(menu->get_item_index(MENU_OPEN_DOCS), get_editor_theme_icon(SNAME("Help")));

+ }

+ }

+void EditorInspectorCategory::set_as_favorite(EditorInspector *p_for_inspector) {

+ is_favorite = true;

+

+ menu = memnew(PopupMenu);

+ menu->add_item(TTR("Unfavorite All"), EditorInspector::MENU_UNFAVORITE_ALL);

+ add_child(menu);

+ menu->connect(SceneStringName(id_pressed), callable_mp(p_for_inspector, &EditorInspector::_handle_menu_option));

+}

+

+ if (!is_favorite && doc_class_name.is_empty()) {

+ if (!is_favorite) {

+ if (!menu) {

+ menu = memnew(PopupMenu);

+ menu->add_icon_item(get_editor_theme_icon(SNAME("Help")), TTR("Open Documentation"), MENU_OPEN_DOCS);

+ add_child(menu);

+ menu->connect(SceneStringName(id_pressed), callable_mp(this, &EditorInspectorCategory::_handle_menu_option));

+ }

+ menu->set_item_disabled(menu->get_item_index(MENU_OPEN_DOCS), !EditorHelp::get_doc_data()->class_list.has(doc_class_name));

+ }

+String EditorInspectorSection::get_section() const {

+ return section;

+}

+

+

+ if (ep && current_favorites.has(F.properties[0])) {

+ ep->favorited = true;

+ favorites_vbox->add_child(F.property_editor);

+ } else {

+ current_vbox->add_child(F.property_editor);

+ }

+ ep->connect("property_favorited", callable_mp(this, &EditorInspector::_set_property_favorited), CONNECT_DEFERRED);

+ ep->_update_flags();

+ bool disable_favorite = false;

+ HashMap<String, HashMap<String, LocalVector<EditorProperty *>>> favorites_to_add;

+ _parse_added_editors(begin_vbox, nullptr, ped);

+ }

+ if (begin_vbox->get_child_count()) {

+ begin_vbox->show();

+ disable_favorite = false;

+

+ // Property favorites aren't compatible with built-in scripts.

+ if (scr->is_built_in()) {

+ disable_favorite = true;

+ }

+ // Don't allow to favorite array items.

+ if (!disable_favorite) {

+ disable_favorite = !array_prefix.is_empty();

+ }

+

+ ep->set_favoritable(can_favorite && !disable_favorite);

+ if (ep && ep->is_favoritable() && current_favorites.has(p.name)) {

+ ep->favorited = true;

+ favorites_to_add[group][subgroup].push_back(ep);

+ } else {

+ current_vbox->add_child(editors[i].property_editor);

+ }

+ ep->connect("property_favorited", callable_mp(this, &EditorInspector::_set_property_favorited), CONNECT_DEFERRED);

+ ep->_update_flags();

+ if (!current_favorites.is_empty()) {

+ favorites_section->show();

+

+ // Organize the favorited properties in their sections, to keep context and differentiate from others with the same name.

+ bool is_localized = property_name_style == EditorPropertyNameProcessor::STYLE_LOCALIZED;

+ for (const KeyValue<String, HashMap<String, LocalVector<EditorProperty *>>> &KV : favorites_to_add) {

+ String section_name = KV.key;

+ String label;

+ String tooltip;

+ VBoxContainer *parent_vbox = favorites_vbox;

+ if (!section_name.is_empty()) {

+ if (is_localized) {

+ label = EditorPropertyNameProcessor::get_singleton()->translate_group_name(section_name);

+ tooltip = section_name;

+ } else {

+ label = section_name;

+ tooltip = EditorPropertyNameProcessor::get_singleton()->translate_group_name(section_name);

+ }

+

+ EditorInspectorSection *section = memnew(EditorInspectorSection);

+ favorites_groups_vbox->add_child(section);

+ parent_vbox = section->get_vbox();

+ section->setup("", section_name, object, sscolor, false);

+ section->set_tooltip_text(tooltip);

+ }

+

+ for (const KeyValue<String, LocalVector<EditorProperty *>> &KV2 : KV.value) {

+ section_name = KV2.key;

+ VBoxContainer *vbox = parent_vbox;

+ if (!section_name.is_empty()) {

+ if (is_localized) {

+ label = EditorPropertyNameProcessor::get_singleton()->translate_group_name(section_name);

+ tooltip = section_name;

+ } else {

+ label = section_name;

+ tooltip = EditorPropertyNameProcessor::get_singleton()->translate_group_name(section_name);

+ }

+

+ EditorInspectorSection *section = memnew(EditorInspectorSection);

+ vbox->add_child(section);

+ vbox = section->get_vbox();

+ section->setup("", section_name, object, sscolor, false);

+ section->set_tooltip_text(tooltip);

+ }

+

+ for (EditorProperty *ep : KV2.value) {

+ vbox->add_child(ep);

+ }

+ }

+ }

+

+ // Show a separator if there's no category to clearly divide the properties.

+ favorites_separator->hide();

+ if (main_vbox->get_child_count() > 0) {

+ EditorInspectorCategory *category = Object::cast_to<EditorInspectorCategory>(main_vbox->get_child(0));

+ if (!category) {

+ favorites_separator->show();

+ }

+ }

+

+ // Clean up empty sections.

+ for (List<EditorInspectorSection *>::Element *I = sections.back(); I; I = I->prev()) {

+ EditorInspectorSection *section = I->get();

+ if (section->get_vbox()->get_child_count() == 0) {

+ I = I->prev();

+

+ sections.erase(section);

+ vbox_per_path[main_vbox].erase(section->get_section());

+ memdelete(section);

+ }

+ }

+ }

+

+ begin_vbox->hide();

+ while (begin_vbox->get_child_count()) {

+ memdelete(begin_vbox->get_child(0));

+ }

+

+ favorites_section->hide();

+ while (favorites_vbox->get_child_count()) {

+ memdelete(favorites_vbox->get_child(0));

+ }

+ while (favorites_groups_vbox->get_child_count()) {

+ memdelete(favorites_groups_vbox->get_child(0));

+ }

+

+

+ can_favorite = Object::cast_to<Node>(object) || Object::cast_to<Resource>(object);

+ _update_current_favorites();

+

+void EditorInspector::_update_current_favorites() {

+ current_favorites.clear();

+ if (!can_favorite) {

+ return;

+ }

+

+ HashMap<String, PackedStringArray> favorites = EditorSettings::get_singleton()->get_favorite_properties();

+

+ // Fetch script properties.

+ Ref<Script> scr = object->get_script();

+ if (scr.is_valid()) {

+ List<PropertyInfo> plist;

+ // FIXME: Only properties from a saved script will be available, unsaved ones will be ignored.

+ // Can cause a little wonkiness, while nothing serious, would be nice to find a way to get

+ // unsaved ones without needing to get the entire property list of an object.

+ scr->get_script_property_list(&plist);

+

+ String path;

+ HashMap<String, LocalVector<String>> props;

+

+ for (PropertyInfo &p : plist) {

+ if (p.usage & PROPERTY_USAGE_CATEGORY) {

+ path = favorites.has(p.hint_string) ? p.hint_string : String();

+ } else if (p.usage & PROPERTY_USAGE_SCRIPT_VARIABLE && !path.is_empty()) {

+ props[path].push_back(p.name);

+ }

+ }

+

+ // Add favorited properties while removing invalid ones.

+ bool invalid_props = false;

+ for (const KeyValue<String, LocalVector<String>> &KV : props) {

+ path = KV.key;

+ for (int i = 0; i < favorites[path].size(); i++) {

+ String prop = favorites[path][i];

+ if (KV.value.has(prop)) {

+ current_favorites.append(prop);

+ } else {

+ invalid_props = true;

+ favorites[path].erase(prop);

+ i--;

+ }

+ }

+

+ if (favorites[path].is_empty()) {

+ favorites.erase(path);

+ }

+ }

+

+ if (invalid_props) {

+ EditorSettings::get_singleton()->set_favorite_properties(favorites);

+ }

+ }

+

+ // Fetch built-in properties.

+ StringName class_name = object->get_class_name();

+ for (const KeyValue<String, PackedStringArray> &KV : favorites) {

+ if (ClassDB::is_parent_class(class_name, KV.key)) {

+ current_favorites.append_array(KV.value);

+ }

+ }

+}

+

+void EditorInspector::_set_property_favorited(const String &p_path, bool p_favorited) {

+ if (!object) {

+ return;

+ }

+

+ StringName class_name = object->get_class_name();

+ while (!class_name.is_empty()) {

+ bool has_prop = ClassDB::has_property(class_name, p_path, true);

+ if (has_prop) {

+ break;

+ }

+

+ class_name = ClassDB::get_parent_class_nocheck(class_name);

+ }

+

+ if (class_name.is_empty()) {

+ Ref<Script> scr = object->get_script();

+ if (scr.is_valid()) {

+ List<PropertyInfo> plist;

+ scr->get_script_property_list(&plist);

+

+ String path;

+ for (PropertyInfo &p : plist) {

+ if (p.usage & PROPERTY_USAGE_CATEGORY) {

+ path = p.hint_string;

+ } else if (p.usage & PROPERTY_USAGE_SCRIPT_VARIABLE && p.name == p_path) {

+ class_name = path;

+ break;

+ }

+ }

+ }

+

+ ERR_FAIL_COND_MSG(class_name.is_empty(), "Can't favorite invalid property. If said property was from a script and recently renamed, try saving it first.");

+ }

+

+ HashMap<String, PackedStringArray> favorites = EditorSettings::get_singleton()->get_favorite_properties();

+ if (p_favorited) {

+ current_favorites.append(p_path);

+ favorites[class_name].append(p_path);

+ } else {

+ current_favorites.erase(p_path);

+

+ if (favorites.has(class_name) && favorites[class_name].has(p_path)) {

+ if (favorites[class_name].size() > 1) {

+ favorites[class_name].erase(p_path);

+ } else {

+ favorites.erase(class_name);

+ }

+ }

+ }

+ EditorSettings::get_singleton()->set_favorite_properties(favorites);

+

+ update_tree();

+}

+

+void EditorInspector::_clear_current_favorites() {

+ current_favorites.clear();

+

+ HashMap<String, PackedStringArray> favorites = EditorSettings::get_singleton()->get_favorite_properties();

+

+ Ref<Script> scr = object->get_script();

+ if (scr.is_valid()) {

+ List<PropertyInfo> plist;

+ scr->get_script_property_list(&plist);

+

+ for (PropertyInfo &p : plist) {

+ if (p.usage & PROPERTY_USAGE_CATEGORY && favorites.has(p.hint_string)) {

+ favorites.erase(p.hint_string);

+ }

+ }

+ }

+

+ StringName class_name = object->get_class_name();

+ while (class_name) {

+ if (favorites.has(class_name)) {

+ favorites.erase(class_name);

+ }

+

+ class_name = ClassDB::get_parent_class(class_name);

+ }

+

+ EditorSettings::get_singleton()->set_favorite_properties(favorites);

+ update_tree();

+}

+

+ favorites_category->icon = get_editor_theme_icon(SNAME("Favorites"));

+

+ int separation = get_theme_constant(SNAME("v_separation"), SNAME("EditorInspector"));

+ base_vbox->add_theme_constant_override("separation", separation);

+ begin_vbox->add_theme_constant_override("separation", separation);

+ favorites_section->add_theme_constant_override("separation", separation);

+ favorites_groups_vbox->add_theme_constant_override("separation", separation);

+ main_vbox->add_theme_constant_override("separation", separation);

+ _update_current_favorites();

+void EditorInspector::_handle_menu_option(int p_option) {

+ switch (p_option) {

+ case MENU_UNFAVORITE_ALL:

+ _clear_current_favorites();

+ break;

+ }

+}

+

+

+ base_vbox = memnew(VBoxContainer);

+ base_vbox->set_h_size_flags(SIZE_EXPAND_FILL);

+ add_child(base_vbox);

+

+ begin_vbox = memnew(VBoxContainer);

+ base_vbox->add_child(begin_vbox);

+ begin_vbox->hide();

+

+ favorites_section = memnew(VBoxContainer);

+ base_vbox->add_child(favorites_section);

+ favorites_section->hide();

+

+ favorites_category = memnew(EditorInspectorCategory);

+ favorites_category->set_as_favorite(this);

+ favorites_section->add_child(favorites_category);

+ favorites_category->label = TTR("Favorites");

+

+ favorites_vbox = memnew(VBoxContainer);

+ favorites_section->add_child(favorites_vbox);

+ favorites_groups_vbox = memnew(VBoxContainer);

+ favorites_section->add_child(favorites_groups_vbox);

+

+ favorites_separator = memnew(HSeparator);

+ favorites_section->add_child(favorites_separator);

+ favorites_separator->hide();

+

+ base_vbox->add_child(main_vbox);

+

+class HSeparator;

+ MENU_FAVORITE_PROPERTY,

+ bool can_favorite = false;

+ bool favorited = false;

+

+ void _update_flags();

+ void set_favoritable(bool p_favoritable);

+ bool is_favoritable() const;

+

+ bool is_favorite = false;

+ void set_as_favorite(EditorInspector *p_for_inspector);

+

+ String get_section() const;

+ friend class EditorInspectorCategory;

+

+ // Right-click context menu options.

+ enum ClassMenuOption {

+ MENU_UNFAVORITE_ALL,

+ };

+

+ bool can_favorite = false;

+ PackedStringArray current_favorites;

+ VBoxContainer *favorites_section = nullptr;

+ EditorInspectorCategory *favorites_category = nullptr;

+ VBoxContainer *favorites_vbox = nullptr;

+ VBoxContainer *favorites_groups_vbox = nullptr;

+ HSeparator *favorites_separator = nullptr;

+

+

+ VBoxContainer *base_vbox = nullptr;

+ VBoxContainer *begin_vbox = nullptr;

+ void _update_current_favorites();

+ void _set_property_favorited(const String &p_path, bool p_favorited);

+ void _clear_current_favorites();

+

+ void _handle_menu_option(int p_option);

+

+ EDITOR_SETTING_USAGE(Variant::INT, PROPERTY_HINT_RANGE, "filesystem/quick_open_dialog/max_results", 100, "0,10000,1", PROPERTY_USAGE_DEFAULT)

+ _initial_set("filesystem/quick_open_dialog/show_search_highlight", true);

+ _initial_set("filesystem/quick_open_dialog/enable_fuzzy_matching", true);

+ EDITOR_SETTING_USAGE(Variant::INT, PROPERTY_HINT_RANGE, "filesystem/quick_open_dialog/max_fuzzy_misses", 2, "0,10,1", PROPERTY_USAGE_DEFAULT)

+void EditorSettings::set_favorite_properties(const HashMap<String, PackedStringArray> &p_favorite_properties) {

+ favorite_properties = p_favorite_properties;

+ String favorite_properties_file = EditorPaths::get_singleton()->get_project_settings_dir().path_join("favorite_properties");

+

+ Ref<ConfigFile> cf;

+ cf.instantiate();

+ for (const KeyValue<String, PackedStringArray> &kv : p_favorite_properties) {

+ cf->set_value(kv.key, "properties", kv.value);

+ }

+ cf->save(favorite_properties_file);

+}

+

+HashMap<String, PackedStringArray> EditorSettings::get_favorite_properties() const {

+ return favorite_properties;

+}

+

+ String favorite_properties_file;

+ favorite_properties_file = EditorPaths::get_singleton()->get_config_dir().path_join("favorite_properties");

+ favorite_properties_file = EditorPaths::get_singleton()->get_project_settings_dir().path_join("favorite_properties");

+

+ /// File Favorites

+

+ favorites.append(line);

+ /// Inspector Favorites

+

+ Ref<ConfigFile> cf;

+ cf.instantiate();

+ if (cf->load(favorite_properties_file) == OK) {

+ List<String> secs;

+ cf->get_sections(&secs);

+

+ for (String &E : secs) {

+ PackedStringArray properties = PackedStringArray(cf->get_value(E, "properties"));

+ if (EditorNode::get_editor_data().is_type_recognized(E) || ResourceLoader::exists(E, "Script")) {

+ for (const String &property : properties) {

+ if (!favorite_properties[E].has(property)) {

+ favorite_properties[E].push_back(property);

+ }

+ }

+ }

+ }

+ }

+

+ /// Recent Directories

+

+ HashMap<String, PackedStringArray> favorite_properties;

+ void set_favorite_properties(const HashMap<String, PackedStringArray> &p_favorite_properties);

+ HashMap<String, PackedStringArray> get_favorite_properties() const;

+void FileSystemDock::_update_favorites_after_move(const HashMap<String, String> &p_files_renames, const HashMap<String, String> &p_folders_renames) const {

+ Vector<String> favorite_files = EditorSettings::get_singleton()->get_favorites();

+ Vector<String> new_favorite_files;

+ for (const String &old_path : favorite_files) {

+ new_favorite_files.push_back(p_folders_renames[old_path]);

+ new_favorite_files.push_back(p_files_renames[old_path]);

+ new_favorite_files.push_back(old_path);

+ EditorSettings::get_singleton()->set_favorites(new_favorite_files);

+ HashMap<String, PackedStringArray> favorite_properties = EditorSettings::get_singleton()->get_favorite_properties();

+ for (const KeyValue<String, String> &KV : p_files_renames) {

+ if (favorite_properties.has(KV.key)) {

+ favorite_properties.replace_key(KV.key, KV.value);

+ }

+ }

+ EditorSettings::get_singleton()->set_favorite_properties(favorite_properties);

+ _update_favorites_after_move(file_renames, folder_renames);

+ _update_favorites_after_move(file_renames, folder_renames);

+ void _update_favorites_after_move(const HashMap<String, String> &p_files_renames, const HashMap<String, String> &p_folders_renames) const;

+#include "scene/gui/split_container.h"

+ pin_button->set_button_icon(get_editor_theme_icon(SNAME("Pin")));

+void EditorBottomPanel::_switch_by_control(bool p_visible, Control *p_control, bool p_ignore_lock) {

+ _switch_to_item(p_visible, i, p_ignore_lock);

+void EditorBottomPanel::_switch_to_item(bool p_visible, int p_idx, bool p_ignore_lock) {

+ if (!p_ignore_lock && lock_panel_switching && pin_button->is_visible()) {

+ return;

+ }

+

+

+ pin_button->show();

+

+ expand_button->show();

+ pin_button->hide();

+

+void EditorBottomPanel::_pin_button_toggled(bool p_pressed) {

+ lock_panel_switching = p_pressed;

+}

+

+ _switch_by_control(true, p_control, true);

+ tb->connect(SceneStringName(toggled), callable_mp(this, &EditorBottomPanel::_switch_by_control).bind(p_item, true));

+ _switch_by_control(!last_opened_control->is_visible(), last_opened_control, true);

+ _switch_to_item(true, 0, true);

+ pin_button = memnew(Button);

+ bottom_hbox->add_child(pin_button);

+ pin_button->hide();

+ pin_button->set_theme_type_variation("FlatMenuButton");

+ pin_button->set_toggle_mode(true);

+ pin_button->set_tooltip_text(TTR("Pin Bottom Panel Switching"));

+ pin_button->connect(SceneStringName(toggled), callable_mp(this, &EditorBottomPanel::_pin_button_toggled));

+

+ bool lock_panel_switching = false;

+ Button *pin_button = nullptr;

+ void _switch_by_control(bool p_visible, Control *p_control, bool p_ignore_lock = false);

+ void _switch_to_item(bool p_visible, int p_idx, bool p_ignore_lock = false);

+ void _pin_button_toggled(bool p_pressed);

+#include "core/string/fuzzy_search.h"

+void HighlightedLabel::draw_substr_rects(const Vector2i &p_substr, Vector2 p_offset, int p_line_limit, int line_spacing) {

+ for (int i = get_lines_skipped(); i < p_line_limit; i++) {

+ RID line = get_line_rid(i);

+ Vector<Vector2> ranges = TS->shaped_text_get_selection(line, p_substr.x, p_substr.x + p_substr.y);

+ Rect2 line_rect = get_line_rect(i);

+ for (const Vector2 &range : ranges) {

+ Rect2 rect = Rect2(Point2(range.x, 0) + line_rect.position, Size2(range.y - range.x, line_rect.size.y));

+ rect.position = p_offset + line_rect.position;

+ rect.position.x += range.x;

+ rect.size = Size2(range.y - range.x, line_rect.size.y);

+ rect.size.x = MIN(rect.size.x, line_rect.size.x - range.x);

+ if (rect.size.x > 0) {

+ draw_rect(rect, Color(1, 1, 1, 0.07), true);

+ draw_rect(rect, Color(0.5, 0.7, 1.0, 0.4), false, 1);

+ }

+ }

+ p_offset.y += line_spacing + TS->shaped_text_get_ascent(line) + TS->shaped_text_get_descent(line);

+ }

+}

+

+void HighlightedLabel::add_highlight(const Vector2i &p_interval) {

+ if (p_interval.y > 0) {

+ highlights.append(p_interval);

+ queue_redraw();

+ }

+}

+

+void HighlightedLabel::reset_highlights() {

+ highlights.clear();

+ queue_redraw();

+}

+

+void HighlightedLabel::_notification(int p_notification) {

+ if (p_notification == NOTIFICATION_DRAW) {

+ if (highlights.is_empty()) {

+ return;

+ }

+

+ Vector2 offset;

+ int line_limit;

+ int line_spacing;

+ get_layout_data(offset, line_limit, line_spacing);

+

+ for (const Vector2i &substr : highlights) {

+ draw_substr_rects(substr, offset, line_limit, line_spacing);

+ }

+ }

+}

+

+ popup_centered_clamped(Size2(780, 650) * EDSCALE, 0.8f);

+ container->set_query_and_update(p_query);

+void style_button(Button *p_button) {

+ p_button->set_flat(true);

+ p_button->set_focus_mode(Control::FOCUS_NONE);

+ p_button->set_default_cursor_shape(Control::CURSOR_POINTING_HAND);

+}

+

+ // Selected filepath

+ add_child(file_details_path);

+ }

+ {

+ // Bottom bar

+ HBoxContainer *bottom_bar = memnew(HBoxContainer);

+ bottom_bar->set_h_size_flags(Control::SIZE_EXPAND_FILL);

+ bottom_bar->set_alignment(ALIGNMENT_END);

+ bottom_bar->add_theme_constant_override("separation", 3);

+ add_child(bottom_bar);

+

+ fuzzy_search_toggle = memnew(CheckButton);

+ style_button(fuzzy_search_toggle);

+ fuzzy_search_toggle->set_text(TTR("Fuzzy Search"));

+ fuzzy_search_toggle->set_tooltip_text(TTR("Enable fuzzy matching"));

+ fuzzy_search_toggle->connect(SceneStringName(toggled), callable_mp(this, &QuickOpenResultContainer::_toggle_fuzzy_search));

+ bottom_bar->add_child(fuzzy_search_toggle);

+

+ include_addons_toggle = memnew(CheckButton);

+ style_button(include_addons_toggle);

+ include_addons_toggle->set_text(TTR("Addons"));

+ include_addons_toggle->set_tooltip_text(TTR("Include files from addons"));

+ include_addons_toggle->connect(SceneStringName(toggled), callable_mp(this, &QuickOpenResultContainer::_toggle_include_addons));

+ bottom_bar->add_child(include_addons_toggle);

+

+ VSeparator *vsep = memnew(VSeparator);

+ vsep->set_v_size_flags(Control::SIZE_SHRINK_CENTER);

+ vsep->set_custom_minimum_size(Size2i(0, 14 * EDSCALE));

+ bottom_bar->add_child(vsep);

+

+ display_mode_toggle = memnew(Button);

+ style_button(display_mode_toggle);

+ display_mode_toggle->connect(SceneStringName(pressed), callable_mp(this, &QuickOpenResultContainer::_toggle_display_mode));

+ bottom_bar->add_child(display_mode_toggle);

+}

+void QuickOpenResultContainer::_ensure_result_vector_capacity() {

+ int target_size = EDITOR_GET("filesystem/quick_open_dialog/max_results");

+ int initial_size = result_items.size();

+ for (int i = target_size; i < initial_size; i++) {

+ result_items[i]->queue_free();

+ }

+ result_items.resize(target_size);

+ for (int i = initial_size; i < target_size; i++) {

+ if (!never_opened) {

+ _layout_result_item(item);

+ _ensure_result_vector_capacity();

+ } else if (never_opened) {

+ int last = EditorSettings::get_singleton()->get_project_metadata("quick_open_dialog", "last_mode", (int)QuickOpenDisplayMode::LIST);

+ _set_display_mode((QuickOpenDisplayMode)last);

+ const bool fuzzy_matching = EDITOR_GET("filesystem/quick_open_dialog/enable_fuzzy_matching");

+ fuzzy_search_toggle->set_pressed_no_signal(fuzzy_matching);

+ never_opened = false;

+ const bool enable_highlights = EDITOR_GET("filesystem/quick_open_dialog/show_search_highlight");

+ for (QuickOpenResultItem *E : result_items) {

+ E->enable_highlights = enable_highlights;

+ }

+

+ _create_initial_results();

+void QuickOpenResultContainer::_create_initial_results() {

+ file_type_icons.insert("__default_icon", get_editor_theme_icon(SNAME("Object")));

+ filepaths.clear();

+ filetypes.clear();

+ _find_filepaths_in_folder(EditorFileSystem::get_singleton()->get_filesystem(), include_addons_toggle->is_pressed());

+ max_total_results = MIN(filepaths.size(), result_items.size());

+ update_results();

+void QuickOpenResultContainer::_find_filepaths_in_folder(EditorFileSystemDirectory *p_directory, bool p_include_addons) {

+ _find_filepaths_in_folder(p_directory->get_subdir(i), p_include_addons);

+ filepaths.append(file_path);

+ filetypes.insert(file_path, actual_type);

+void QuickOpenResultContainer::set_query_and_update(const String &p_query) {

+ update_results();

+}

+

+void QuickOpenResultContainer::_setup_candidate(QuickOpenResultCandidate &candidate, const String &filepath) {

+ StringName actual_type = *filetypes.lookup_ptr(filepath);

+ candidate.file_path = filepath;

+ candidate.result = nullptr;

+

+ EditorResourcePreview::PreviewItem item = EditorResourcePreview::get_singleton()->get_resource_preview_if_available(filepath);

+ if (item.preview.is_valid()) {

+ candidate.thumbnail = item.preview;

+ } else if (file_type_icons.has(actual_type)) {

+ candidate.thumbnail = *file_type_icons.lookup_ptr(actual_type);

+ } else if (has_theme_icon(actual_type, EditorStringName(EditorIcons))) {

+ candidate.thumbnail = get_editor_theme_icon(actual_type);

+ file_type_icons.insert(actual_type, candidate.thumbnail);

+ } else {

+ candidate.thumbnail = *file_type_icons.lookup_ptr("__default_icon");

+}

+void QuickOpenResultContainer::_setup_candidate(QuickOpenResultCandidate &p_candidate, const FuzzySearchResult &p_result) {

+ _setup_candidate(p_candidate, p_result.target);

+ p_candidate.result = &p_result;

+}

+void QuickOpenResultContainer::update_results() {

+ showing_history = false;

+ candidates.clear();

+ if (query.is_empty()) {

+ _use_default_candidates();

+ } else {

+ _score_and_sort_candidates();

+ _update_result_items(MIN(candidates.size(), max_total_results), 0);

+}

+void QuickOpenResultContainer::_use_default_candidates() {

+ if (filepaths.size() <= SHOW_ALL_FILES_THRESHOLD) {

+ candidates.resize(filepaths.size());

+ QuickOpenResultCandidate *candidates_write = candidates.ptrw();

+ for (const String &filepath : filepaths) {

+ _setup_candidate(*candidates_write++, filepath);

+ } else if (base_types.size() == 1) {

+ Vector<QuickOpenResultCandidate> *history = selected_history.lookup_ptr(base_types[0]);

+ if (history) {

+ showing_history = true;

+ candidates.append_array(*history);

+void QuickOpenResultContainer::_update_fuzzy_search_results() {

+ FuzzySearch fuzzy_search;

+ fuzzy_search.start_offset = 6; // Don't match against "res://" at the start of each filepath.

+ fuzzy_search.set_query(query);

+ fuzzy_search.max_results = max_total_results;

+ bool fuzzy_matching = EDITOR_GET("filesystem/quick_open_dialog/enable_fuzzy_matching");

+ int max_misses = EDITOR_GET("filesystem/quick_open_dialog/max_fuzzy_misses");

+ fuzzy_search.allow_subsequences = fuzzy_matching;

+ fuzzy_search.max_misses = fuzzy_matching ? max_misses : 0;

+ fuzzy_search.search_all(filepaths, search_results);

+}

+void QuickOpenResultContainer::_score_and_sort_candidates() {

+ _update_fuzzy_search_results();

+ candidates.resize(search_results.size());

+ QuickOpenResultCandidate *candidates_write = candidates.ptrw();

+ for (const FuzzySearchResult &result : search_results) {

+ _setup_candidate(*candidates_write++, result);

+}

+void QuickOpenResultContainer::_update_result_items(int p_new_visible_results_count, int p_new_selection_index) {

+ item->set_content(candidates[i]);

+ if (filepaths.is_empty()) {

+ if (content_display_mode == QuickOpenDisplayMode::GRID) {

+ // Maybe strip off the shift modifier to allow non-selecting navigation by character?

+ if (key_event->get_modifiers_mask() == 0) {

+ move_selection = true;

+ }

+ }

+ // Don't move selection if there are no results.

+ if (num_visible_results <= 0) {

+ return;

+ }

+void QuickOpenResultContainer::_toggle_fuzzy_search(bool p_pressed) {

+ EditorSettings::get_singleton()->set("filesystem/quick_open_dialog/enable_fuzzy_matching", p_pressed);

+ update_results();

+}

+

+ _create_initial_results();

+CanvasItem *QuickOpenResultContainer::_get_result_root() {

+ if (content_display_mode == QuickOpenDisplayMode::LIST) {

+ return list;

+ } else {

+ return grid;

+ }

+}

+void QuickOpenResultContainer::_layout_result_item(QuickOpenResultItem *item) {

+ item->set_display_mode(content_display_mode);

+ Node *parent = item->get_parent();

+ if (parent) {

+ parent->remove_child(item);

+ _get_result_root()->add_child(item);

+}

+void QuickOpenResultContainer::_set_display_mode(QuickOpenDisplayMode p_display_mode) {

+ CanvasItem *prev_root = _get_result_root();

+ if (prev_root->is_visible() && content_display_mode == p_display_mode) {

+ return;

+ content_display_mode = p_display_mode;

+ CanvasItem *next_root = _get_result_root();

+

+ EditorSettings::get_singleton()->set_project_metadata("quick_open_dialog", "last_mode", (int)content_display_mode);

+ next_root->show();

+ for (QuickOpenResultItem *item : result_items) {

+ _layout_result_item(item);

+ return candidates[selection_index].file_path;

+ const QuickOpenResultCandidate &selected = candidates[selection_index];

+ Vector<QuickOpenResultCandidate> *type_history = selected_history.lookup_ptr(base_type);

+ selected_history.insert(base_type, Vector<QuickOpenResultCandidate>());

+ for (int i = 0; i < type_history->size(); i++) {

+ if (selected.file_path == type_history->get(i).file_path) {

+ type_history->remove_at(i);

+ break;

+ type_history->insert(0, selected);

+ type_history->ptrw()->result = nullptr;

+ if (type_history->size() > MAX_HISTORY_SIZE) {

+ type_history->resize(MAX_HISTORY_SIZE);

+ }

+ grid_item->reset();

+ list_item->reset();

+void QuickOpenResultItem::set_content(const QuickOpenResultCandidate &p_candidate) {

+ list_item->set_content(p_candidate, enable_highlights);

+ grid_item->set_content(p_candidate, enable_highlights);

+

+ queue_redraw();

+ list_item->reset();

+ grid_item->reset();

+static Vector2i _get_path_interval(const Vector2i &p_interval, int p_dir_index) {

+ if (p_interval.x >= p_dir_index || p_interval.y < 1) {

+ return { -1, -1 };

+ }

+ return { p_interval.x, MIN(p_interval.x + p_interval.y, p_dir_index) - p_interval.x };

+}

+

+static Vector2i _get_name_interval(const Vector2i &p_interval, int p_dir_index) {

+ if (p_interval.x + p_interval.y <= p_dir_index || p_interval.y < 1) {

+ return { -1, -1 };

+ }

+ int first_name_idx = p_dir_index + 1;

+ int start = MAX(p_interval.x, first_name_idx);

+ return { start - first_name_idx, p_interval.y - start + p_interval.x };

+}

+

+ name = memnew(HighlightedLabel);

+ path = memnew(HighlightedLabel);

+void QuickOpenResultListItem::set_content(const QuickOpenResultCandidate &p_candidate, bool p_highlight) {

+ thumbnail->set_texture(p_candidate.thumbnail);

+ name->set_text(p_candidate.file_path.get_file());

+ path->set_text(p_candidate.file_path.get_base_dir());

+ name->reset_highlights();

+ path->reset_highlights();

+

+ if (p_highlight && p_candidate.result != nullptr) {

+ for (const FuzzyTokenMatch &match : p_candidate.result->token_matches) {

+ for (const Vector2i &interval : match.substrings) {

+ path->add_highlight(_get_path_interval(interval, p_candidate.result->dir_index));

+ name->add_highlight(_get_name_interval(interval, p_candidate.result->dir_index));

+ }

+ }

+ }

+ bool uses_icon = p_candidate.thumbnail->get_width() < max_size;

+ thumbnail->set_custom_minimum_size(p_candidate.thumbnail->get_size());

+ int margin_needed = (max_size - p_candidate.thumbnail->get_width()) / 2;

+ name->set_text("");

+ name->reset_highlights();

+ path->reset_highlights();

+ thumbnail->set_custom_minimum_size(Size2i(120 * EDSCALE, 64 * EDSCALE));

+ name = memnew(HighlightedLabel);

+void QuickOpenResultGridItem::set_content(const QuickOpenResultCandidate &p_candidate, bool p_highlight) {

+ thumbnail->set_texture(p_candidate.thumbnail);

+ name->set_text(p_candidate.file_path.get_file());

+ name->set_tooltip_text(p_candidate.file_path);

+ name->reset_highlights();

+ if (p_highlight && p_candidate.result != nullptr) {

+ for (const FuzzyTokenMatch &match : p_candidate.result->token_matches) {

+ for (const Vector2i &interval : match.substrings) {

+ name->add_highlight(_get_name_interval(interval, p_candidate.result->dir_index));

+ }

+ }

+ }

+ bool uses_icon = p_candidate.thumbnail->get_width() < (32 * EDSCALE);

+ if (uses_icon || p_candidate.thumbnail->get_height() <= thumbnail->get_custom_minimum_size().y) {

+ name->set_text("");

+ name->reset_highlights();

+class FuzzySearchResult;

+

+struct QuickOpenResultCandidate {

+ String file_path;

+ Ref<Texture2D> thumbnail;

+ const FuzzySearchResult *result = nullptr;

+};

+

+class HighlightedLabel : public Label {

+ GDCLASS(HighlightedLabel, Label)

+

+ Vector<Vector2i> highlights;

+

+ void draw_substr_rects(const Vector2i &p_substr, Vector2 p_offset, int p_line_limit, int line_spacing);

+

+public:

+ void add_highlight(const Vector2i &p_interval);

+ void reset_highlights();

+

+protected:

+ void _notification(int p_notification);

+};

+

+ void set_query_and_update(const String &p_query);

+ void update_results();

+ static constexpr int SHOW_ALL_FILES_THRESHOLD = 30;

+ static constexpr int MAX_HISTORY_SIZE = 20;

+ Vector<FuzzySearchResult> search_results;

+ Vector<String> filepaths;

+ OAHashMap<String, StringName> filetypes;

+ Vector<QuickOpenResultCandidate> candidates;

+ OAHashMap<StringName, Vector<QuickOpenResultCandidate>> selected_history;

+ CheckButton *fuzzy_search_toggle = nullptr;

+ void _ensure_result_vector_capacity();

+ void _create_initial_results();

+ void _find_filepaths_in_folder(EditorFileSystemDirectory *p_directory, bool p_include_addons);

+ void _setup_candidate(QuickOpenResultCandidate &p_candidate, const String &p_filepath);

+ void _setup_candidate(QuickOpenResultCandidate &p_candidate, const FuzzySearchResult &p_result);

+ void _update_fuzzy_search_results();

+ void _use_default_candidates();

+ void _score_and_sort_candidates();

+ CanvasItem *_get_result_root();

+ void _layout_result_item(QuickOpenResultItem *p_item);

+ void _toggle_fuzzy_search(bool p_pressed);

+ void set_content(const QuickOpenResultCandidate &p_candidate, bool p_highlight);

+ HighlightedLabel *name = nullptr;

+ void set_content(const QuickOpenResultCandidate &p_candidate, bool p_highlight);

+ HighlightedLabel *name = nullptr;

+ HighlightedLabel *path = nullptr;

+ bool enable_highlights = true;

+ void reset();

+ void set_content(const QuickOpenResultCandidate &p_candidate);

+ void set_display_mode(QuickOpenDisplayMode p_display_mode);

+ set_process_internal(false);

+ panel->connect(SceneStringName(theme_changed), callable_mp(this, &EditorToaster::_toast_theme_changed).bind(panel));

+

+ Toast &toast = toasts[panel];

+

+ toast.close_button = close_button;

+ toast.severity = p_severity;

+ toast.duration = p_time;

+ toast.remaining_time = p_time;

+ toast.duration = -1.0;

+ toast.popped = true;

+ callable_mp(this, &EditorToaster::_popup_str).call_deferred(p_message, p_severity, p_tooltip);

+

+ Toast &toast = toasts[control];

+ toast.message = p_message;

+ toast.tooltip = p_tooltip;

+ toast.count = 1;

+ toast.message_label = label;

+ toast.message_count_label = count_label;

+ Toast &toast = toasts[control];

+ if (toast.popped) {

+ toast.count += 1;

+ toast.count = 1;

+ toast.remaining_time = toast.duration;

+ toast.popped = true;

+ set_process_internal(true);

+}

+

+void EditorToaster::_toast_theme_changed(Control *p_control) {

+ ERR_FAIL_COND(!toasts.has(p_control));

+

+ Toast &toast = toasts[p_control];

+ if (toast.close_button) {

+ toast.close_button->set_button_icon(get_editor_theme_icon(SNAME("Close")));

+ }

+ // Buttons

+ Button *close_button = nullptr;

+

+ void _toast_theme_changed(Control *p_control);

+ if (allowed_types_hbox) {

+ allowed_types_hbox->queue_free();

+ allowed_types_hbox = nullptr;

+ valid_type_icons.clear();

+ if (p_valid.is_empty()) {

+ return;

+ }

+

+ allowed_types_hbox = memnew(HBoxContainer);

+ content->add_child(allowed_types_hbox);

+ content->move_child(allowed_types_hbox, 0);

+ allowed_types_hbox->add_child(label);

+ allowed_types_hbox->add_child(hflow);

+ if (is_inside_tree()) {

+ _update_valid_type_icons();

+ }

+ _update_valid_type_icons();

+void SceneTreeDialog::_update_valid_type_icons() {

+ filter->set_right_icon(get_editor_theme_icon(SNAME("Search")));

+ for (TextureRect *trect : valid_type_icons) {

+ trect->set_custom_minimum_size(Vector2(get_theme_constant(SNAME("class_icon_size"), EditorStringName(Editor)), 0));

+ trect->set_texture(trect->get_meta("icon"));

+ }

+}

+

+ HBoxContainer *allowed_types_hbox = nullptr;

+ void _update_valid_type_icons();

+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path fill="#e0e0e0" d="M 8 1.6992188 L 5.6269531 5.796875 L 1 6.8945312 L 4.2363281 10.302734 L 3.8769531 14.976562 L 8.0175781 12.998047 L 12.173828 14.941406 L 11.777344 10.287109 L 15 6.8945312 L 10.373047 5.796875 L 8 1.6992188 z M 8 4.2773438 L 9.4882812 6.8457031 L 12.388672 7.5332031 L 10.369141 9.6601562 L 10.617188 12.576172 L 8.0097656 11.359375 L 5.4160156 12.599609 L 5.640625 9.6699219 L 3.6113281 7.5332031 L 6.5117188 6.8457031 L 8 4.2773438 z"/></svg> \ No newline at end of file

+ mesh->optimize_indices();

+

+ src_mesh_node->get_mesh()->optimize_indices();

+

+ mesh_node->set_visible(src_mesh_node->is_visible());

+ mesh_node->set_visible(src_mesh_node->is_visible());

+ main_vbox->add_margin_child(TTR("Preview:"), color_rect, true);

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ virtual bool can_import_threaded() const override { return true; }

+

+ ERR_FAIL_COND_V(format_channels == 0, ERR_INVALID_DATA);

+ virtual bool can_import_threaded() const override { return true; }

+

+#include "core/debugger/debugger_marshalls.h"

+ Array setup_data;

+ Dictionary settings;

+ settings["editors/panning/2d_editor_panning_scheme"] = EDITOR_GET("editors/panning/2d_editor_panning_scheme");

+ settings["editors/panning/simple_panning"] = EDITOR_GET("editors/panning/simple_panning");

+ settings["editors/panning/warped_mouse_panning"] = EDITOR_GET("editors/panning/warped_mouse_panning");

+ settings["editors/panning/2d_editor_pan_speed"] = EDITOR_GET("editors/panning/2d_editor_pan_speed");

+ settings["canvas_item_editor/pan_view"] = DebuggerMarshalls::serialize_key_shortcut(ED_GET_SHORTCUT("canvas_item_editor/pan_view"));

+ setup_data.append(settings);

+ p_session->send_message("scene:runtime_node_select_setup", setup_data);

+ Vector<String> features_vector;

+ features_vector.append(tag);

+ struct FoundLibInfo {

+ int count = 0;

+ Vector<String> libs;

+ };

+ HashMap<String, FoundLibInfo> libs_found;

+ for (const String &arch_tag : archs) {

+ if (arch_tag != "universal") {

+ libs_found[arch_tag] = FoundLibInfo();

+ }

+ }

+

+

+ // Update found library info.

+ if (arch_tag == "universal") {

+ for (const String &sub_arch_tag : archs) {

+ if (sub_arch_tag != "universal") {

+ libs_found[sub_arch_tag].count++;

+ libs_found[sub_arch_tag].libs.push_back(library_path);

+ }

+ }

+ } else {

+ libs_found[arch_tag].count++;

+ libs_found[arch_tag].libs.push_back(library_path);

+

+ for (const KeyValue<String, FoundLibInfo> &E : libs_found) {

+ if (E.value.count == 0) {

+ if (get_export_platform().is_valid()) {

+ get_export_platform()->add_message(EditorExportPlatform::EXPORT_MESSAGE_WARNING, TTR("GDExtension"), vformat(TTR("No \"%s\" library found for GDExtension: \"%s\". Possible feature flags for your platform: %s"), E.key, p_path, String(", ").join(features_vector)));

+ }

+ } else if (E.value.count > 1) {

+ if (get_export_platform().is_valid()) {

+ get_export_platform()->add_message(EditorExportPlatform::EXPORT_MESSAGE_WARNING, TTR("GDExtension"), vformat(TTR("Multiple \"%s\" libraries found for GDExtension: \"%s\": \"%s\"."), E.key, p_path, String(", ").join(E.value.libs)));

+ }

+ }

+ }

+#include "scene/gui/aspect_ratio_container.h"

+ debug_uv->draw_rect(

+ Rect2(Vector2(), debug_uv->get_size()),

+ get_theme_color(SNAME("dark_color_3"), EditorStringName(Editor)));

+

+ // Draw an outline to represent the UV2's beginning and end area (useful on Black OLED theme).

+ // Top-left coordinate needs to be `(1, 1)` to prevent `clip_contents` from clipping the top and left lines.

+ debug_uv->draw_rect(

+ Rect2(Vector2(1, 1), debug_uv->get_size() - Vector2(1, 1)),

+ get_theme_color(SNAME("mono_color"), EditorStringName(Editor)) * Color(1, 1, 1, 0.125),

+ false,

+ Math::round(EDSCALE));

+

+ for (int x = 1; x <= 7; x++) {

+ debug_uv->draw_line(

+ Vector2(debug_uv->get_size().x * 0.125 * x, 0),

+ Vector2(debug_uv->get_size().x * 0.125 * x, debug_uv->get_size().y),

+ get_theme_color(SNAME("mono_color"), EditorStringName(Editor)) * Color(1, 1, 1, 0.125),

+ Math::round(EDSCALE));

+ }

+

+ for (int y = 1; y <= 7; y++) {

+ debug_uv->draw_line(

+ Vector2(0, debug_uv->get_size().y * 0.125 * y),

+ Vector2(debug_uv->get_size().x, debug_uv->get_size().y * 0.125 * y),

+ get_theme_color(SNAME("mono_color"), EditorStringName(Editor)) * Color(1, 1, 1, 0.125),

+ Math::round(EDSCALE));

+ }

+

+

+ // Divide line width by the drawing scale set above, so that line width is consistent regardless of dialog size.

+ // Aspect ratio is preserved by the parent AspectRatioContainer, so we only need to check the X size which is always equal to Y.

+ debug_uv->draw_multiline(

+ uv_lines,

+ get_theme_color(SNAME("mono_color"), EditorStringName(Editor)) * Color(1, 1, 1, 0.5),

+ Math::round(EDSCALE) / debug_uv->get_size().x);

+

+ debug_uv_arc = memnew(AspectRatioContainer);

+ debug_uv_dialog->add_child(debug_uv_arc);

+

+ debug_uv_arc->add_child(debug_uv);

+class AspectRatioContainer;

+ AspectRatioContainer *debug_uv_arc = nullptr;

+ viewports[i]->view_menu->get_popup()->set_item_checked(viewports[i]->view_menu->get_popup()->get_item_index(Node3DEditorViewport::VIEW_AUDIO_LISTENER), i == 0);

+ for (List<VisualShader::Connection>::Element *E = connections.front(); E; E = E->next()) {

+ Tree *tree = scene_tree->get_scene_tree();

+ if (mb->is_pressed() && tree->get_rect().has_point(tree->get_local_mouse_position())) {