Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

csv_preview: Refine filter popover UI (#61138)

Oleksandr Kholiavko1764c2fa6776
diff --git a/Cargo.lock b/Cargo.lock
index 8c6c525480f..10cb9751dc8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4580,8 +4580,10 @@ dependencies = [
"anyhow",
"editor",
"feature_flags",
+ "fuzzy",
"gpui",
"log",
+ "picker",
"text",
"ui",
"workspace",
diff --git a/crates/csv_preview/Cargo.toml b/crates/csv_preview/Cargo.toml
index ff4c0a61240..1dbec1cc58d 100644
--- a/crates/csv_preview/Cargo.toml
+++ b/crates/csv_preview/Cargo.toml
@@ -10,8 +10,10 @@ path = "src/csv_preview.rs"
[dependencies]
anyhow.workspace = true
feature_flags.workspace = true
+fuzzy.workspace = true
gpui.workspace = true
editor.workspace = true
+picker.workspace = true
ui.workspace = true
workspace.workspace = true
log.workspace = true
diff --git a/crates/csv_preview/src/renderer/table_header.rs b/crates/csv_preview/src/renderer/table_header.rs
index 444ee090993..bc96f239026 100644
--- a/crates/csv_preview/src/renderer/table_header.rs
+++ b/crates/csv_preview/src/renderer/table_header.rs
@@ -1,6 +1,19 @@
-use gpui::ElementId;
+use std::{
+ collections::HashMap,
+ sync::{
+ Arc,
+ atomic::{AtomicBool, Ordering},
+ },
+};
+
+use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
+use gpui::{
+ BackgroundExecutor, DismissEvent, ElementId, Entity, Focusable, ForegroundExecutor, Task,
+};
+use picker::{Picker, PickerDelegate};
use ui::{
- ContextMenu, GradientFade, IconButton, IconName, IconSize, PopoverMenu, Tooltip, prelude::*,
+ Color, GradientFade, HighlightedLabel, Icon, IconButton, IconName, IconSize, Label, LabelSize,
+ ListItem, ListItemSpacing, PopoverMenu, Tooltip, prelude::*,
};
use crate::{
@@ -13,6 +26,494 @@ use crate::{
types::AnyColumn,
};
+struct ColumnFilterRow {
+ entry: FilterEntry,
+ is_applied: bool,
+ /// Set when this value is hidden because another column's active filter
+ /// excludes every row containing it.
+ hidden_by: Option<AnyColumn>,
+}
+
+enum ColumnFilterListEntry {
+ Header(SharedString),
+ Row {
+ row_index: usize,
+ positions: Vec<usize>,
+ },
+}
+
+struct ColumnFilterDelegate {
+ col: AnyColumn,
+ view: Entity<CsvPreviewView>,
+ /// Row order frozen at open time (available entries sorted per the
+ /// column's `FilterSortOrder`, then entries hidden by other columns'
+ /// filters). Kept stable so toggling a value doesn't reshuffle the list
+ /// under the user's cursor; only `is_applied`/`hidden_by`/counts are
+ /// refreshed in place after a toggle.
+ rows: Vec<ColumnFilterRow>,
+ /// Number of available (non-hidden) rows, shown in the search placeholder.
+ available_count: usize,
+ string_candidates: Arc<Vec<StringMatchCandidate>>,
+ filtered: Vec<ColumnFilterListEntry>,
+ selected_index: usize,
+ query: String,
+ foreground: ForegroundExecutor,
+ background: BackgroundExecutor,
+ cancel: Option<Arc<AtomicBool>>,
+}
+
+impl ColumnFilterDelegate {
+ fn new(
+ col: AnyColumn,
+ view: Entity<CsvPreviewView>,
+ sort_order: FilterSortOrder,
+ column_filters: Arc<Vec<(FilterEntry, FilterEntryState)>>,
+ cx: &mut Context<Picker<Self>>,
+ ) -> Self {
+ let mut available: Vec<(FilterEntry, bool)> = Vec::new();
+ let mut hidden: Vec<(FilterEntry, AnyColumn)> = Vec::new();
+ for (entry, state) in column_filters.iter() {
+ match state {
+ FilterEntryState::Available { is_applied } => {
+ available.push((entry.clone(), *is_applied))
+ }
+ FilterEntryState::Unavailable { blocked_by } => {
+ hidden.push((entry.clone(), *blocked_by))
+ }
+ }
+ }
+
+ match sort_order {
+ FilterSortOrder::AlphaThenCount => available.sort_by(|(a, a_app), (b, b_app)| {
+ b_app
+ .cmp(a_app)
+ .then_with(|| a.content.cmp(&b.content))
+ .then_with(|| b.occurred_times().cmp(&a.occurred_times()))
+ }),
+ FilterSortOrder::CountThenAlpha => available.sort_by(|(a, a_app), (b, b_app)| {
+ b_app
+ .cmp(a_app)
+ .then_with(|| b.occurred_times().cmp(&a.occurred_times()))
+ .then_with(|| a.content.cmp(&b.content))
+ }),
+ }
+
+ let available_count = available.len();
+
+ let rows: Vec<ColumnFilterRow> = available
+ .into_iter()
+ .map(|(entry, is_applied)| ColumnFilterRow {
+ entry,
+ is_applied,
+ hidden_by: None,
+ })
+ .chain(
+ hidden
+ .into_iter()
+ .map(|(entry, blocked_by)| ColumnFilterRow {
+ entry,
+ is_applied: false,
+ hidden_by: Some(blocked_by),
+ }),
+ )
+ .collect();
+
+ let string_candidates = Arc::new(
+ rows.iter()
+ .enumerate()
+ .map(|(index, row)| {
+ StringMatchCandidate::new(index, &Self::display_text(&row.entry))
+ })
+ .collect::<Vec<_>>(),
+ );
+
+ let filtered = Self::build_entries(
+ &rows,
+ rows.iter()
+ .enumerate()
+ .map(|(index, _)| (index, Vec::new()))
+ .collect(),
+ );
+
+ Self {
+ col,
+ view,
+ rows,
+ available_count,
+ string_candidates,
+ filtered,
+ selected_index: 0,
+ query: String::new(),
+ foreground: cx.foreground_executor().clone(),
+ background: cx.background_executor().clone(),
+ cancel: None,
+ }
+ }
+
+ fn display_text(entry: &FilterEntry) -> String {
+ match &entry.content {
+ Some(s) => s.as_ref().to_owned(),
+ None => "<null>".to_owned(),
+ }
+ }
+
+ /// Assembles the flat list shown to the user from matched
+ /// `(row_index, positions)` pairs (which must be sorted ascending by
+ /// `row_index`, matching `rows`' available-then-hidden order), inserting a
+ /// "Hidden by other filters" header before the first hidden row.
+ fn build_entries(
+ rows: &[ColumnFilterRow],
+ matches: Vec<(usize, Vec<usize>)>,
+ ) -> Vec<ColumnFilterListEntry> {
+ let mut entries = Vec::with_capacity(matches.len() + 1);
+ let mut header_inserted = false;
+ for (row_index, positions) in matches {
+ if rows[row_index].hidden_by.is_some() && !header_inserted {
+ entries.push(ColumnFilterListEntry::Header(
+ "Hidden by other filters".into(),
+ ));
+ header_inserted = true;
+ }
+ entries.push(ColumnFilterListEntry::Row {
+ row_index,
+ positions,
+ });
+ }
+ entries
+ }
+
+ fn first_selectable_index(&self) -> usize {
+ self.filtered
+ .iter()
+ .position(|entry| {
+ matches!(entry, ColumnFilterListEntry::Row { row_index, .. }
+ if self.rows[*row_index].hidden_by.is_none())
+ })
+ .unwrap_or(0)
+ }
+
+ fn matches_for_query(&self, query: &str) -> Vec<(usize, Vec<usize>)> {
+ if query.is_empty() {
+ return self
+ .rows
+ .iter()
+ .enumerate()
+ .map(|(index, _)| (index, Vec::new()))
+ .collect();
+ }
+
+ let cancel_flag = AtomicBool::new(false);
+ let mut matches: Vec<StringMatch> = self.foreground.block_on(match_strings(
+ self.string_candidates.as_ref(),
+ query,
+ false,
+ true,
+ usize::MAX,
+ &cancel_flag,
+ self.background.clone(),
+ ));
+ matches.sort_by_key(|m| m.candidate_id);
+ matches
+ .into_iter()
+ .map(|m| (m.candidate_id, m.positions))
+ .collect()
+ }
+
+ /// Re-fetches this column's filter entries from the engine (e.g. after a
+ /// toggle changes counts/availability across the cascade) while keeping
+ /// `rows`' frozen order, then re-applies the current search query.
+ fn refresh_rows(&mut self, cx: &mut Context<Picker<Self>>) {
+ let column_filters = match self.view.read(cx).engine.get_filters_for_column(self.col) {
+ Ok(filters) => filters,
+ Err(err) => {
+ log::error!("Failed to get filters for column: {err}");
+ return;
+ }
+ };
+
+ let mut lookup: HashMap<Option<SharedString>, (FilterEntry, FilterEntryState)> =
+ column_filters
+ .iter()
+ .map(|(entry, state)| (entry.content.clone(), (entry.clone(), *state)))
+ .collect();
+
+ for row in &mut self.rows {
+ let Some((entry, state)) = lookup.remove(&row.entry.content) else {
+ continue;
+ };
+ row.entry = entry;
+ match state {
+ FilterEntryState::Available { is_applied } => {
+ row.is_applied = is_applied;
+ row.hidden_by = None;
+ }
+ FilterEntryState::Unavailable { blocked_by } => {
+ row.is_applied = false;
+ row.hidden_by = Some(blocked_by);
+ }
+ }
+ }
+
+ self.filtered = Self::build_entries(&self.rows, self.matches_for_query(&self.query));
+ self.selected_index = self
+ .selected_index
+ .min(self.filtered.len().saturating_sub(1));
+ }
+}
+
+impl PickerDelegate for ColumnFilterDelegate {
+ type ListItem = AnyElement;
+
+ fn name() -> &'static str {
+ "csv column filter"
+ }
+
+ fn match_count(&self) -> usize {
+ self.filtered.len()
+ }
+
+ fn selected_index(&self) -> usize {
+ self.selected_index
+ }
+
+ fn set_selected_index(
+ &mut self,
+ ix: usize,
+ _window: &mut Window,
+ cx: &mut Context<Picker<Self>>,
+ ) {
+ self.selected_index = ix.min(self.filtered.len().saturating_sub(1));
+ cx.notify();
+ }
+
+ fn can_select(&self, ix: usize, _window: &mut Window, _cx: &mut Context<Picker<Self>>) -> bool {
+ match self.filtered.get(ix) {
+ Some(ColumnFilterListEntry::Row { row_index, .. }) => {
+ self.rows[*row_index].hidden_by.is_none()
+ }
+ _ => false,
+ }
+ }
+
+ fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+ format!("Search {} unique values…", self.available_count).into()
+ }
+
+ fn update_matches(
+ &mut self,
+ query: String,
+ window: &mut Window,
+ cx: &mut Context<Picker<Self>>,
+ ) -> Task<()> {
+ self.query = query.clone();
+
+ if query.is_empty() {
+ self.filtered = Self::build_entries(&self.rows, self.matches_for_query(&query));
+ self.selected_index = self.first_selectable_index();
+ cx.notify();
+ return Task::ready(());
+ }
+
+ if let Some(prev) = &self.cancel {
+ prev.store(true, Ordering::Relaxed);
+ }
+ let cancel = Arc::new(AtomicBool::new(false));
+ self.cancel = Some(cancel.clone());
+
+ let string_candidates = self.string_candidates.clone();
+ let background = self.background.clone();
+
+ cx.spawn_in(window, async move |this, cx| {
+ let mut matches = match_strings(
+ string_candidates.as_ref(),
+ &query,
+ false,
+ true,
+ usize::MAX,
+ cancel.as_ref(),
+ background,
+ )
+ .await;
+ matches.sort_by_key(|m| m.candidate_id);
+
+ this.update_in(cx, |this, _, cx| {
+ if this.delegate.query != query {
+ return;
+ }
+ let rows = &this.delegate.rows;
+ let matches = matches
+ .into_iter()
+ .map(|m| (m.candidate_id, m.positions))
+ .collect();
+ this.delegate.filtered = ColumnFilterDelegate::build_entries(rows, matches);
+ this.delegate.selected_index = this.delegate.first_selectable_index();
+ cx.notify();
+ })
+ .ok();
+ })
+ }
+
+ fn confirm(&mut self, _secondary: bool, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+ let Some(ColumnFilterListEntry::Row { row_index, .. }) =
+ self.filtered.get(self.selected_index)
+ else {
+ return;
+ };
+ let row_index = *row_index;
+ if self.rows[row_index].hidden_by.is_some() {
+ return;
+ }
+ let col = self.col;
+ let value = self.rows[row_index].entry.content.clone();
+ self.view
+ .update(cx, |view, cx| view.toggle_filter(col, value, cx));
+ self.refresh_rows(cx);
+ cx.notify();
+ }
+
+ fn dismissed(&mut self, _window: &mut Window, _cx: &mut Context<Picker<Self>>) {}
+
+ fn render_match(
+ &self,
+ ix: usize,
+ selected: bool,
+ _window: &mut Window,
+ cx: &mut Context<Picker<Self>>,
+ ) -> Option<Self::ListItem> {
+ match self.filtered.get(ix)? {
+ ColumnFilterListEntry::Header(label) => Some(
+ div()
+ .px_2()
+ .pt_2()
+ .pb_1()
+ .border_t_1()
+ .border_color(cx.theme().colors().border_variant)
+ .child(
+ Label::new(label.clone())
+ .size(LabelSize::XSmall)
+ .color(Color::Muted),
+ )
+ .into_any_element(),
+ ),
+ ColumnFilterListEntry::Row {
+ row_index,
+ positions,
+ } => {
+ let row = &self.rows[*row_index];
+ let value_text: SharedString = match &row.entry.content {
+ Some(s) => s.clone(),
+ None => "<null>".into(),
+ };
+ let count_text = SharedString::from(row.entry.occurred_times().to_string());
+ let label = HighlightedLabel::new(value_text.clone(), positions.clone())
+ .size(LabelSize::Small)
+ .single_line()
+ .truncate();
+
+ if row.hidden_by.is_some() {
+ return Some(
+ ListItem::new(("csv-filter-hidden", ix))
+ .disabled(true)
+ .inset(true)
+ .spacing(ListItemSpacing::Sparse)
+ .child(label.color(Color::Disabled))
+ .end_slot(
+ Label::new(count_text)
+ .size(LabelSize::Small)
+ .color(Color::Disabled),
+ )
+ .into_any_element(),
+ );
+ }
+
+ Some(
+ ListItem::new(("csv-filter-value", ix))
+ .inset(true)
+ .spacing(ListItemSpacing::Sparse)
+ .toggle_state(selected)
+ .start_slot(
+ h_flex()
+ .flex_none()
+ .when(!row.is_applied, |el| el.invisible())
+ .child(
+ Icon::new(IconName::Check)
+ .size(IconSize::Small)
+ .color(Color::Accent),
+ ),
+ )
+ .child(label)
+ .end_slot(
+ Label::new(count_text)
+ .size(LabelSize::Small)
+ .color(Color::Muted),
+ )
+ .tooltip(Tooltip::text(value_text))
+ .into_any_element(),
+ )
+ }
+ }
+ }
+
+ fn render_footer(
+ &self,
+ _window: &mut Window,
+ cx: &mut Context<Picker<Self>>,
+ ) -> Option<AnyElement> {
+ let selected_rows: usize = self
+ .rows
+ .iter()
+ .filter(|row| row.hidden_by.is_none() && row.is_applied)
+ .map(|row| row.entry.occurred_times())
+ .sum();
+ let total_rows: usize = self
+ .rows
+ .iter()
+ .filter(|row| row.hidden_by.is_none())
+ .map(|row| row.entry.occurred_times())
+ .sum();
+ if selected_rows == 0 {
+ return None;
+ }
+
+ let col = self.col;
+ Some(
+ h_flex()
+ .w_full()
+ .px_2()
+ .py_1()
+ .border_t_1()
+ .border_color(cx.theme().colors().border_variant)
+ .justify_between()
+ .items_center()
+ .child(
+ Label::new(format!("{selected_rows} / {total_rows} rows selected"))
+ .size(LabelSize::Small)
+ .color(Color::Muted),
+ )
+ .child(
+ div()
+ .id("csv-filter-clear-all")
+ .cursor_pointer()
+ .child(
+ Label::new("Clear all")
+ .size(LabelSize::Small)
+ .color(Color::Accent),
+ )
+ .on_click(cx.listener(move |picker, _, _, cx| {
+ picker
+ .delegate
+ .view
+ .update(cx, |view, cx| view.clear_filters(col, cx));
+ picker.delegate.refresh_rows(cx);
+ cx.notify();
+ cx.emit(DismissEvent);
+ })),
+ )
+ .into_any(),
+ )
+ }
+}
+
impl CsvPreviewView {
/// Create header for data, which is orderable with text on the left and sort button on the right
pub(crate) fn create_header_element_with_sort_button(
@@ -83,14 +584,14 @@ impl CsvPreviewView {
cx: &mut Context<'_, CsvPreviewView>,
col_idx: AnyColumn,
) -> Button {
- let sort_btn = Button::new(
+ Button::new(
ElementId::NamedInteger("sort-button".into(), col_idx.get() as u64),
match self.engine.applied_sorting {
Some(ordering) if ordering.col_idx == col_idx => match ordering.direction {
SortDirection::Asc => "↓",
SortDirection::Desc => "↑",
},
- _ => "↕", // Unsorted/available for sorting
+ _ => "↕",
},
)
.size(ButtonSize::Compact)
@@ -114,38 +615,31 @@ impl CsvPreviewView {
}))
.on_click(cx.listener(move |this, _event, _window, cx| {
let new_sorting = match this.engine.applied_sorting {
- Some(ordering) if ordering.col_idx == col_idx => {
- // Same column clicked - cycle through states
- match ordering.direction {
- SortDirection::Asc => Some(AppliedSorting {
- col_idx,
- direction: SortDirection::Desc,
- }),
- SortDirection::Desc => None, // Clear sorting
- }
- }
- _ => {
- // Different column or no sorting - start with ascending
- Some(AppliedSorting {
+ Some(ordering) if ordering.col_idx == col_idx => match ordering.direction {
+ SortDirection::Asc => Some(AppliedSorting {
col_idx,
- direction: SortDirection::Asc,
- })
- }
+ direction: SortDirection::Desc,
+ }),
+ SortDirection::Desc => None,
+ },
+ _ => Some(AppliedSorting {
+ col_idx,
+ direction: SortDirection::Asc,
+ }),
};
-
this.engine.applied_sorting = new_sorting;
this.apply_sort(cx);
cx.notify();
- }));
- sort_btn
+ }))
}
fn create_filter_button(
&self,
cx: &mut Context<'_, CsvPreviewView>,
col: AnyColumn,
- ) -> PopoverMenu<ContextMenu> {
+ ) -> PopoverMenu<Picker<ColumnFilterDelegate>> {
let has_active_filters = self.engine.has_active_filters(col);
+ let sort_order = self.settings.filter_sort_order;
PopoverMenu::new(ElementId::NamedInteger(
"filter-menu".into(),
@@ -180,146 +674,19 @@ impl CsvPreviewView {
return None;
}
};
- let filter_sort_order = view.settings.filter_sort_order;
- let filter_menu = Self::create_filter_menu(
- window,
- cx,
- view_entity.clone(),
- col,
- &column_filters,
- has_active_filters,
- filter_sort_order,
- );
- Some(filter_menu)
- }
- })
- }
-
- fn create_filter_menu(
- window: &mut ui::Window,
- cx: &mut ui::App,
- view_entity: gpui::Entity<CsvPreviewView>,
- col: AnyColumn,
- column_filters: &[(FilterEntry, FilterEntryState)],
- has_active_filters: bool,
- sort_order: FilterSortOrder,
- ) -> gpui::Entity<ContextMenu> {
- let mut available: Vec<&FilterEntry> = column_filters
- .iter()
- .filter_map(|(entry, state)| {
- matches!(state, FilterEntryState::Available { .. }).then_some(entry)
- })
- .collect();
-
- match sort_order {
- FilterSortOrder::AlphaThenCount => available.sort_by(|a, b| {
- a.content
- .cmp(&b.content)
- .then_with(|| b.occurred_times().cmp(&a.occurred_times()))
- }),
- FilterSortOrder::CountThenAlpha => available.sort_by(|a, b| {
- b.occurred_times()
- .cmp(&a.occurred_times())
- .then_with(|| a.content.cmp(&b.content))
- }),
- }
-
- let unavailable: Vec<(&FilterEntry, AnyColumn)> = column_filters
- .iter()
- .filter_map(|(entry, state)| {
- if let FilterEntryState::Unavailable { blocked_by } = state {
- Some((entry, *blocked_by))
- } else {
- None
- }
- })
- .collect();
+ let view_entity = view_entity.clone();
- // Pre-build applied-state lookup before moving into the closure
- let applied_states: Vec<(FilterEntry, bool)> = column_filters
- .iter()
- .filter_map(|(entry, state)| {
- if let FilterEntryState::Available { is_applied } = state {
- Some((entry.clone(), *is_applied))
- } else {
- None
- }
- })
- .collect();
-
- let available_cloned: Vec<FilterEntry> = available.iter().map(|e| (*e).clone()).collect();
- let unavailable_cloned: Vec<(FilterEntry, AnyColumn)> = unavailable
- .into_iter()
- .map(|(e, col)| (e.clone(), col))
- .collect();
-
- ContextMenu::build(window, cx, move |menu, _, _| {
- let mut menu = menu;
-
- if has_active_filters {
- menu = menu
- .toggleable_entry("Clear all", false, ui::IconPosition::Start, None, {
- let view_entity = view_entity.clone();
- move |_window, cx| {
- view_entity.update(cx, |view, cx| {
- view.clear_filters(col, cx);
- cx.notify();
- });
- }
- })
- .separator();
- }
-
- for entry in &available_cloned {
- let is_applied = applied_states
- .iter()
- .find(|(e, _)| e.content == entry.content)
- .map_or(false, |(_, applied)| *applied);
-
- let label: SharedString =
- format_filter_label(entry.content.as_ref(), entry.occurred_times()).into();
- let entry_value = entry.content.clone();
-
- menu = menu.toggleable_entry(&label, is_applied, ui::IconPosition::Start, None, {
- let view_entity = view_entity.clone();
- move |_window, cx| {
- view_entity.update(cx, |view, cx| {
- view.toggle_filter(col, entry_value.clone(), cx);
- cx.notify();
- });
- }
+ let picker = cx.new(|cx| {
+ let delegate =
+ ColumnFilterDelegate::new(col, view_entity, sort_order, column_filters, cx);
+ Picker::list(delegate, window, cx)
+ .popover()
+ .initial_width(rems(18.75))
+ .show_scrollbar(true)
});
+ picker.focus_handle(cx).focus(window, cx);
+ Some(picker)
}
-
- if !unavailable_cloned.is_empty() {
- menu = menu.separator().header("Hidden by other filters");
- for (entry, _blocked_by) in &unavailable_cloned {
- let label: SharedString =
- format_filter_label(entry.content.as_ref(), entry.occurred_times()).into();
- menu = menu.custom_entry(
- {
- let label = label.clone();
- move |_window, cx| {
- div()
- .px_2()
- .text_color(cx.theme().colors().text_muted)
- .child(label.clone())
- .into_any_element()
- }
- },
- |_, _| {},
- );
- }
- }
-
- menu
})
}
}
-
-fn format_filter_label(content: Option<&SharedString>, count: usize) -> String {
- match content {
- Some(s) => format!("{s} ({count})"),
- None => format!("<null> ({count})"),
- }
-}