/**************************************************************************/
/* editor_quick_open_dialog.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_quick_open_dialog.h"
#include "core/config/project_settings.h"
#include "core/io/resource_loader.h"
#include "core/object/callable_mp.h"
#include "core/object/class_db.h"
#include "core/os/os.h"
#include "core/string/fuzzy_search.h"
#include "editor/docks/filesystem_dock.h"
#include "editor/editor_node.h"
#include "editor/editor_string_names.h"
#include "editor/file_system/editor_file_system.h"
#include "editor/file_system/editor_paths.h"
#include "editor/gui/editor_toaster.h"
#include "editor/inspector/editor_resource_preview.h"
#include "editor/inspector/multi_node_edit.h"
#include "editor/settings/editor_settings.h"
#include "editor/themes/editor_scale.h"
#include "scene/gui/center_container.h"
#include "scene/gui/check_button.h"
#include "scene/gui/flow_container.h"
#include "scene/gui/line_edit.h"
#include "scene/gui/margin_container.h"
#include "scene/gui/panel_container.h"
#include "scene/gui/separator.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tree.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);
}
}
}
EditorQuickOpenDialog::EditorQuickOpenDialog() {
VBoxContainer *vbc = memnew(VBoxContainer);
vbc->add_theme_constant_override("separation", 0);
add_child(vbc);
{
// Search bar
MarginContainer *mc = memnew(MarginContainer);
mc->add_theme_constant_override("margin_top", 6);
mc->add_theme_constant_override("margin_bottom", 6);
mc->add_theme_constant_override("margin_left", 1);
mc->add_theme_constant_override("margin_right", 1);
vbc->add_child(mc);
search_box = memnew(LineEdit);
search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL);
search_box->set_placeholder(TTR("Search files..."));
search_box->set_accessibility_name(TTRC("Search"));
search_box->set_clear_button_enabled(true);
mc->add_child(search_box);
}
{
container = memnew(QuickOpenResultContainer);
container->connect("selection_changed", callable_mp(this, &EditorQuickOpenDialog::selection_changed));
container->connect("result_clicked", callable_mp(this, &EditorQuickOpenDialog::item_pressed));
vbc->add_child(container);
}
search_box->connect(SceneStringName(text_changed), callable_mp(this, &EditorQuickOpenDialog::_search_box_text_changed));
search_box->connect(SceneStringName(gui_input), callable_mp(container, &QuickOpenResultContainer::handle_search_box_input));
register_text_enter(search_box);
get_ok_button()->hide();
}
String EditorQuickOpenDialog::get_dialog_title(const Vector<StringName> &p_base_types) {
if (p_base_types.size() > 1) {
return TTR("Select Resource");
}
if (p_base_types[0] == SNAME("PackedScene")) {
return TTR("Select Scene");
}
return vformat(TTR("Select %s"), p_base_types[0]);
}
void EditorQuickOpenDialog::popup_dialog(const Vector<StringName> &p_base_types, const Callable &p_item_selected_callback, bool p_allow_type_switching) {
ERR_FAIL_COND(p_base_types.is_empty());
ERR_FAIL_COND(!p_item_selected_callback.is_valid());
property_object = nullptr;
property_path = "";
item_selected_callback = p_item_selected_callback;
allow_type_switching = p_allow_type_switching;
is_cycling_items = false;
container->init(p_base_types);
container->set_instant_preview_toggle_visible(false);
_finish_dialog_setup(p_base_types);
}
void EditorQuickOpenDialog::popup_dialog_for_property(const Vector<StringName> &p_base_types, Object *p_obj, const StringName &p_path, const Callable &p_item_selected_callback) {
ERR_FAIL_NULL(p_obj);
ERR_FAIL_COND(p_base_types.is_empty());
ERR_FAIL_COND(!p_item_selected_callback.is_valid());
property_object = p_obj;
property_path = p_path;
item_selected_callback = p_item_selected_callback;
initial_property_value = property_object->get(property_path);
allow_type_switching = false;
// Reset this, so that the property isn't updated immediately upon opening
// the window.
initial_selection_performed = false;
container->init(p_base_types);
container->set_instant_preview_toggle_visible(true);
_finish_dialog_setup(p_base_types);
}
void EditorQuickOpenDialog::_finish_dialog_setup(const Vector<StringName> &p_base_types) {
set_process_shortcut_input(allow_type_switching);
get_ok_button()->set_disabled(container->has_nothing_selected());
set_title(get_dialog_title(p_base_types));
popup_centered_clamped(Size2(780, 650) * EDSCALE, 0.8f);
search_box->grab_focus();
}
void EditorQuickOpenDialog::ok_pressed() {
container->save_selected_item();
update_property();
container->cleanup();
search_box->clear();
hide();
}
bool EditorQuickOpenDialog::_is_instant_preview_active() const {
return property_object != nullptr && container->is_instant_preview_enabled();
}
void EditorQuickOpenDialog::selection_changed() {
if (!_is_instant_preview_active()) {
return;
}
// This prevents the property from being changed the first time the Quick Open
// window is opened.
if (!initial_selection_performed) {
initial_selection_performed = true;
} else {
preview_property();
}
}
void EditorQuickOpenDialog::item_pressed(bool p_double_click) {
// A double-click should always be taken as a "confirm" action.
if (p_double_click) {
ok_pressed();
return;
}
// Single-clicks should be taken as a "confirm" action only if Instant Preview
// isn't currently enabled, or the property object is null for some reason.
if (!_is_instant_preview_active()) {
ok_pressed();
}
}
void EditorQuickOpenDialog::preview_property() {
ERR_FAIL_COND(container->get_selected() == ResourceUID::INVALID_ID);
String path = container->get_selected_path();
Ref<Resource> loaded_resource = ResourceLoader::load(path);
ERR_FAIL_COND_MSG(loaded_resource.is_null(), "Cannot load resource from path '" + path + "'.");
Resource *res = Object::cast_to<Resource>(property_object);
if (res) {
HashSet<Resource *> resources_found;
resources_found.insert(res);
if (EditorNode::find_recursive_resources(loaded_resource, resources_found)) {
EditorToaster::get_singleton()->popup_str(TTR("Recursion detected, Instant Preview failed."), EditorToaster::SEVERITY_ERROR);
loaded_resource = Ref<Resource>();
}
}
// MultiNodeEdit has adding to the undo/redo stack baked into its set function.
// As such, we have to specifically call a version of its setter that doesn't
// create undo/redo actions.
property_object->set_block_signals(true);
if (Object::cast_to<MultiNodeEdit>(property_object)) {
Object::cast_to<MultiNodeEdit>(property_object)->_set_impl(property_path, loaded_resource, "", false);
} else {
property_object->set(property_path, loaded_resource);
}
property_object->set_block_signals(false);
}
void EditorQuickOpenDialog::update_property() {
// Set the property back to the initial value first, so that the undo action
// has the correct object.
if (property_object) {
if (Object::cast_to<MultiNodeEdit>(property_object)) {
Object::cast_to<MultiNodeEdit>(property_object)->_set_impl(property_path, initial_property_value, "", false);
} else {
property_object->set(property_path, initial_property_value);
}
}
if (!item_selected_callback.is_valid()) {
String err_msg = "The callback provided to the Quick Open dialog was invalid.";
if (_is_instant_preview_active()) {
err_msg += " Try disabling \"Instant Preview\" as a workaround.";
}
ERR_FAIL_MSG(err_msg);
}
item_selected_callback.call(container->get_selected_path());
}
void EditorQuickOpenDialog::cancel_pressed() {
if (property_object) {
if (Object::cast_to<MultiNodeEdit>(property_object)) {
Object::cast_to<MultiNodeEdit>(property_object)->_set_impl(property_path, initial_property_value, "", false);
} else {
property_object->set(property_path, initial_property_value);
}
}
container->cleanup();
search_box->clear();
}
void EditorQuickOpenDialog::shortcut_input(const Ref<InputEvent> &p_event) {
// If the user is cycling through items (with up/down arrows), confirm selection when releasing the keys.
Ref<InputEventWithModifiers> iewm = p_event;
if (is_cycling_items && iewm.is_valid() && p_event->is_released() && iewm->get_modifiers_mask().is_empty()) {
ok_pressed();
return;
}
if (p_event.is_null() || !p_event->is_pressed() || p_event->is_echo()) {
return;
}
Vector<StringName> new_base_types;
if (EditorSettings *settings = EditorSettings::get_singleton()) {
if (settings->is_shortcut("editor/quick_open", p_event)) {
new_base_types.push_back("Resource");
} else if (settings->is_shortcut("editor/quick_open_scene", p_event)) {
new_base_types.push_back("PackedScene");
} else if (settings->is_shortcut("editor/quick_open_script", p_event)) {
new_base_types.push_back("Script");
}
}
if (new_base_types.size() != 1) {
return;
}
// Check if we're already showing this dialog type.
const Vector<StringName> ¤t_base_types = container->get_base_types();
if (current_base_types.size() == 1 && current_base_types[0] == new_base_types[0]) {
// Already showing the requested dialog type, move next.
Ref<InputEventKey> down_event = memnew(InputEventKey);
down_event->set_keycode(Key::DOWN);
down_event->set_pressed(true);
container->handle_search_box_input(down_event);
is_cycling_items = true;
} else {
// Switch to the new dialog type.
container->init(new_base_types);
container->set_instant_preview_toggle_visible(false);
is_cycling_items = false;
set_title(get_dialog_title(new_base_types));
search_box->clear();
search_box->grab_focus();
}
set_input_as_handled();
}
void EditorQuickOpenDialog::_search_box_text_changed(const String &p_query) {
container->set_query_and_update(p_query);
get_ok_button()->set_disabled(container->has_nothing_selected());
}
//------------------------- Result Container
void style_button(Button *p_button) {
p_button->set_flat(true);
p_button->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
}
QuickOpenResultContainer::QuickOpenResultContainer() {
set_h_size_flags(Control::SIZE_EXPAND_FILL);
set_v_size_flags(Control::SIZE_EXPAND_FILL);
add_theme_constant_override("separation", 0);
history_file.instantiate();
{
// Results section
panel_container = memnew(PanelContainer);
panel_container->set_v_size_flags(Control::SIZE_EXPAND_FILL);
add_child(panel_container);
{
// No search results
no_results_container = memnew(CenterContainer);
no_results_container->set_h_size_flags(Control::SIZE_EXPAND_FILL);
no_results_container->set_v_size_flags(Control::SIZE_EXPAND_FILL);
panel_container->add_child(no_results_container);
no_results_label = memnew(Label);
no_results_label->set_focus_mode(FOCUS_ACCESSIBILITY);
no_results_label->add_theme_font_size_override(SceneStringName(font_size), 24 * EDSCALE);
no_results_container->add_child(no_results_label);
no_results_container->hide();
}
{
MarginContainer *mc = memnew(MarginContainer);
mc->set_theme_type_variation("NoBorderHorizontalWindow");
mc->set_h_size_flags(Control::SIZE_EXPAND_FILL);
mc->set_v_size_flags(Control::SIZE_EXPAND_FILL);
panel_container->add_child(mc);
// Search results
scroll_container = memnew(ScrollContainer);
scroll_container->set_horizontal_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED);
scroll_container->set_scroll_hint_mode(ScrollContainer::SCROLL_HINT_MODE_ALL);
scroll_container->hide();
panel_container->add_child(scroll_container);
list = memnew(VBoxContainer);
list->set_h_size_flags(Control::SIZE_EXPAND_FILL);
list->add_theme_constant_override(SNAME("separation"), 0);
list->hide();
scroll_container->add_child(list);
grid = memnew(HFlowContainer);
grid->set_h_size_flags(Control::SIZE_EXPAND_FILL);
grid->set_v_size_flags(Control::SIZE_EXPAND_FILL);
grid->add_theme_constant_override(SNAME("v_separation"), 0);
grid->add_theme_constant_override(SNAME("h_separation"), 0);
grid->hide();
scroll_container->add_child(grid);
file_context_menu = memnew(PopupMenu);
file_context_menu->add_item(TTR("Show in FileSystem"), FILE_SHOW_IN_FILESYSTEM);
file_context_menu->add_item(OS::get_singleton()->get_platform_string(OS::PLATFORM_STRING_FILE_MANAGER_SHOW), FILE_SHOW_IN_FILE_MANAGER);
file_context_menu->connect(SceneStringName(id_pressed), callable_mp(this, &QuickOpenResultContainer::_menu_option));
file_context_menu->hide();
scroll_container->add_child(file_context_menu);
}
}
{
// Selected filepath
file_details_path = memnew(Label);
file_details_path->set_focus_mode(FOCUS_ACCESSIBILITY);
file_details_path->set_h_size_flags(Control::SIZE_EXPAND_FILL);
file_details_path->set_horizontal_alignment(HorizontalAlignment::HORIZONTAL_ALIGNMENT_CENTER);
file_details_path->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS);
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);
instant_preview_toggle = memnew(CheckButton);
style_button(instant_preview_toggle);
instant_preview_toggle->set_text(TTRC("Instant Preview"));
instant_preview_toggle->set_tooltip_text(TTRC("Selected resource will be previewed in the editor before accepting."));
instant_preview_toggle->connect(SceneStringName(toggled), callable_mp(this, &QuickOpenResultContainer::_toggle_instant_preview));
bottom_bar->add_child(instant_preview_toggle);
fuzzy_search_toggle = memnew(CheckButton);
style_button(fuzzy_search_toggle);
fuzzy_search_toggle->set_text(TTR("Fuzzy Search"));
fuzzy_search_toggle->set_tooltip_text(TTRC("Include approximate matches."));
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);
display_mode_toggle->set_accessibility_name(TTRC("Display Mode"));
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::_menu_option(int p_option) {
ERR_FAIL_COND(get_selected() == ResourceUID::INVALID_ID);
String selected_path = get_selected_path();
switch (p_option) {
case FILE_SHOW_IN_FILESYSTEM: {
FileSystemDock::get_singleton()->navigate_to_path(selected_path);
} break;
case FILE_SHOW_IN_FILE_MANAGER: {
String dir = ProjectSettings::get_singleton()->globalize_path(selected_path);
OS::get_singleton()->shell_show_in_file_manager(dir, true);
} break;
}
}
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++) {
QuickOpenResultItem *item = memnew(QuickOpenResultItem);
item->connect(SceneStringName(gui_input), callable_mp(this, &QuickOpenResultContainer::_item_input).bind(i));
result_items.write[i] = item;
if (!never_opened) {
_layout_result_item(item);
}
}
}
void QuickOpenResultContainer::init(const Vector<StringName> &p_base_types) {
_ensure_result_vector_capacity();
base_types = p_base_types;
const int display_mode_behavior = EDITOR_GET("filesystem/quick_open_dialog/default_display_mode");
const bool adaptive_display_mode = (display_mode_behavior == 0);
const bool first_open = never_opened;
if (adaptive_display_mode) {
_set_display_mode(get_adaptive_display_mode(p_base_types));
} 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 do_instant_preview = EDITOR_GET("filesystem/quick_open_dialog/instant_preview");
const bool fuzzy_matching = EDITOR_GET("filesystem/quick_open_dialog/enable_fuzzy_matching");
const bool include_addons = EDITOR_GET("filesystem/quick_open_dialog/include_addons");
instant_preview_toggle->set_pressed_no_signal(do_instant_preview);
fuzzy_search_toggle->set_pressed_no_signal(fuzzy_matching);
include_addons_toggle->set_pressed_no_signal(include_addons);
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;
}
bool history_modified = false;
if (first_open && history_file->load(_get_cache_file_path()) == OK) {
// Load history when opening for the first time.
file_type_icons.insert(SNAME("__default_icon"), get_editor_theme_icon(SNAME("Object")));
Vector<String> history_keys = history_file->get_section_keys("selected_history");
for (const String &type : history_keys) {
const StringName type_name = type;
const PackedStringArray history_uids = history_file->get_value("selected_history", type);
PackedStringArray cleaned_text_uids;
cleaned_text_uids.resize(history_uids.size());
Vector<ResourceUID::ID> cleaned_ids;
cleaned_ids.resize(history_uids.size());
{
String *text_write = cleaned_text_uids.ptrw();
ResourceUID::ID *id_write = cleaned_ids.ptrw();
int i = 0;
for (String uid : history_uids) {
#ifndef DISABLE_DEPRECATED
if (!uid.begins_with("uid://")) {
// uid might be a path here, if config was written by older editor version
ResourceUID::ID id = EditorFileSystem::get_singleton()->get_file_uid(uid);
if (id == ResourceUID::INVALID_ID) {
continue;
}
uid = ResourceUID::get_singleton()->id_to_text(id);
}
#endif
ResourceUID::ID id = ResourceUID::get_singleton()->text_to_id(uid);
if (id == ResourceUID::INVALID_ID || !ResourceUID::get_singleton()->has_id(id)) {
continue;
}
filetypes.insert(id, type_name);
text_write[i] = uid;
id_write[i] = id;
i++;
}
cleaned_text_uids.resize(i);
selected_history.insert(type, cleaned_ids);
if (i < history_uids.size()) {
// Some paths removed, need to update history.
if (i == 0) {
history_file->erase_section_key("selected_history", type);
} else {
history_file->set_value("selected_history", type, cleaned_text_uids);
}
history_modified = true;
}
}
}
} else if (!first_open && base_types.size() == 1) {
const StringName &type = base_types[0];
Vector<ResourceUID::ID> *history = selected_history.getptr(type);
if (history) {
Vector<ResourceUID::ID> clean_history;
for (const ResourceUID::ID &uid : *history) {
if (ResourceUID::get_singleton()->has_id(uid)) {
clean_history.push_back(uid);
} else {
history_modified = true;
}
}
if (clean_history.is_empty()) {
selected_history.erase(type);
} else if (history_modified) {
*history = clean_history;
}
}
}
if (history_modified) {
history_file->save(_get_cache_file_path());
}
_create_initial_results();
}
void QuickOpenResultContainer::_sort_uids(int p_max_results) {
struct FilepathComparator {
bool operator()(const ResourceUID::ID &p_lhs, const ResourceUID::ID &p_rhs) const {
String lhs_path = ResourceUID::get_singleton()->get_id_path(p_lhs);
String rhs_path = ResourceUID::get_singleton()->get_id_path(p_rhs);
// Sort on (length, alphanumeric) to prioritize shorter filepaths
return lhs_path.length() == rhs_path.length() ? lhs_path < rhs_path : lhs_path.length() < rhs_path.length();
}
};
SortArray<ResourceUID::ID, FilepathComparator> sorter{};
if ((int)uids.size() > p_max_results) {
sorter.partial_sort(0, uids.size(), p_max_results, uids.ptr());
} else {
sorter.sort(uids.ptr(), uids.size());
}
}
void QuickOpenResultContainer::_create_initial_results() {
file_type_icons.clear();
file_type_icons.insert(SNAME("__default_icon"), get_editor_theme_icon(SNAME("Object")));
uids.clear();
filetypes.clear();
history_set.clear();
Vector<ResourceUID::ID> *history = _get_history();
if (history) {
for (const ResourceUID::ID &uid : *history) {
history_set.insert(uid);
}
}
_find_uids_in_folder(EditorFileSystem::get_singleton()->get_filesystem(), include_addons_toggle->is_pressed());
_sort_uids(result_items.size());
max_total_results = MIN(uids.size(), result_items.size());
update_results();
}
void QuickOpenResultContainer::_find_uids_in_folder(EditorFileSystemDirectory *p_directory, bool p_include_addons) {
for (int i = 0; i < p_directory->get_subdir_count(); i++) {
if (p_include_addons || p_directory->get_name() != "addons") {
_find_uids_in_folder(p_directory->get_subdir(i), p_include_addons);
}
}
for (int i = 0; i < p_directory->get_file_count(); i++) {
ResourceUID::ID uid = p_directory->get_file_uid(i);
if (uid == ResourceUID::INVALID_ID) {
continue;
}
const StringName engine_type = p_directory->get_file_type(i);
const StringName script_type = p_directory->get_file_resource_script_class(i);
const bool is_engine_type = script_type == StringName();
const StringName &actual_type = is_engine_type ? engine_type : script_type;
for (const StringName &parent_type : base_types) {
bool is_valid = ClassDB::is_parent_class(engine_type, parent_type) || (!is_engine_type && EditorNode::get_editor_data().script_class_is_parent(script_type, parent_type));
if (is_valid) {
uids.push_back(uid);
filetypes.insert(uid, actual_type);
break; // Stop testing base types as soon as we get a match.
}
}
}
}
void QuickOpenResultContainer::set_query_and_update(const String &p_query) {
query = p_query;
update_results();
}
Vector<ResourceUID::ID> *QuickOpenResultContainer::_get_history() {
if (base_types.size() == 1) {
return selected_history.getptr(base_types[0]);
}
return nullptr;
}
QuickOpenResultCandidate QuickOpenResultCandidate::from_uid(const ResourceUID::ID &p_uid, bool &r_success) {
if (p_uid == ResourceUID::INVALID_ID || !ResourceUID::get_singleton()->has_id(p_uid)) {
r_success = false;
return QuickOpenResultCandidate();
}
QuickOpenResultCandidate candidate;
candidate.uid = p_uid;
candidate.result = nullptr;
r_success = true;
return candidate;
}
QuickOpenResultCandidate QuickOpenResultCandidate::from_result(const FuzzySearchResult &p_result, bool &r_success) {
ResourceUID::ID uid = EditorFileSystem::get_singleton()->get_file_uid(p_result.target);
QuickOpenResultCandidate candidate = from_uid(uid, r_success);
if (!r_success) {
return QuickOpenResultCandidate();
}
candidate.result = &p_result;
return candidate;
}
void QuickOpenResultContainer::_add_candidate(QuickOpenResultCandidate &p_candidate) {
ERR_FAIL_COND(!ResourceUID::get_singleton()->has_id(p_candidate.uid));
StringName actual_type;
{
StringName *actual_type_ptr = filetypes.getptr(p_candidate.uid);
if (actual_type_ptr) {
actual_type = *actual_type_ptr;
} else {
ERR_PRINT(vformat("EditorQuickOpenDialog: No type for path %s.", ResourceUID::get_singleton()->get_id_path(p_candidate.uid)));
}
}
String file_path = ResourceUID::get_singleton()->get_id_path(p_candidate.uid);
EditorResourcePreview::PreviewItem item = EditorResourcePreview::get_singleton()->get_resource_preview_if_available(file_path);
if (item.preview.is_valid()) {
p_candidate.thumbnail = item.preview;
} else if (file_type_icons.has(actual_type)) {
p_candidate.thumbnail = *file_type_icons.getptr(actual_type);
} else if (has_theme_icon(actual_type, EditorStringName(EditorIcons))) {
p_candidate.thumbnail = get_editor_theme_icon(actual_type);
file_type_icons.insert(actual_type, p_candidate.thumbnail);
} else {
p_candidate.thumbnail = *file_type_icons.getptr(SNAME("__default_icon"));
}
candidates.push_back(p_candidate);
candidates_uids.insert(p_candidate.uid);
}
void QuickOpenResultContainer::update_results() {
candidates.clear();
candidates_uids.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() {
HashSet<ResourceUID::ID> existing_uids;
Vector<ResourceUID::ID> *history = _get_history();
if (history) {
for (const ResourceUID::ID &uid : *history) {
bool success;
QuickOpenResultCandidate candidate = QuickOpenResultCandidate::from_uid(uid, success);
if (!success) {
continue;
}
_add_candidate(candidate);
}
}
for (const ResourceUID::ID &uid : uids) {
if (candidates.size() >= max_total_results) {
break;
}
if (candidates_uids.has(uid)) {
continue;
}
bool success;
QuickOpenResultCandidate candidate = QuickOpenResultCandidate::from_uid(uid, success);
if (!success) {
continue;
}
_add_candidate(candidate);
}
}
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;
PackedStringArray paths;
paths.reserve_exact(uids.size());
for (const ResourceUID::ID &uid : uids) {
paths.push_back(ResourceUID::get_singleton()->get_id_path(uid));
}
fuzzy_search.search_all(paths, search_results);
}
void QuickOpenResultContainer::_score_and_sort_candidates() {
_update_fuzzy_search_results();
for (const FuzzySearchResult &result : search_results) {
bool success;
QuickOpenResultCandidate candidate = QuickOpenResultCandidate::from_result(result, success);
if (!success) {
continue;
}
_add_candidate(candidate);
}
}
void QuickOpenResultContainer::_update_result_items(int p_new_visible_results_count, int p_new_selection_index) {
// Only need to update items that were not hidden in previous update.
int num_items_needing_updates = MAX(num_visible_results, p_new_visible_results_count);
num_visible_results = p_new_visible_results_count;
for (int i = 0; i < num_items_needing_updates; i++) {
QuickOpenResultItem *item = result_items[i];
if (i < num_visible_results) {
item->set_content(candidates[i]);
} else {
item->reset();
}
};
const bool any_results = num_visible_results > 0;
_select_item(any_results ? p_new_selection_index : -1);
scroll_container->set_visible(any_results);
no_results_container->set_visible(!any_results);
if (!any_results) {
if (uids.is_empty()) {
no_results_label->set_text(TTR("No files found for this type"));
} else {
no_results_label->set_text(TTR("No results found"));
}
}
}
void QuickOpenResultContainer::handle_search_box_input(const Ref<InputEvent> &p_ie) {
if (num_visible_results < 0) {
return;
}
Ref<InputEventKey> key_event = p_ie;
if (key_event.is_valid() && key_event->is_pressed()) {
bool move_selection = false;
switch (key_event->get_keycode()) {
case Key::UP:
case Key::DOWN:
case Key::PAGEUP:
case Key::PAGEDOWN: {
move_selection = true;
} break;
case Key::LEFT:
case Key::RIGHT: {
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().is_empty()) {
move_selection = true;
}
}
} break;
default:
break; // Let the event through so it will reach the search box.
}
if (move_selection) {
_move_selection_index(key_event->get_keycode());
queue_redraw();
accept_event();
}
}
}
void QuickOpenResultContainer::_move_selection_index(Key p_key) {
// Don't move selection if there are no results.
if (num_visible_results <= 0) {
return;
}
const int max_index = num_visible_results - 1;
int idx = selection_index;
if (content_display_mode == QuickOpenDisplayMode::LIST) {
if (p_key == Key::UP) {
idx = (idx == 0) ? max_index : (idx - 1);
} else if (p_key == Key::DOWN) {
idx = (idx == max_index) ? 0 : (idx + 1);
} else if (p_key == Key::PAGEUP) {
idx = (idx == 0) ? idx : MAX(idx - 10, 0);
} else if (p_key == Key::PAGEDOWN) {
idx = (idx == max_index) ? idx : MIN(idx + 10, max_index);
}
} else {
int column_count = grid->get_line_max_child_count();
if (p_key == Key::LEFT) {
idx = (idx == 0) ? max_index : (idx - 1);
} else if (p_key == Key::RIGHT) {
idx = (idx == max_index) ? 0 : (idx + 1);
} else if (p_key == Key::UP) {
idx = (idx == 0) ? max_index : MAX(idx - column_count, 0);
} else if (p_key == Key::DOWN) {
idx = (idx == max_index) ? 0 : MIN(idx + column_count, max_index);
} else if (p_key == Key::PAGEUP) {
idx = (idx == 0) ? idx : MAX(idx - (3 * column_count), 0);
} else if (p_key == Key::PAGEDOWN) {
idx = (idx == max_index) ? idx : MIN(idx + (3 * column_count), max_index);
}
}
_select_item(idx);
}
void QuickOpenResultContainer::_select_item(int p_index) {
if (!has_nothing_selected()) {
result_items[selection_index]->highlight_item(false);
}
selection_index = p_index;
if (has_nothing_selected()) {
file_details_path->set_text("");
return;
}
result_items[selection_index]->highlight_item(true);
bool in_history = history_set.has(candidates[selection_index].uid);
file_details_path->set_text(get_selected_path() + (in_history ? TTR(" (recently opened)") : ""));
emit_signal(SNAME("selection_changed"));
const QuickOpenResultItem *item = result_items[selection_index];
// Copied from Tree.
const int selected_position = item->get_position().y;
const int selected_size = item->get_size().y;
const int scroll_window_size = scroll_container->get_size().y;
const int scroll_position = scroll_container->get_v_scroll();
if (selected_position <= scroll_position) {
scroll_container->set_v_scroll(selected_position);
} else if (selected_position + selected_size > scroll_position + scroll_window_size) {
scroll_container->set_v_scroll(selected_position + selected_size - scroll_window_size);
}
}
void QuickOpenResultContainer::_item_input(const Ref<InputEvent> &p_ev, int p_index) {
Ref<InputEventMouseButton> mb = p_ev;
if (mb.is_valid() && mb->is_pressed()) {
if (mb->get_button_index() == MouseButton::LEFT) {
_select_item(p_index);
emit_signal(SNAME("result_clicked"), mb->is_double_click());
} else if (mb->get_button_index() == MouseButton::RIGHT) {
_select_item(p_index);
file_context_menu->set_position(result_items[p_index]->get_screen_position() + mb->get_position());
file_context_menu->reset_size();
file_context_menu->popup();
}
}
}
void QuickOpenResultContainer::_toggle_instant_preview(bool p_pressed) {
EditorSettings::get_singleton()->set("filesystem/quick_open_dialog/instant_preview", p_pressed);
}
void QuickOpenResultContainer::_toggle_fuzzy_search(bool p_pressed) {
EditorSettings::get_singleton()->set("filesystem/quick_open_dialog/enable_fuzzy_matching", p_pressed);
update_results();
}
String QuickOpenResultContainer::_get_cache_file_path() const {
return EditorPaths::get_singleton()->get_project_settings_dir().path_join("quick_open_dialog_cache.cfg");
}
void QuickOpenResultContainer::_toggle_include_addons(bool p_pressed) {
EditorSettings::get_singleton()->set("filesystem/quick_open_dialog/include_addons", p_pressed);
cleanup();
_create_initial_results();
}
void QuickOpenResultContainer::_toggle_display_mode() {
QuickOpenDisplayMode new_display_mode = (content_display_mode == QuickOpenDisplayMode::LIST) ? QuickOpenDisplayMode::GRID : QuickOpenDisplayMode::LIST;
_set_display_mode(new_display_mode);
}
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);
prev_root->hide();
next_root->show();
for (QuickOpenResultItem *item : result_items) {
_layout_result_item(item);
}
_update_result_items(num_visible_results, selection_index);
if (content_display_mode == QuickOpenDisplayMode::LIST) {
display_mode_toggle->set_button_icon(get_editor_theme_icon(SNAME("FileThumbnail")));
display_mode_toggle->set_tooltip_text(TTR("Grid view"));
} else {
display_mode_toggle->set_button_icon(get_editor_theme_icon(SNAME("FileList")));
display_mode_toggle->set_tooltip_text(TTR("List view"));
}
}
bool QuickOpenResultContainer::has_nothing_selected() const {
return selection_index < 0;
}
ResourceUID::ID QuickOpenResultContainer::get_selected() const {
ERR_FAIL_COND_V_MSG(has_nothing_selected(), ResourceUID::INVALID_ID, "Tried to get selected file, but nothing was selected.");
return candidates[selection_index].uid;
}
String QuickOpenResultContainer::get_selected_path() const {
ERR_FAIL_COND_V_MSG(has_nothing_selected(), "", "Tried to get selected file path, but nothing was selected.");
String path = ResourceUID::get_singleton()->get_id_path(candidates[selection_index].uid);
ERR_FAIL_COND_V_MSG(path.is_empty(), "", "Failed to get selected file path.");
return path;
}
const Vector<StringName> &QuickOpenResultContainer::get_base_types() const {
return base_types;
}
QuickOpenDisplayMode QuickOpenResultContainer::get_adaptive_display_mode(const Vector<StringName> &p_base_types) {
static const Vector<StringName> grid_preferred_types = {
StringName("Font", true),
StringName("Texture2D", true),
StringName("Material", true),
StringName("Mesh", true),
};
for (const StringName &type : grid_preferred_types) {
for (const StringName &base_type : p_base_types) {
if (base_type == type || ClassDB::is_parent_class(base_type, type)) {
return QuickOpenDisplayMode::GRID;
}
}
}
return QuickOpenDisplayMode::LIST;
}
String _get_uid_string(const String &p_filepath) {
ResourceUID::ID id = EditorFileSystem::get_singleton()->get_file_uid(p_filepath);
return id == ResourceUID::INVALID_ID ? p_filepath : ResourceUID::get_singleton()->id_to_text(id);
}
bool QuickOpenResultContainer::is_instant_preview_enabled() const {
return instant_preview_toggle && instant_preview_toggle->is_visible() && instant_preview_toggle->is_pressed();
}
void QuickOpenResultContainer::set_instant_preview_toggle_visible(bool p_visible) {
instant_preview_toggle->set_visible(p_visible);
}
void QuickOpenResultContainer::save_selected_item() {
if (base_types.size() > 1) {
// Getting the type of the file and checking which base type it belongs to should be possible.
// However, for now these are not supported, and we don't record this.
return;
}
const StringName &base_type = base_types[0];
ResourceUID::ID selected = get_selected();
Vector<ResourceUID::ID> *type_history = selected_history.getptr(base_type);
if (!type_history) {
selected_history.insert(base_type, Vector<ResourceUID::ID>());
type_history = selected_history.getptr(base_type);
} else {
for (int i = 0; i < type_history->size(); i++) {
if (selected == type_history->get(i)) {
type_history->remove_at(i);
break;
}
}
}
history_set.insert(selected);
type_history->insert(0, selected);
if (type_history->size() > MAX_HISTORY_SIZE) {
type_history->resize(MAX_HISTORY_SIZE);
}
PackedStringArray history_uids;
history_uids.resize(type_history->size());
{
String *uids_write = history_uids.ptrw();
int i = 0;
for (const ResourceUID::ID &uid : *type_history) {
uids_write[i] = ResourceUID::get_singleton()->id_to_text(uid);
i++;
}
}
history_file->set_value("selected_history", base_type, history_uids);
history_file->save(_get_cache_file_path());
}
void QuickOpenResultContainer::cleanup() {
num_visible_results = 0;
candidates.clear();
history_set.clear();
_select_item(-1);
for (QuickOpenResultItem *item : result_items) {
item->reset();
}
}
void QuickOpenResultContainer::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_THEME_CHANGED: {
Color text_color = get_theme_color("font_readonly_color", EditorStringName(Editor));
file_details_path->add_theme_color_override(SceneStringName(font_color), text_color);
no_results_label->add_theme_color_override(SceneStringName(font_color), text_color);
file_context_menu->set_item_icon(FILE_SHOW_IN_FILESYSTEM, get_editor_theme_icon(SNAME("ShowInFileSystem")));
file_context_menu->set_item_icon(FILE_SHOW_IN_FILE_MANAGER, get_editor_theme_icon(SNAME("Filesystem")));
panel_container->add_theme_style_override(SceneStringName(panel), get_theme_stylebox(SceneStringName(panel), SNAME("Tree")));
if (content_display_mode == QuickOpenDisplayMode::LIST) {
display_mode_toggle->set_button_icon(get_editor_theme_icon(SNAME("FileThumbnail")));
} else {
display_mode_toggle->set_button_icon(get_editor_theme_icon(SNAME("FileList")));
}
} break;
}
}
void QuickOpenResultContainer::_bind_methods() {
ADD_SIGNAL(MethodInfo("selection_changed"));
ADD_SIGNAL(MethodInfo("result_clicked", PropertyInfo(Variant::BOOL, "double_click")));
}
//------------------------- Result Item
QuickOpenResultItem::QuickOpenResultItem() {
set_focus_mode(FocusMode::FOCUS_NONE);
_set_enabled(false);
list_item = memnew(QuickOpenResultListItem);
list_item->hide();
add_child(list_item);
grid_item = memnew(QuickOpenResultGridItem);
grid_item->hide();
add_child(grid_item);
}
void QuickOpenResultItem::set_display_mode(QuickOpenDisplayMode p_display_mode) {
if (p_display_mode == QuickOpenDisplayMode::LIST) {
grid_item->hide();
grid_item->reset();
list_item->show();
} else {
list_item->hide();
list_item->reset();
grid_item->show();
}
queue_redraw();
}
void QuickOpenResultItem::set_content(const QuickOpenResultCandidate &p_candidate) {
_set_enabled(true);
if (list_item->is_visible()) {
list_item->set_content(p_candidate, enable_highlights);
} else {
grid_item->set_content(p_candidate, enable_highlights);
}
queue_redraw();
}
void QuickOpenResultItem::reset() {
_set_enabled(false);
is_hovering = false;
is_selected = false;
list_item->reset();
grid_item->reset();
}
void QuickOpenResultItem::highlight_item(bool p_enabled) {
is_selected = p_enabled;
if (list_item->is_visible()) {
if (p_enabled) {
list_item->highlight_item(highlighted_font_color);
} else {
list_item->remove_highlight();
}
} else {
if (p_enabled) {
grid_item->highlight_item(highlighted_font_color);
} else {
grid_item->remove_highlight();
}
}
queue_redraw();
}
void QuickOpenResultItem::_set_enabled(bool p_enabled) {
set_visible(p_enabled);
set_process(p_enabled);
set_process_input(p_enabled);
}
void QuickOpenResultItem::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_MOUSE_ENTER:
case NOTIFICATION_MOUSE_EXIT: {
is_hovering = is_visible() && p_what == NOTIFICATION_MOUSE_ENTER;
queue_redraw();
} break;
case NOTIFICATION_THEME_CHANGED: {
selected_stylebox = get_theme_stylebox("selected", "Tree");
hovering_stylebox = get_theme_stylebox(SNAME("hovered"), "Tree");
highlighted_font_color = get_theme_color("font_focus_color", EditorStringName(Editor));
} break;
case NOTIFICATION_DRAW: {
if (is_selected) {
draw_style_box(selected_stylebox, Rect2(Point2(), get_size()));
} else if (is_hovering) {
draw_style_box(hovering_stylebox, Rect2(Point2(), get_size()));
}
} break;
}
}
//----------------- List item
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 };
}
QuickOpenResultListItem::QuickOpenResultListItem() {
set_h_size_flags(Control::SIZE_EXPAND_FILL);
add_theme_constant_override("margin_left", 6 * EDSCALE);
add_theme_constant_override("margin_right", 6 * EDSCALE);
hbc = memnew(HBoxContainer);
hbc->add_theme_constant_override(SNAME("separation"), 4 * EDSCALE);
add_child(hbc);
const int max_size = 36 * EDSCALE;
thumbnail = memnew(TextureRect);
thumbnail->set_h_size_flags(Control::SIZE_SHRINK_CENTER);
thumbnail->set_v_size_flags(Control::SIZE_SHRINK_CENTER);
thumbnail->set_expand_mode(TextureRect::EXPAND_IGNORE_SIZE);
thumbnail->set_stretch_mode(TextureRect::STRETCH_KEEP_ASPECT_CENTERED);
thumbnail->set_custom_minimum_size(Size2i(max_size, max_size));
hbc->add_child(thumbnail);
text_container = memnew(VBoxContainer);
text_container->add_theme_constant_override(SNAME("separation"), -7 * EDSCALE);
text_container->set_h_size_flags(Control::SIZE_EXPAND_FILL);
text_container->set_v_size_flags(Control::SIZE_FILL);
hbc->add_child(text_container);
name = memnew(HighlightedLabel);
name->set_h_size_flags(Control::SIZE_EXPAND_FILL);
name->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS);
name->set_horizontal_alignment(HorizontalAlignment::HORIZONTAL_ALIGNMENT_LEFT);
text_container->add_child(name);
path = memnew(HighlightedLabel);
path->set_h_size_flags(Control::SIZE_EXPAND_FILL);
path->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS);
path->add_theme_font_size_override(SceneStringName(font_size), 12 * EDSCALE);
text_container->add_child(path);
}
void QuickOpenResultListItem::set_content(const QuickOpenResultCandidate &p_candidate, bool p_highlight) {
thumbnail->set_texture(p_candidate.thumbnail);
String file_path = ResourceUID::get_singleton()->get_id_path(p_candidate.uid);
name->set_text(file_path.get_file());
path->set_text(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));
}
}
}
}
void QuickOpenResultListItem::reset() {
thumbnail->set_texture(nullptr);
name->set_text("");
path->set_text("");
name->reset_highlights();
path->reset_highlights();
}
void QuickOpenResultListItem::highlight_item(const Color &p_color) {
name->add_theme_color_override(SceneStringName(font_color), p_color);
}
void QuickOpenResultListItem::remove_highlight() {
name->remove_theme_color_override(SceneStringName(font_color));
}
void QuickOpenResultListItem::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_THEME_CHANGED: {
path->add_theme_color_override(SceneStringName(font_color), get_theme_color("font_disabled_color", EditorStringName(Editor)));
} break;
}
}
//--------------- Grid Item
QuickOpenResultGridItem::QuickOpenResultGridItem() {
set_custom_minimum_size(Size2i(120 * EDSCALE, 0));
add_theme_constant_override("margin_top", 6 * EDSCALE);
add_theme_constant_override("margin_left", 2 * EDSCALE);
add_theme_constant_override("margin_right", 2 * EDSCALE);
vbc = memnew(VBoxContainer);
vbc->set_h_size_flags(Control::SIZE_FILL);
vbc->set_v_size_flags(Control::SIZE_EXPAND_FILL);
vbc->add_theme_constant_override(SNAME("separation"), 0);
add_child(vbc);
const int max_size = 64 * EDSCALE;
thumbnail = memnew(TextureRect);
thumbnail->set_h_size_flags(Control::SIZE_SHRINK_CENTER);
thumbnail->set_v_size_flags(Control::SIZE_SHRINK_CENTER);
thumbnail->set_custom_minimum_size(Size2i(max_size, max_size));
vbc->add_child(thumbnail);
name = memnew(HighlightedLabel);
name->set_h_size_flags(Control::SIZE_EXPAND_FILL);
name->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS);
name->set_horizontal_alignment(HorizontalAlignment::HORIZONTAL_ALIGNMENT_CENTER);
name->add_theme_font_size_override(SceneStringName(font_size), 13 * EDSCALE);
vbc->add_child(name);
}
void QuickOpenResultGridItem::set_content(const QuickOpenResultCandidate &p_candidate, bool p_highlight) {
thumbnail->set_texture(p_candidate.thumbnail);
String file_path = ResourceUID::get_singleton()->get_id_path(p_candidate.uid);
name->set_text(file_path.get_file());
name->set_tooltip_text(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) {
thumbnail->set_expand_mode(TextureRect::EXPAND_KEEP_SIZE);
thumbnail->set_stretch_mode(TextureRect::StretchMode::STRETCH_KEEP_CENTERED);
} else {
thumbnail->set_expand_mode(TextureRect::EXPAND_FIT_WIDTH_PROPORTIONAL);
thumbnail->set_stretch_mode(TextureRect::StretchMode::STRETCH_SCALE);
}
}
void QuickOpenResultGridItem::reset() {
thumbnail->set_texture(nullptr);
name->set_text("");
name->reset_highlights();
}
void QuickOpenResultGridItem::highlight_item(const Color &p_color) {
name->add_theme_color_override(SceneStringName(font_color), p_color);
}
void QuickOpenResultGridItem::remove_highlight() {
name->remove_theme_color_override(SceneStringName(font_color));
}