diff --git a/linux/changelog.d/4113.added.md b/linux/changelog.d/4113.added.md new file mode 100644 index 0000000000..4bf0ad7a81 --- /dev/null +++ b/linux/changelog.d/4113.added.md @@ -0,0 +1 @@ +Search Row Details by field name or value, or show only fields with unsaved edits. diff --git a/linux/crates/app/src/ui/data_grid/row_detail/fields.rs b/linux/crates/app/src/ui/data_grid/row_detail/fields.rs index b2b4b16a2e..500c6773d1 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/fields.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/fields.rs @@ -185,7 +185,52 @@ impl RowDetailPane { let imp = self.imp(); imp.selection.set_autoselect(false); imp.selection.set_can_unselect(true); - imp.selection.set_model(Some(&imp.fields.0)); + imp.filtered.set_model(Some(&imp.fields.0)); + imp.filtered.set_filter(Some(&imp.field_filter)); + imp.selection.set_model(Some(&imp.filtered)); + imp.field_filter.set_filter_func(glib::clone!( + #[weak(rename_to = pane)] + self, + #[upgrade_or] + false, + move |item| pane.field_shown(field_of(Some(item.clone()))) + )); + imp.field_search.connect_search_changed(glib::clone!( + #[weak(rename_to = pane)] + self, + move |_| pane.refilter_fields() + )); + imp.field_search.set_key_capture_widget(Some(&imp.field_list.get())); + imp.field_search.connect_search_started(|entry| { + entry.grab_focus(); + }); + imp.field_search.connect_stop_search(glib::clone!( + #[weak(rename_to = pane)] + self, + move |entry| { + if !entry.text().is_empty() { + entry.set_text(""); + } else if pane.grid().is_some_and(|grid| grid.imp().split_view.is_collapsed()) { + pane.imp().close_button.emit_clicked(); + } + } + )); + imp.field_search.connect_activate(glib::clone!( + #[weak(rename_to = pane)] + self, + move |_| { + pane.refilter_fields(); + if pane.imp().filtered.n_items() > 0 { + pane.imp().selection.set_selected(0); + pane.focus_value(); + } + } + )); + imp.edited_toggle.connect_toggled(glib::clone!( + #[weak(rename_to = pane)] + self, + move |_| pane.refilter_fields() + )); imp.field_list.set_model(Some(&imp.selection)); imp.field_list.set_factory(Some(&self.field_factory())); imp.selection.connect_selected_notify(glib::clone!( @@ -237,12 +282,56 @@ impl RowDetailPane { } pub(super) fn redraw_fields(&self) { + self.refilter_fields(); let bound: Vec = self.imp().bound.borrow().clone(); for item in &bound { self.draw_field(item); } } + pub(super) fn refilter_fields(&self) { + let imp = self.imp(); + let has_edits = self.grid().zip(self.current_row()).is_some_and(|(grid, row)| { + grid.grid_columns().iter().any(|column| { + let mark = grid.tracked().mark(&row, column.index); + mark.state == CellState::Modified && !mark.row_deleted + }) + }); + imp.edited_toggle + .set_sensitive(has_edits || imp.edited_toggle.is_active()); + // A changed filter may move the selected position without a user picking a field. + let syncing = imp.syncing.replace(true); + imp.field_filter.changed(gtk::FilterChange::Different); + self.select_in_list(imp.field.get()); + imp.syncing.set(syncing); + imp.field_results.set_visible_child_name(match imp.filtered.n_items() { + 0 => "empty", + _ => "fields", + }); + } + + fn field_shown(&self, column: Option) -> bool { + let imp = self.imp(); + let (Some(grid), Some(column), Some(row)) = (self.grid(), column, self.current_row()) else { + return false; + }; + let Some(column) = grid.grid_columns().get(column).cloned() else { + return false; + }; + if imp.edited_toggle.is_active() { + let mark = grid.tracked().mark(&row, column.index); + if mark.state != CellState::Modified || mark.row_deleted { + return false; + } + } + let wanted = imp.field_search.text().to_lowercase(); + if wanted.is_empty() || column.name.to_lowercase().contains(&wanted) { + return true; + } + let value = field_value(&grid.tracked(), &row, &column); + !value.null && value.text.to_lowercase().contains(&wanted) + } + fn draw_field(&self, item: >k::ListItem) { let (Some(grid), Some(index)) = (self.grid(), field_of(item.item())) else { return; @@ -324,16 +413,16 @@ impl RowDetailPane { pub(super) fn select_in_list(&self, column: Option) { let imp = self.imp(); - let store = &imp.fields.0; + let shown = &imp.selection; let position = column - .and_then(|column| (0..store.n_items()).find(|position| field_of(store.item(*position)) == Some(column))) + .and_then(|column| (0..shown.n_items()).find(|position| field_of(shown.item(*position)) == Some(column))) .unwrap_or(gtk::INVALID_LIST_POSITION); if imp.selection.selected() == position { return; } - imp.syncing.set(true); + let syncing = imp.syncing.replace(true); imp.selection.set_selected(position); - imp.syncing.set(false); + imp.syncing.set(syncing); if position != gtk::INVALID_LIST_POSITION { imp.field_list.scroll_to(position, gtk::ListScrollFlags::NONE, None); } @@ -369,17 +458,15 @@ impl RowDetailPane { move || { pane.imp().sync_queued.set(false); pane.watch_column_visibility(); - if pane.sync_fields() { - pane.render(); - } + pane.sync_fields(); + pane.render(); } )); } - /// Put the fields in the grid's column order. `true` when it changed. - pub(super) fn sync_fields(&self) -> bool { + pub(super) fn sync_fields(&self) { let Some(grid) = self.grid() else { - return false; + return; }; let imp = self.imp(); let wanted = field_order(&grid.shown_columns(), grid.grid_columns().len()); @@ -388,7 +475,7 @@ impl RowDetailPane { .filter_map(|position| field_of(store.item(position))) .collect(); if held == wanted { - return false; + return; } let items: Vec = wanted.into_iter().map(glib::BoxedAnyObject::new).collect(); imp.syncing.set(true); @@ -399,7 +486,6 @@ impl RowDetailPane { imp.field.set(None); } self.select_in_list(imp.field.get()); - true } fn watch_column_visibility(&self) { diff --git a/linux/crates/app/src/ui/data_grid/row_detail/imp.rs b/linux/crates/app/src/ui/data_grid/row_detail/imp.rs index d71dbbd2e0..7f9b51ba0a 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/imp.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/imp.rs @@ -41,6 +41,12 @@ pub struct RowDetailPane { #[template_child] pub field_list: TemplateChild, #[template_child] + pub field_results: TemplateChild, + #[template_child] + pub field_search: TemplateChild, + #[template_child] + pub edited_toggle: TemplateChild, + #[template_child] pub field_label: TemplateChild, #[template_child] pub choice_button: TemplateChild, @@ -80,6 +86,8 @@ pub struct RowDetailPane { pub grid: glib::WeakRef, pub fields: Fields, pub selection: gtk::SingleSelection, + pub filtered: gtk::FilterListModel, + pub field_filter: gtk::CustomFilter, /// The row the pane shows, while it has one. pub shown: RefCell>, /// The data column of the selected field. diff --git a/linux/crates/app/src/ui/data_grid/row_detail/mod.rs b/linux/crates/app/src/ui/data_grid/row_detail/mod.rs index 7804cc47ca..68aa409846 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/mod.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/mod.rs @@ -282,6 +282,7 @@ impl RowDetailPane { } fn show_nothing(&self) { + self.refilter_fields(); self.imp().stack.set_visible_child_name("empty"); self.imp().loaded.take(); } diff --git a/linux/crates/app/src/ui/data_grid/row_detail/tests.rs b/linux/crates/app/src/ui/data_grid/row_detail/tests.rs index 0976385e79..ed074bb410 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/tests.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/tests.rs @@ -24,10 +24,10 @@ use crate::test_support::{ descendants, drain_main_context, finish_on_main, test_backend_records_properties, unlabelled_icon_buttons, wait_until, }; -use crate::ui::data_grid::GridRequest; use crate::ui::data_grid::test_grid::{ Grid, GridSpec, WAIT, focus_in_grid, key, named, page, persisted, text, two_text_columns, two_text_values, }; +use crate::ui::data_grid::{GridRequest, GridSorting}; use crate::ui::error_text::edit_parse_message; fn pane_of(grid: &Grid) -> RowDetailPane { @@ -1615,3 +1615,195 @@ fn a_field_names_its_type_and_its_key_to_a_screen_reader() { }; assert_eq!(field_label(&result_column), "id, integer"); } + +#[gtk4::test] +fn the_field_search_and_the_edited_toggle_narrow_the_list() { + let (grid, pane) = opened(two_text_columns(), two_text_values()); + grid.focus(0, 1); + let imp = pane.imp(); + let listed = || imp.selection.n_items(); + assert_eq!(listed(), 2); + assert!(!imp.edited_toggle.is_sensitive()); + + // The entry reports a search after its own short delay. + imp.field_search.set_text("NAM"); + wait_until(WAIT, || listed() == 1).expect("a search matches a name in any case"); + + imp.field_search.set_text(""); + wait_until(WAIT, || listed() == 2).expect("the fields come back"); + imp.edited_toggle.set_active(true); + drain_main_context(); + assert_eq!(listed(), 0, "nothing is edited yet"); + + let delta = grid.tracker.apply(TrackerEdit::Cell { + row_key: key(1), + col: 1, + original: Value::Text("A".into()), + value: CellInput::Value(Value::Text("changed".into())), + }); + grid.grid.apply_delta(&delta); + drain_main_context(); + assert_eq!(listed(), 1, "the edited field joins the list"); + grid.grid.undo(); + drain_main_context(); + assert_eq!(listed(), 0, "undo removes the field from the edited filter"); + assert!( + imp.edited_toggle.is_sensitive(), + "the active filter can always be turned off" + ); + imp.edited_toggle.set_active(false); + assert_eq!(listed(), 2); + assert!(!imp.edited_toggle.is_sensitive()); +} + +fn listed_columns(pane: &RowDetailPane) -> Vec { + let model = &pane.imp().filtered; + (0..model.n_items()) + .map(|position| { + let boxed = model + .item(position) + .and_downcast::() + .expect("a field"); + *boxed.borrow::() + }) + .collect() +} + +fn search_fields(pane: &RowDetailPane, query: &str) { + pane.imp().field_search.set_text(query); + pane.imp().field_search.emit_by_name::<()>("search-changed", &[]); + drain_main_context(); +} + +#[gtk4::test] +fn field_search_refilters_a_new_schema_with_the_same_column_indices() { + let (grid, pane) = opened(two_text_columns(), two_text_values()); + grid.focus(0, 1); + search_fields(&pane, "nam"); + assert_eq!(listed_columns(&pane), vec![1]); + + let mut columns = grid.columns.to_vec(); + columns[0].name = "name_id".into(); + columns[1].name = "label".into(); + grid.grid + .set_columns(columns.into(), GridSorting::Server { initial: None }, None); + grid.grid.replace_rows(persisted(&two_text_values()), 0); + grid.focus(0, 0); + drain_main_context(); + + assert_eq!(listed_columns(&pane), vec![0]); + assert_eq!( + drawn_field(&pane, 0).accessible_label().as_str(), + "name_id, integer, primary key" + ); +} + +#[gtk4::test] +fn field_search_follows_row_selection_replacement_and_edits() { + let (grid, pane) = opened(two_text_columns(), two_text_values()); + grid.focus(0, 1); + search_fields(&pane, "B"); + assert!(listed_columns(&pane).is_empty()); + pane.imp().field_search.grab_focus(); + grid.grid.selection().select_item(1, true); + drain_main_context(); + assert_eq!(listed_columns(&pane), vec![1]); + + grid.grid + .replace_rows(persisted(&[vec![Value::Int(2), Value::Text("C".into())]]), 0); + drain_main_context(); + assert!(listed_columns(&pane).is_empty()); + let delta = grid.tracker.apply(TrackerEdit::Cell { + row_key: key(2), + col: 1, + original: Value::Text("C".into()), + value: text("B"), + }); + grid.grid.apply_delta(&delta); + drain_main_context(); + assert_eq!(listed_columns(&pane), vec![1]); + grid.grid.undo(); + drain_main_context(); + assert!(listed_columns(&pane).is_empty()); + grid.grid.clear_rows(); + drain_main_context(); + assert!(listed_columns(&pane).is_empty()); + assert_eq!(pane.imp().stack.visible_child_name().as_deref(), Some("empty")); +} + +#[gtk4::test] +fn filtering_keeps_the_selected_field_and_restores_its_list_selection() { + let (grid, pane) = opened(two_text_columns(), two_text_values()); + grid.focus(0, 1); + pane.imp().field_search.grab_focus(); + search_fields(&pane, "id"); + assert_eq!(selected_field(&pane), Some(1)); + assert_eq!(pane.typed_text(), "A"); + assert_eq!(pane.imp().selection.selected(), gtk::INVALID_LIST_POSITION); + assert!(crate::ui::a11y::holds_focus(&pane.imp().field_search.get())); + + search_fields(&pane, "no such field"); + assert_eq!(pane.imp().field_results.visible_child_name().as_deref(), Some("empty")); + search_fields(&pane, ""); + assert_eq!(selected_field(&pane), Some(1)); + assert_eq!(pane.imp().selection.selected(), 1); + assert_eq!(pane.imp().field_results.visible_child_name().as_deref(), Some("fields")); +} + +#[gtk4::test] +fn search_keys_and_tab_order_reach_the_filter_list_and_value() { + let (grid, pane) = opened(two_text_columns(), two_text_values()); + crate::test_support::KeyInjector::focus_only(&grid.window); + take_keyboard(&grid); + grid.focus(0, 1); + let delta = grid.tracker.apply(TrackerEdit::Cell { + row_key: key(1), + col: 1, + original: Value::Text("A".into()), + value: text("changed"), + }); + grid.grid.apply_delta(&delta); + // GTK orders Tab stops by their allocation, which follows the pane opening. + wait_until(WAIT, || { + pane.imp().field_search.is_mapped() + && pane.imp().field_search.width() > 0 + && pane.imp().field_search.height() > 0 + && pane.imp().edited_toggle.is_mapped() + && pane.imp().edited_toggle.width() > 0 + && pane.imp().edited_toggle.height() > 0 + && pane.imp().field_list.width() > 0 + }) + .expect("the search controls are laid out"); + crate::test_support::after_next_frame(&grid.window); + assert!(pane.imp().edited_toggle.is_sensitive()); + assert!(pane.imp().field_search.grab_focus()); + assert!(crate::ui::a11y::holds_focus(&pane.imp().field_search.get())); + let keys = crate::test_support::KeyInjector::connect().expect("an X11 display"); + keys.press(gdk::Key::Tab, gdk::ModifierType::empty()).expect("Tab"); + wait_until(WAIT, || crate::ui::a11y::holds_focus(&pane.imp().edited_toggle.get())).expect("Tab to the filter"); + keys.press(gdk::Key::Tab, gdk::ModifierType::empty()).expect("Tab"); + wait_until(WAIT, || crate::ui::a11y::holds_focus(&pane.imp().field_list.get())).expect("Tab to the list"); + keys.press(gdk::Key::n, gdk::ModifierType::empty()) + .expect("type to search"); + wait_until(WAIT, || pane.imp().field_search.text() == "n").expect("typing in the list searches"); + assert!(crate::ui::a11y::holds_focus(&pane.imp().field_search.get())); + keys.press(gdk::Key::space, gdk::ModifierType::empty()) + .expect("a space in the query"); + wait_until(WAIT, || pane.imp().field_search.text() == "n ").expect("the entry keeps spaces in the query"); + keys.press(gdk::Key::Escape, gdk::ModifierType::empty()) + .expect("Escape"); + wait_until(WAIT, || pane.imp().field_search.text().is_empty()).expect("Escape clears"); + wait_until(WAIT, || listed_columns(&pane).len() == 2).expect("clearing restores all fields"); + search_fields(&pane, "name"); + keys.press(gdk::Key::Return, gdk::ModifierType::empty()).expect("Enter"); + wait_until(WAIT, || crate::ui::a11y::holds_focus(&pane.imp().value_view.get())).expect("Enter opens the result"); + assert_eq!(selected_field(&pane), Some(1)); + assert_eq!(pane.typed_text(), "changed"); + + grid.grid.imp().split_view.set_collapsed(true); + pane.imp().field_search.grab_focus(); + search_fields(&pane, ""); + keys.press(gdk::Key::Escape, gdk::ModifierType::empty()) + .expect("Escape"); + wait_until(WAIT, || !grid.grid.imp().split_view.shows_sidebar()).expect("Escape closes the empty overlay search"); +} diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 97905d18c9..1546b9b017 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -1330,10 +1330,6 @@ impl WorkspaceModel { } } - #[expect( - clippy::too_many_lines, - reason = "Each workspace input dispatches to its own handler" - )] fn update(&mut self, msg: WorkspaceInput) { match msg { WorkspaceInput::HealthChanged(health) => self.refresh_health_banner(&health), diff --git a/linux/data/resources/ui/row-detail-pane.ui b/linux/data/resources/ui/row-detail-pane.ui index a0465b692c..133dfbeccd 100644 --- a/linux/data/resources/ui/row-detail-pane.ui +++ b/linux/data/resources/ui/row-detail-pane.ui @@ -128,16 +128,75 @@ false false - - never - 120 - - - - Fields - + + vertical + + + + 6 + 6 + 6 + 12 + 12 + + + true + Search fields + + Search fields + + + + + + document-edit-symbolic + Show edited fields only + + Show edited fields only + + + + + + + + true + + + fields + + + never + 120 + + + + Fields + + + + + + + + + + empty + + + No Matching Fields + true + 12 + 12 + + + + + - +