From a80b737319da1ffeead4c3e250f303d6844817ae Mon Sep 17 00:00:00 2001 From: Alexander Montag Date: Wed, 25 Sep 2024 15:32:03 +0000 Subject: [PATCH] Implement tree search: highlighting --- editor/limbo_ai_editor_plugin.cpp | 6 +- editor/task_tree.cpp | 13 +- editor/task_tree.h | 4 +- editor/tree_search.cpp | 407 +++++++++++++++++++++++++++--- editor/tree_search.h | 81 ++++-- register_types.cpp | 1 + 6 files changed, 455 insertions(+), 57 deletions(-) diff --git a/editor/limbo_ai_editor_plugin.cpp b/editor/limbo_ai_editor_plugin.cpp index e2e9376..4300b4d 100644 --- a/editor/limbo_ai_editor_plugin.cpp +++ b/editor/limbo_ai_editor_plugin.cpp @@ -457,6 +457,8 @@ void LimboAIEditor::_process_shortcut_input(const Ref &p_event) { _on_save_pressed(); } else if (LW_IS_SHORTCUT("limbo_ai/load_behavior_tree", p_event)) { _popup_file_dialog(load_dialog); + } else if (LW_IS_SHORTCUT("limbo_ai/search_tree", p_event)) { + task_tree->tree_search_show_and_focus(); } else { handled = false; } @@ -800,7 +802,7 @@ void LimboAIEditor::_misc_option_selected(int p_id) { EDIT_SCRIPT(template_path); } break; case MISC_SEARCH_TREE: { - UtilityFunctions::print("Search Tree"); + task_tree->tree_search_show_and_focus(); } } } @@ -1520,6 +1522,8 @@ LimboAIEditor::LimboAIEditor() { LW_SHORTCUT("limbo_ai/jump_to_owner", TTR("Jump to Owner"), (Key)(LW_KEY_MASK(CMD_OR_CTRL) | LW_KEY(J))); LW_SHORTCUT("limbo_ai/close_tab", TTR("Close Tab"), (Key)(LW_KEY_MASK(CMD_OR_CTRL) | LW_KEY(W))); LW_SHORTCUT("limbo_ai/find_task", TTR("Find Task"), (Key)(LW_KEY_MASK(CMD_OR_CTRL) | LW_KEY(F))); + LW_SHORTCUT("limbo_ai/hide_tree_search", TTR("Hide BehaviorTrees Search Panel"), (Key)(LW_KEY(ESCAPE))); + LW_SHORTCUT("limbo_ai/search_tree", TTR("Shows the BehaviorTree Search Panel"), (Key)(LW_KEY_MASK(CMD_OR_CTRL) | LW_KEY(F))); set_process_shortcut_input(true); diff --git a/editor/task_tree.cpp b/editor/task_tree.cpp index d70e4d8..167ce1f 100644 --- a/editor/task_tree.cpp +++ b/editor/task_tree.cpp @@ -106,6 +106,7 @@ void TaskTree::_update_item(TreeItem *p_item) { if (!warning_text.is_empty()) { p_item->add_button(0, theme_cache.task_warning_icon, 0, false, warning_text); } + tree_search->on_item_edited(p_item); // this is necessary to preserve custom drawing from tree search. } void TaskTree::_update_tree() { @@ -125,7 +126,7 @@ void TaskTree::_update_tree() { for (const Ref &task : selection) { add_selection(task); } - tree_search.apply_search(tree); + tree_search->update_search(tree); } TreeItem *TaskTree::_find_item(const Ref &p_task) const { @@ -532,6 +533,8 @@ void TaskTree::_notification(int p_what) { tree->connect("multi_selected", callable_mp(this, &TaskTree::_on_item_selected).unbind(3), CONNECT_DEFERRED); tree->connect("item_activated", callable_mp(this, &TaskTree::_on_item_activated)); tree->connect("item_collapsed", callable_mp(this, &TaskTree::_on_item_collapsed)); + tree_search->search_panel->connect("text_changed", callable_mp(this, &TaskTree::_update_tree).unbind(1)); + tree_search->search_panel->connect("visibility_changed", callable_mp(this, &TaskTree::_update_tree)); } break; case NOTIFICATION_THEME_CHANGED: { _do_update_theme_item_cache(); @@ -564,6 +567,10 @@ void TaskTree::_bind_methods() { PropertyInfo(Variant::INT, "type"))); } +void TaskTree::tree_search_show_and_focus() { + tree_search->search_panel->show_and_focus(); +} + TaskTree::TaskTree() { editable = true; updating_tree = false; @@ -587,7 +594,9 @@ TaskTree::TaskTree() { tree->set_select_mode(Tree::SelectMode::SELECT_MULTI); tree->set_drag_forwarding(callable_mp(this, &TaskTree::_get_drag_data_fw), callable_mp(this, &TaskTree::_can_drop_data_fw), callable_mp(this, &TaskTree::_drop_data_fw)); - vbox_container->add_child(tree_search.search_panel); + + tree_search = memnew(TreeSearch); + vbox_container->add_child(tree_search->search_panel); } TaskTree::~TaskTree() { diff --git a/editor/task_tree.h b/editor/task_tree.h index 897a8b3..e75ed72 100644 --- a/editor/task_tree.h +++ b/editor/task_tree.h @@ -46,7 +46,7 @@ private: bool editable; bool updating_tree; HashMap probability_rect_cache; - TreeSearch tree_search; + TreeSearch * tree_search; struct ThemeCache { Ref comment_font; @@ -101,6 +101,7 @@ public: Ref get_selected() const; Vector> get_selected_tasks() const; void clear_selection(); + void tree_search_show_and_focus(); Rect2 get_selected_probability_rect() const; double get_selected_probability_weight() const; @@ -108,6 +109,7 @@ public: bool selected_has_probability() const; virtual bool editor_can_reload_from_file() { return false; } + TaskTree(); ~TaskTree(); diff --git a/editor/tree_search.cpp b/editor/tree_search.cpp index 3b78d08..23ba40e 100644 --- a/editor/tree_search.cpp +++ b/editor/tree_search.cpp @@ -9,16 +9,35 @@ * ============================================================================= */ +#ifdef TOOLS_ENABLED + #include "tree_search.h" -#include "../util/limbo_compat.h" // for edge scale +#include "../bt/behavior_tree.h" +#include "../util/limbo_compat.h" // for edscale #include "../util/limbo_string_names.h" #include "../util/limbo_utility.h" -#include -#include // for edge scale -#include -#ifdef TOOLS_ENABLED +#ifdef LIMBOAI_MODULE +#include "core/math/math_funcs.h" +#include "editor/editor_interface.h" +#include "editor/themes/editor_scale.h" +#include "scene/resources/font.h" +#include "scene/gui/separator.h" +#include "scene/resources/style_box_flat.h" +#include "scene/main/viewport.h" +#endif // LIMBOAI_MODULE + +#ifdef LIMBOAI_GDEXTENSION +#include +#include // for edge scale +#include +#include +#include +#include +#endif // LIMBOAI_GDEXTENSION + +#define UPPER_BOUND (1 << 15) // for substring search. /* ------- TreeSearchPanel ------- */ @@ -34,7 +53,9 @@ void TreeSearchPanel::_initialize_controls() { label_highlight->set_text(TTR("Highlight")); label_filter->set_text(TTR("Filter")); - close_button->set_button_icon(get_theme_icon(LW_NAME(Close), LW_NAME(EditorIcons))); + BUTTON_SET_ICON(close_button, get_theme_icon(LW_NAME(Close), LW_NAME(EditorIcons))); + close_button->set_theme_type_variation("FlatButton"); + // positioning and sizing this->set_anchors_and_offsets_preset(LayoutPreset::PRESET_BOTTOM_WIDE); this->set_v_size_flags(SIZE_SHRINK_CENTER); // Do not expand vertically @@ -42,26 +63,59 @@ void TreeSearchPanel::_initialize_controls() { // hack add separator to the left so line edit doesn't clip. line_edit_search->set_h_size_flags(SIZE_EXPAND_FILL); - add_spacer(0.25); // otherwise the lineedits expand margin touches the left border. + _add_spacer(0.25); // otherwise the lineedits expand margin touches the left border. add_child(line_edit_search); - add_spacer(); + _add_spacer(); add_child(label_highlight); add_child(check_button_filter_highlight); add_child(label_filter); add_child(close_button); - add_spacer(0.25); + _add_spacer(0.25); } -void TreeSearchPanel::add_spacer(float width_multiplier) { +void TreeSearchPanel::_initialize_close_callbacks() { + Callable calleable_set_invisible = Callable(this, "set_visible").bind(false); // don't need a custom bind. + close_button->connect("pressed", calleable_set_invisible); + close_button->set_shortcut(LW_GET_SHORTCUT("limbo_ai/hide_tree_search")); +} + +void TreeSearchPanel::_add_spacer(float p_width_multiplier) { Control *spacer = memnew(Control); - spacer->set_custom_minimum_size(Vector2(8.0 * EDSCALE * width_multiplier, 0.0)); + spacer->set_custom_minimum_size(Vector2(8.0 * EDSCALE * p_width_multiplier, 0.0)); add_child(spacer); } -/* !TreeSearchPanel */ +void TreeSearchPanel::_emit_text_changed(const String &p_text) { + this->emit_signal("text_changed", p_text); +} + +void TreeSearchPanel::_emit_text_submitted(const String &p_text) { + this->emit_signal("text_submitted"); +} + +void TreeSearchPanel::_notification(int p_what) { + switch (p_what) { + case NOTIFICATION_READY: { + _initialize_controls(); + line_edit_search->connect("text_changed", callable_mp(this, &TreeSearchPanel::_emit_text_changed)); + _initialize_close_callbacks(); + line_edit_search->connect("text_submitted", callable_mp(this, &TreeSearchPanel::_emit_text_submitted)); + break; + } + } +} + +void TreeSearchPanel::_bind_methods() { + ADD_SIGNAL(MethodInfo("text_changed")); + ADD_SIGNAL(MethodInfo("text_submitted")); +} TreeSearchPanel::TreeSearchPanel() { - _initialize_controls(); + this->set_visible(false); +} + +bool TreeSearchPanel::has_focus() { + return false; } TreeSearchMode TreeSearchPanel::get_search_mode() { @@ -77,33 +131,324 @@ String TreeSearchPanel::get_text() { return line_edit_search->get_text(); } +void TreeSearchPanel::show_and_focus() { + this->set_visible(true); + line_edit_search->grab_focus(); +} + +/* !TreeSearchPanel */ + /* ------- TreeSearch ------- */ -void TreeSearch::filter_tree(TreeItem *tree_item, String search_mask) { - PRINT_LINE("filter tree not yet implemented!", search_mask); +void TreeSearch::_filter_tree(TreeItem *p_tree_item, const String &p_search_mask) { + for (int i = 0; i < ordered_tree_items.size(); i++){ + + } + PRINT_LINE("filter tree not yet implemented!", p_search_mask); } -void TreeSearch::highlight_tree(TreeItem *tree_item, String search_mask) { - PRINT_LINE("highlight tree not yet implemented! ", search_mask); - // queue/iterative instead of recursive approach. dsf - Vector queue; - Vector hits; +void TreeSearch::_highlight_tree(const String &p_search_mask) { + callable_cache.clear(); + for (int i = 0; i < ordered_tree_items.size(); i++) { + TreeItem *entry = ordered_tree_items[i]; + + int num_m = number_matches.has(entry) ? number_matches.get(entry) : 0; + if (num_m == 0){ + continue;; + } + + // make sure to also call any draw method already defined. + Callable parent_draw_method; + if (entry->get_cell_mode(0) == TreeItem::CELL_MODE_CUSTOM) { + parent_draw_method = entry->get_custom_draw_callback(0); + } + + Callable draw_callback = callable_mp(this, &TreeSearch::_draw_highlight_item).bind(p_search_mask, parent_draw_method); + + // -- this is necessary because of the modularity of this implementation + // cache render properties of entry + String cached_text = entry->get_text(0); + Ref cached_icon = entry->get_icon(0); + int cached_max_width = entry->get_icon_max_width(0); + callable_cache[entry] = draw_callback; + + // this removes render properties in entry + entry->set_custom_draw_callback(0, draw_callback); + entry->set_cell_mode(0, TreeItem::CELL_MODE_CUSTOM); + + // restore render properties + entry->set_text(0, cached_text); + entry->set_icon(0, cached_icon); + entry->set_icon_max_width(0, cached_max_width); + } } -// Call this as a post-processing step for the already constructed tree. -void TreeSearch::apply_search(Tree *tree) { - if (!search_panel || !search_panel->is_visible()){ +// custom draw callback for highlighting (bind 2) +void TreeSearch::_draw_highlight_item(TreeItem *p_tree_item, Rect2 p_rect, String p_search_mask, Callable p_parent_draw_method) { + if (!p_tree_item) + return; + // call any parent draw methods such as for probability FIRST. + p_parent_draw_method.call(p_tree_item, p_rect); + + // first part: outline + if (matching_entries.has(p_tree_item)) { + + // font info + Ref font = p_tree_item->get_custom_font(0); + if (font.is_null()) { + font = p_tree_item->get_tree()->get_theme_font(LW_NAME(font)); + } + ERR_FAIL_NULL(font); + double font_size = p_tree_item->get_custom_font_size(0); + if (font_size == -1) { + font_size = p_tree_item->get_tree()->get_theme_font_size(LW_NAME(font)); + } + + // substring size + String string_full = p_tree_item->get_text(0); + StringSearchIndices substring_idx = _substring_bounds(string_full, p_search_mask); + + String substring_match = string_full.substr(substring_idx.lower, substring_idx.upper - substring_idx.lower); + Vector2 substring_match_size = font->get_string_size(substring_match, HORIZONTAL_ALIGNMENT_LEFT, -1.f, font_size); + + String substring_before = string_full.substr(0, substring_idx.lower); + Vector2 substring_before_size = font->get_string_size(substring_before, HORIZONTAL_ALIGNMENT_LEFT, -1.f, font_size); + + // stylebox + Ref stylebox = p_tree_item->get_tree()->get_theme_stylebox("Focus"); + ERR_FAIL_NULL(stylebox); + + // extract separation + float h_sep = p_tree_item->get_tree()->get_theme_constant("h_separation"); + + // compose draw rect + const Vector2 PADDING = Vector2(4., 2.); + Rect2 draw_rect = p_rect; + + Vector2 rect_offset = Vector2(substring_before_size.x, 0); + rect_offset.x += p_tree_item->get_icon_max_width(0) * EDSCALE; + rect_offset.x += (h_sep + 4.) * EDSCALE; // TODO: Find better way to determine texts x-offset + rect_offset.y = (p_rect.size.y - substring_match_size.y) / 2; // center box vertically + + draw_rect.position += rect_offset - PADDING / 2; + draw_rect.size = substring_match_size + PADDING; + + // draw + stylebox->draw(p_tree_item->get_tree()->get_canvas_item(), draw_rect); + } + + // second part: draw number (TODO: maybe use columns) + int num_mat = number_matches.has(p_tree_item) ? number_matches.get(p_tree_item) : 0; + if (num_mat > 0) { + float h_sep = p_tree_item->get_tree()->get_theme_constant("h_separation"); + Ref font = tree_reference->get_theme_font("font"); + float font_size = tree_reference->get_theme_font_size("font") * 0.75; + + String num_string = String::num_int64(num_mat); + Vector2 string_size = font->get_string_size(num_string, HORIZONTAL_ALIGNMENT_CENTER, -1, font_size); + Vector2 text_pos = p_rect.position; + + text_pos.x += p_rect.size.x - string_size.x - h_sep; + text_pos.y += font->get_descent(font_size) + p_rect.size.y / 2.; // center vertically + + font->draw_string(tree_reference->get_canvas_item(), text_pos, num_string, HORIZONTAL_ALIGNMENT_CENTER, -1, font_size); + } +} + +void TreeSearch::_update_matching_entries(const String &search_mask) { + Vector accum; + matching_entries = _find_matching_entries(tree_reference->get_root(), search_mask, accum); +} + +/* this linearizes the tree into [ordered_tree_items] like so: + - i1 + - i2 + - i3 + - i4 ---> [i1,i2,i3,i4] +*/ +void TreeSearch::_update_ordered_tree_items(TreeItem *p_tree_item) { + if (!p_tree_item) + return; + if (p_tree_item == p_tree_item->get_tree()->get_root()) { + ordered_tree_items.clear(); + } + // Add the current item to the list + ordered_tree_items.push_back(p_tree_item); + + // Recursively collect items from the first child + TreeItem *child = p_tree_item->get_first_child(); + while (child) { + _update_ordered_tree_items(child); + child = child->get_next(); + } +} + +void TreeSearch::_update_number_matches() { + number_matches.clear(); + for (int i = 0; i < matching_entries.size(); i++) { + TreeItem *item = matching_entries[i]; + while (item) { + int old_num_value = number_matches.has(item) ? number_matches.get(item) : 0; + number_matches[item] = old_num_value + 1; + item = item->get_parent(); + } + } +} + +Vector TreeSearch::_find_matching_entries(TreeItem *p_tree_item, const String &p_search_mask, Vector &p_accum) { + if (!p_tree_item) + return p_accum; + StringSearchIndices item_search_indices = _substring_bounds(p_tree_item->get_text(0), p_search_mask); + if (item_search_indices.hit()) + p_accum.insert(p_accum.bsearch(p_tree_item, true), p_tree_item); + + for (int i = 0; i < p_tree_item->get_child_count(); i++) { + TreeItem *child = p_tree_item->get_child(i); + _find_matching_entries(child, p_search_mask, p_accum); + } + return p_accum; +} + +// Returns the lower and upper bounds of a substring. Does fuzzy search: Simply looks if words exist in right ordering. +// Also ignores case if p_search_mask is lowercase. Example: +// p_searcheable = "TimeLimit 2 sec", p_search_mask = limit 2 sec -> [4,14]. With p_search_mask = "LimiT 2 SEC" or "Limit sec 2" -> [-1,-1] +TreeSearch::StringSearchIndices TreeSearch::_substring_bounds(const String &p_searchable, const String &p_search_mask) const { + StringSearchIndices result; + result.lower = UPPER_BOUND; + result.upper = 0; + + if (p_search_mask.is_empty()) { + return result; // Early return if search_mask is empty. + } + + // Determine if the search should be case-insensitive. + bool is_case_insensitive = (p_search_mask == p_search_mask.to_lower()); + String searchable_processed = is_case_insensitive ? p_searchable.to_lower() : p_searchable; + PackedStringArray words = p_search_mask.split(" "); + int word_position = 0; + for (const String &word : words) { + if (word.is_empty()) { + continue; // Skip empty words. + } + + String word_processed = is_case_insensitive ? word.to_lower() : word; + + // Find the position of the next word in the searchable string. + word_position = searchable_processed.find(word_processed, word_position); + + if (word_position < 0) { + // If any word is not found, return an empty StringSearchIndices. + return StringSearchIndices(); + } + + // Update lower and upper bounds. + result.lower = MIN(result.lower, word_position); + result.upper = MAX(result.upper, static_cast(word_position + word.length())); + } + + return result; +} + +void TreeSearch::_select_item(TreeItem *item) { + if (!item) + return; + tree_reference->set_selected(item, 0); + tree_reference->scroll_to_item(item); + item = item->get_parent(); + while (item) { + item->set_collapsed(false); + item = item->get_parent(); + } +} + +void TreeSearch::_select_first_match() { + if (matching_entries.size() == 0) { + return; + } + for (int i = 0; i < ordered_tree_items.size(); i++) { + TreeItem *item = ordered_tree_items[i]; + int match_idx = matching_entries.bsearch(item, true); + if (match_idx < 0 || match_idx >= matching_entries.size() || matching_entries[match_idx] != item) { + continue; + } + String debug_string = "["; + _select_item(item); + return; + } +} + +void TreeSearch::_select_next_match() { + if (matching_entries.size() == 0) { + return; + } + TreeItem *selected = tree_reference->get_selected(); // we care about a single item here. + if (!selected) { + _select_first_match(); return; } - TreeItem * tree_root = tree->get_root(); - String search_mask = search_panel->get_text(); - TreeSearchMode search_mode = search_panel->get_search_mode(); - if (search_mode == TreeSearchMode::HIGHLIGHT){ - highlight_tree(tree_root, search_mask); + int selected_idx = -1; + for (int i = 0; i < ordered_tree_items.size(); i++) { + if (ordered_tree_items[i] == selected) { + selected_idx = i; + break; + } } - if (search_mode == TreeSearchMode::FILTER){ - filter_tree(tree_root, search_mask); + + // find the best fitting entry. + for (int i = 0; i < ordered_tree_items.size(); i++) { + TreeItem *item = ordered_tree_items[i]; + int match_idx = matching_entries.bsearch(item, true); + if (match_idx < 0 || match_idx >= matching_entries.size() || selected_idx >= i || matching_entries[match_idx] != item) { + continue; + } + + _select_item(item); + return; + } + _select_first_match(); // wrap around. +} + +void TreeSearch::on_item_edited(TreeItem * item) { + if (item->get_cell_mode(0) != TreeItem::CELL_MODE_CUSTOM){ + return; + } + + if (!callable_cache.has(item) || item->get_custom_draw_callback(0) == callable_cache.get(item)){ + return; + } + + item->set_custom_draw_callback(0,callable_cache.get(item)); +} + +// Call this as a post-processing step for the already constructed tree. +void TreeSearch::update_search(Tree *p_tree) { + ERR_FAIL_COND(!search_panel || !p_tree); + + // ignore if panel not visible or no search string is given. + if (!search_panel->is_visible() || search_panel->get_text().length() == 0) { + return; + } + + tree_reference = p_tree; + + String search_mask = search_panel->get_text(); + TreeItem *tree_root = p_tree->get_root(); + TreeSearchMode search_mode = search_panel->get_search_mode(); + + _update_ordered_tree_items(p_tree->get_root()); + _update_matching_entries(search_mask); + _update_number_matches(); + + + if (search_mode == TreeSearchMode::HIGHLIGHT) { + _highlight_tree(search_mask); + if (!search_panel->is_connected("text_submitted", callable_mp(this, &TreeSearch::_select_next_match))) { + search_panel->connect("text_submitted", callable_mp(this, &TreeSearch::_select_next_match)); + } + } + if (search_mode == TreeSearchMode::FILTER) { + _filter_tree(tree_root, search_mask); } } @@ -116,4 +461,4 @@ TreeSearch::~TreeSearch() { /* !TreeSearch */ -#endif // ! TOOLS_ENABLED \ No newline at end of file +#endif // TOOLS_ENABLED \ No newline at end of file diff --git a/editor/tree_search.h b/editor/tree_search.h index 026fe87..5786cb1 100644 --- a/editor/tree_search.h +++ b/editor/tree_search.h @@ -18,62 +18,99 @@ #ifdef LIMBOAI_GDEXTENSION #include -#include #include +#include #include #include -#include -#include + #endif // LIMBOAI_GDEXTENSION #ifdef LIMBOAI_MODULE -// TODO: Add includes for godot module variant. +#include "scene/gui/check_button.h" +#include "scene/gui/box_container.h" +#include "scene/gui/label.h" +#include "scene/gui/line_edit.h" +#include "scene/gui/tree.h" #endif // LIMBOAI_MODULE using namespace godot; enum TreeSearchMode { - HIGHLIGHT = 0, - FILTER = 1 + HIGHLIGHT = 0, + FILTER = 1 }; class TreeSearchPanel : public HBoxContainer { -GDCLASS(TreeSearchPanel, HBoxContainer) + GDCLASS(TreeSearchPanel, HBoxContainer) private: Button *toggle_button_filter_highlight; Button *close_button; - Label * label_highlight; - Label * label_filter; + Label *label_highlight; + Label *label_filter; LineEdit *line_edit_search; CheckButton *check_button_filter_highlight; - void _initialize_controls(); - void add_spacer(float width_multiplier = 1.f); - + void _initialize_close_callbacks(); + void _add_spacer(float width_multiplier = 1.f); + void _on_draw_highlight(TreeItem *item, Rect2 rect); + void _emit_text_changed(const String &text); + void _emit_text_submitted(const String &p_text); + void _notification(int p_what); protected: - static void _bind_methods(){}; // we don't need anything exposed. + static void _bind_methods(); + void _process_shortcut_input(const Ref &p_event); public: TreeSearchMode get_search_mode(); String get_text(); - + void show_and_focus(); TreeSearchPanel(); + bool has_focus(); }; -class TreeSearch { +class TreeSearch : public RefCounted { + GDCLASS(TreeSearch, RefCounted) private: - void filter_tree(TreeItem *tree_item, String search_mask); - void highlight_tree(TreeItem *tree_item, String search_mask); + struct StringSearchIndices { + // initialize to opposite bounds. + int lower = -1; + int upper = -1; - void highlight_item(TreeItem * tree_item, String search_mask); - Vector find_matching_entries(TreeItem * tree_item, Vector buffer = Vector()); + bool hit() { + return 0 <= lower && lower < upper; + } + }; + + Tree * tree_reference; + + Vector ordered_tree_items; + Vector matching_entries; + HashMap number_matches; + HashMap callable_cache; + + void _filter_tree(TreeItem *tree_item, const String &search_mask); + void _highlight_tree(const String &p_search_mask); + void _draw_highlight_item(TreeItem *tree_item, Rect2 rect, String search_mask, Callable parent_draw_method); + void _update_matching_entries(const String &search_mask); + void _update_ordered_tree_items(TreeItem *tree_item); + void _update_number_matches(); + Vector _find_matching_entries(TreeItem *tree_item, const String &search_mask, Vector &buffer); + StringSearchIndices _substring_bounds(const String &searchable, const String &search_mask) const; + + void _select_item(TreeItem * item); + void _select_first_match(); + void _select_next_match(); + + +protected: + static void _bind_methods(){} public: // we will add everything from TaskTree.h - void apply_search(Tree *tree); - void set_search_evaluation_method(Callable method); + void update_search(Tree *tree); + void on_item_edited(TreeItem *item); TreeSearchPanel *search_panel; TreeSearch(); @@ -81,4 +118,4 @@ public: }; #endif // TREE_SEARCH_H -#endif // ! TOOLS_ENABLED +#endif // ! TOOLS_ENABLED \ No newline at end of file diff --git a/register_types.cpp b/register_types.cpp index 0eb4d60..162df4b 100644 --- a/register_types.cpp +++ b/register_types.cpp @@ -269,6 +269,7 @@ void initialize_limboai_module(ModuleInitializationLevel p_level) { GDREGISTER_CLASS(LimboAIEditor); GDREGISTER_CLASS(LimboAIEditorPlugin); GDREGISTER_INTERNAL_CLASS(TreeSearchPanel); + GDREGISTER_INTERNAL_CLASS(TreeSearch); #endif // LIMBOAI_GDEXTENSION EditorPlugins::add_by_type();