Merge 4f7996b1ea into 760af804c0

editor/tree_search.cpp

@@ -56,34 +56,55 @@ void TreeSearch::_clean_callable_cache() {
 }
 
 void TreeSearch::_filter_tree(const String &p_search_mask) {
-	if (matching_entries.size() == 0) {
+	if (matching_entries.is_empty()) {
 		return;
 	}
 
+	Vector<bool> item_visibilities;
+	item_visibilities.resize(ordered_tree_items.size());
+	item_visibilities.fill(false);
+
+	// Make all entries visible that have any matching descendents. O(n)
 	for (int i = 0; i < ordered_tree_items.size(); i++) {
-		TreeItem *cur_item = ordered_tree_items[i];
-
-		if (number_matches.has(cur_item)) {
-			continue;
+		TreeItem *entry = ordered_tree_items[i];
+		if (number_matches.has(entry) && number_matches[entry] > 0) {
+			item_visibilities.set(i, true);
+		}
 	}
 
-		TreeItem *first_counting_ancestor = cur_item;
-		bool parents_visible = true;
-		while (first_counting_ancestor && !number_matches.has(first_counting_ancestor)) {
-			// Performance: we only need to check the first visible ancestor. This is already optimal because of the ordering in ordered_tree_items.
-			if (!first_counting_ancestor->is_visible()){
-				parents_visible = false;
-				break;
+	// Make all descendents of matching entries visible. O(n) * log(|matching_entries|)
+	for (int i = 0; i < ordered_tree_items.size(); i++) {
+		TreeItem *entry = ordered_tree_items[i];
+		if (_vector_has_bsearch(matching_entries, entry)) {
+			// the [next_entry] at the same depth or depth above.
+			TreeItem *next_entry = entry->get_next();
+
+			// search above current depth if no [next_entry].
+			while (!next_entry && entry) {
+				entry = entry->get_parent();
 			}
-			first_counting_ancestor = first_counting_ancestor->get_parent();
+			if (entry) {
+				next_entry = entry->get_next();
 			}
-		if (!parents_visible || !first_counting_ancestor || !_vector_has_bsearch(matching_entries, first_counting_ancestor)) {
-			cur_item->set_visible(false);
+
+			// mark visible all successors upto next entry at the same depth or above
+			int j = i;
+			for (; j < ordered_tree_items.size() && ordered_tree_items[j] != next_entry; j++) {
+				item_visibilities.set(j, true);
+			}
+			i = j - 1; // every entry is only processed once.
+		}
+	}
+
+	// Apply visibility. O(n)
+	for (int i = 0; i < ordered_tree_items.size(); i++) {
+		if (!item_visibilities[i]) {
+			ordered_tree_items[i]->set_visible(false);
 		}
 	}
 }
 
-// makes all tree items visible.
+// Makes all tree items visible.
 void TreeSearch::_clear_filter() {
 	ERR_FAIL_COND(!tree_reference);
 	Vector<TreeItem *> items = { tree_reference->get_root() };