diff --git a/linux/changelog.d/4137.added.md b/linux/changelog.d/4137.added.md new file mode 100644 index 0000000000..b498d0b520 --- /dev/null +++ b/linux/changelog.d/4137.added.md @@ -0,0 +1 @@ +Preferences can set the format Copy writes when several rows are selected, as TSV, JSON, CSV or Markdown. diff --git a/linux/changelog.d/4138.added.md b/linux/changelog.d/4138.added.md new file mode 100644 index 0000000000..023ae1adcd --- /dev/null +++ b/linux/changelog.d/4138.added.md @@ -0,0 +1 @@ +Preferences can open the row details pane whenever a row is selected. diff --git a/linux/changelog.d/4140.added.md b/linux/changelog.d/4140.added.md new file mode 100644 index 0000000000..fae3205070 --- /dev/null +++ b/linux/changelog.d/4140.added.md @@ -0,0 +1 @@ +Preferences can sort a table by its primary key or first column when it opens, ascending or descending. diff --git a/linux/crates/app/src/ui/browse_tab/data_handlers.rs b/linux/crates/app/src/ui/browse_tab/data_handlers.rs index 434ed8ef31..cd4362927a 100644 --- a/linux/crates/app/src/ui/browse_tab/data_handlers.rs +++ b/linux/crates/app/src/ui/browse_tab/data_handlers.rs @@ -171,6 +171,12 @@ impl BrowseModel { } pub(super) fn on_columns_loaded(&mut self, columns: Vec, fx: &mut Effects) { + if let Some((behavior, direction)) = self.default_sort.take() { + let result: Vec = columns.iter().map(ColumnInfo::result_column).collect(); + let sortable = self.grid_columns_for_catalog(&result, &columns); + self.current_sort = + super::default_sort::resolve(behavior, direction, &sortable).filter(|_| self.sorts_rows()); + } if self.current_columns != columns { self.page = None; self.shown_view = None; @@ -250,13 +256,15 @@ impl BrowseModel { /// its place. A document's field whose name a filter, a sort or an /// update cannot spell takes none of them (ADR 0026). fn grid_columns_for(&self, result: &[ResultColumn]) -> Arc<[GridColumn]> { + self.grid_columns_for_catalog(result, &self.current_columns) + } + + fn grid_columns_for_catalog(&self, result: &[ResultColumn], catalog: &[ColumnInfo]) -> Arc<[GridColumn]> { let documents = self .dialect .as_ref() .is_some_and(|dialect| dialect.grammar() == SqlGrammar::Mongo); - grid_columns(result, &self.current_columns, |name| { - !documents || is_addressable_field(name) - }) + grid_columns(result, catalog, |name| !documents || is_addressable_field(name)) } /// Give the grid `columns` when it shows others. Its rows go with the diff --git a/linux/crates/app/src/ui/browse_tab/default_sort.rs b/linux/crates/app/src/ui/browse_tab/default_sort.rs new file mode 100644 index 0000000000..cc3f3ff22d --- /dev/null +++ b/linux/crates/app/src/ui/browse_tab/default_sort.rs @@ -0,0 +1,104 @@ +use tablepro_linux_platform::settings::{DefaultSort, GridSortDirection}; + +use crate::services::grid::GridColumn; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum InitialSort { + Default, + Kept(Option<(usize, bool)>), +} + +pub(super) fn resolve( + behavior: DefaultSort, + direction: GridSortDirection, + columns: &[GridColumn], +) -> Option<(usize, bool)> { + let column = match behavior { + DefaultSort::PrimaryKey => columns + .iter() + .find(|column| column.catalog.as_ref().is_some_and(|catalog| catalog.primary_key))?, + DefaultSort::FirstColumn => columns.first()?, + DefaultSort::None => return None, + }; + column.sortable().then_some((column.index, direction.ascending())) +} + +#[cfg(test)] +mod tests { + use tablepro_core::ColumnInfo; + + use super::*; + use crate::services::grid::grid_columns; + use crate::ui::data_grid::test_grid::named; + + fn columns() -> std::sync::Arc<[GridColumn]> { + let catalog = vec![named("name", "text", false), named("id", "integer", true)]; + grid_columns( + &catalog.iter().map(ColumnInfo::result_column).collect::>(), + &catalog, + |_| true, + ) + } + + #[test] + fn none_sorts_nothing() { + assert_eq!( + resolve(DefaultSort::None, GridSortDirection::Ascending, &columns()), + None + ); + } + + #[test] + fn primary_key_picks_the_key_column_in_the_direction() { + assert_eq!( + resolve(DefaultSort::PrimaryKey, GridSortDirection::Ascending, &columns()), + Some((1, true)) + ); + assert_eq!( + resolve(DefaultSort::PrimaryKey, GridSortDirection::Descending, &columns()), + Some((1, false)) + ); + } + + #[test] + fn a_table_without_a_key_stays_unsorted_by_primary_key() { + let keyless = columns()[..1].to_vec(); + assert_eq!( + resolve(DefaultSort::PrimaryKey, GridSortDirection::Ascending, &keyless), + None + ); + assert_eq!( + resolve(DefaultSort::FirstColumn, GridSortDirection::Ascending, &keyless), + Some((0, true)) + ); + } + + #[test] + fn unaddressable_and_missing_columns_are_not_sorted() { + let mut columns = columns().to_vec(); + columns[0].addressable = false; + columns[1].addressable = false; + assert_eq!( + resolve(DefaultSort::FirstColumn, GridSortDirection::Ascending, &columns), + None + ); + assert_eq!( + resolve(DefaultSort::PrimaryKey, GridSortDirection::Ascending, &columns), + None + ); + assert_eq!( + resolve(DefaultSort::FirstColumn, GridSortDirection::Ascending, &[]), + None + ); + } + + #[test] + fn a_composite_key_uses_its_first_column() { + let mut columns = columns().to_vec(); + columns[0].catalog.as_mut().expect("catalog").primary_key = true; + assert_eq!( + resolve(DefaultSort::PrimaryKey, GridSortDirection::Descending, &columns), + Some((0, false)) + ); + } +} diff --git a/linux/crates/app/src/ui/browse_tab/mod.rs b/linux/crates/app/src/ui/browse_tab/mod.rs index c81b355936..c86f3a493e 100644 --- a/linux/crates/app/src/ui/browse_tab/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/mod.rs @@ -22,6 +22,7 @@ mod count_failure_text; mod count_policy; mod data_handlers; mod data_input; +mod default_sort; mod fetch; mod grid_handlers; mod grid_input; @@ -57,6 +58,7 @@ use tablepro_core::dialect::{SqlDialect, TablePaging}; use tablepro_core::meta::{RowIdentity, TableRef}; use tablepro_core::{ColumnInfo, FilterSet}; use tablepro_linux_platform::AppSettings; +use tablepro_linux_platform::settings::{DefaultSort, GridSortDirection}; use tablepro_session::operation::DeadlinePolicy; use tablepro_session::runtime::{Tasks, WatchForwarder}; use tablepro_session::{LinkGeneration, Session}; @@ -70,6 +72,7 @@ use self::browse_tab_widgets::BrowseTabWidgets; use self::column_recheck::ColumnRecheck; pub(super) use self::columns_fetch::{ColumnFreshness, load_columns}; pub(crate) use self::data_input::DataInput; +pub use self::default_sort::InitialSort; pub(crate) use self::grid_input::GridInput; pub(crate) use self::page_reply::PageReply; use self::page_state::PageState; @@ -104,7 +107,7 @@ pub struct BrowseTabInit { pub read_only: bool, pub page_size: u64, pub initial_offset: u64, - pub initial_sort: Option<(usize, bool)>, + pub initial_sort: InitialSort, pub filter: TableFilter, pub column_layouts: crate::persistence::ColumnLayoutStore, pub filter_settings: crate::persistence::FilterSettingsStore, @@ -147,7 +150,14 @@ impl BrowseTab { let actions = browse_actions::install_browse_actions(&tab, init.page_size); // A sort saved with the tab cannot reach an engine that reads // in its own order. - let initial_sort = init.initial_sort.filter(|_| sorts_rows(dialect.as_deref())); + let preferences = init.settings.grid_preferences().snapshot(); + let (initial_sort, default_sort) = match init.initial_sort { + InitialSort::Default => ( + None, + Some((preferences.default_sort, preferences.default_sort_direction)), + ), + InitialSort::Kept(sort) => (sort.filter(|_| sorts_rows(dialect.as_deref())), None), + }; let keys = KeysHandle::new(table.clone()); let grid = layout::grid( &tab, @@ -187,6 +197,7 @@ impl BrowseTab { pager: BrowsePager::new(init.page_size, init.initial_offset), deadlines: init.deadlines, current_sort: initial_sort, + default_sort, current_filter: initial_filter, current_columns: Vec::new(), page: None, @@ -568,6 +579,9 @@ pub(crate) struct BrowseModel { pager: BrowsePager, deadlines: Arc, current_sort: Option<(usize, bool)>, + /// What Preferences asked for when the tab opened, until the columns + /// say which column that is. + default_sort: Option<(DefaultSort, GridSortDirection)>, /// The WHERE every page and count reads under, kept per connection, /// schema and table. current_filter: tablepro_core::FilterSet, diff --git a/linux/crates/app/src/ui/browse_tab/paging_handlers.rs b/linux/crates/app/src/ui/browse_tab/paging_handlers.rs index 83061d8c9c..1416dd15a4 100644 --- a/linux/crates/app/src/ui/browse_tab/paging_handlers.rs +++ b/linux/crates/app/src/ui/browse_tab/paging_handlers.rs @@ -68,6 +68,7 @@ impl BrowseModel { /// A sort the headers did not make, which they show too. /// Read the first page in `next` order. pub(super) fn sort_by(&mut self, next: Option<(usize, bool)>, fx: &mut Effects) { + self.default_sort = None; // One header click can report the same sort twice. if self.current_sort == next { return; diff --git a/linux/crates/app/src/ui/browse_tab/tests/default_sort.rs b/linux/crates/app/src/ui/browse_tab/tests/default_sort.rs new file mode 100644 index 0000000000..1c407f87af --- /dev/null +++ b/linux/crates/app/src/ui/browse_tab/tests/default_sort.rs @@ -0,0 +1,228 @@ +use std::sync::Arc; +use std::time::Duration; + +use gtk4::prelude::*; +use gtk4::subclass::prelude::*; +use tablepro_core::DriverError; +use tablepro_test_support::{ConnectionScript, FakeReply}; + +use super::super::{GridInput, InitialSort, PagingInput}; +use super::{Harness, WAIT, column, column_view, page_queries, rows, serving_table}; +use crate::test_support::wait_until; +use crate::ui::data_grid::GridRequest; + +fn serving_rows() -> ConnectionScript { + let mut script = serving_table(); + script.query_bound.always(FakeReply::ok(rows(&["Ada"]))); + script +} + +fn loaded(harness: &Harness) { + wait_until(WAIT, || !harness.tab().is_loading() && harness.shown().len() == 1).expect("first page"); +} + +#[gtk4::test] +fn the_default_sort_reaches_the_first_page_query_and_header() { + let harness = Harness::open_with_sort(serving_rows(), InitialSort::Default, "primary-key", "descending"); + loaded(&harness); + + let queries = page_queries(&harness); + assert_eq!(queries.len(), 1); + assert!(queries[0].contains("ORDER BY \"users\".\"id\" DESC"), "{}", queries[0]); + assert_eq!(harness.tab().current_sort(), Some((0, false))); + let sorter = column_view(harness.tab()) + .sorter() + .and_downcast::() + .expect("sorter"); + assert_eq!(sorter.primary_sort_column(), harness.grid().data_view_column(0)); + assert_eq!(sorter.primary_sort_order(), gtk4::SortType::Descending); +} + +#[gtk4::test] +fn kept_sorts_include_an_explicitly_unsorted_first_page() { + for kept in [None, Some((1, true))] { + let harness = Harness::open_with_sort(serving_rows(), InitialSort::Kept(kept), "primary-key", "descending"); + loaded(&harness); + assert_eq!(harness.tab().current_sort(), kept); + if kept.is_some() { + assert!(page_queries(&harness)[0].contains("ORDER BY \"users\".\"name\" ASC")); + } else { + // Stable paging can add the key's ascending order without selecting a header sort. + assert!(!page_queries(&harness)[0].contains("DESC")); + let sorter = column_view(harness.tab()) + .sorter() + .and_downcast::() + .expect("sorter"); + assert!(sorter.primary_sort_column().is_none()); + } + } +} + +#[gtk4::test] +fn refresh_and_preference_changes_preserve_the_users_sort() { + let harness = Harness::open_with_sort(serving_rows(), InitialSort::Default, "primary-key", "descending"); + loaded(&harness); + harness.grid().sort_by(Some((1, true))); + wait_until(WAIT, || { + page_queries(&harness).len() == 2 && !harness.tab().is_loading() + }) + .expect("manual sort"); + + harness + .stores + .settings + .get() + .set_default_sort("first-column") + .expect("preference"); + harness.tab().send(PagingInput::Refresh); + wait_until(WAIT, || { + page_queries(&harness).len() == 3 && !harness.tab().is_loading() + }) + .expect("refresh"); + + assert_eq!(harness.tab().current_sort(), Some((1, true))); + assert!(page_queries(&harness)[2].contains("ORDER BY \"users\".\"name\" ASC")); +} + +#[gtk4::test] +fn a_failed_metadata_read_keeps_the_default_for_its_retry() { + let mut script = serving_rows(); + script.fetch_columns.once(FakeReply::err(DriverError::server("busy"))); + let harness = Harness::open_with_sort(script, InitialSort::Default, "primary-key", "descending"); + wait_until(WAIT, || harness.visible_page().as_deref() == Some("error")).expect("metadata failure"); + assert!(page_queries(&harness).is_empty()); + + harness.tab().send(PagingInput::Refresh); + loaded(&harness); + + assert_eq!(harness.tab().current_sort(), Some((0, false))); + assert!(page_queries(&harness)[0].contains("ORDER BY \"users\".\"id\" DESC")); +} + +#[gtk4::test] +fn explicitly_clearing_sort_before_metadata_cancels_the_default() { + let mut script = serving_rows(); + script.fetch_columns.always(FakeReply::Late { + after: Duration::from_millis(150), + outcome: Ok(vec![column("id", true), column("name", false)]), + }); + let harness = Harness::open_with_sort(script, InitialSort::Default, "primary-key", "descending"); + + harness.tab().send(GridInput::Request(GridRequest::Sort(None))); + loaded(&harness); + + assert_eq!(harness.tab().current_sort(), None); + assert!(!page_queries(&harness)[0].contains("DESC")); +} + +#[gtk4::test] +fn a_keyless_table_and_an_engine_without_sorting_skip_the_default() { + let mut keyless = serving_rows(); + keyless + .fetch_columns + .always(FakeReply::ok(vec![column("id", false), column("name", false)])); + keyless + .row_identity + .always(FakeReply::ok(tablepro_core::meta::RowIdentity::Unordered)); + let harness = Harness::open_with_sort(keyless, InitialSort::Default, "primary-key", "descending"); + loaded(&harness); + assert_eq!(harness.tab().current_sort(), None); + drop(harness); + + let mut unsupported = serving_rows(); + unsupported.dialect = Arc::new(tablepro_driver_cassandra::CqlDialect::new( + &tablepro_core::ServerInfo::new("Cassandra", "5.0", 5, 0, 0), + )); + let harness = Harness::open_with_sort(unsupported, InitialSort::Default, "primary-key", "descending"); + wait_until(WAIT, || harness.grid().data_view_column(0).is_some()).expect("metadata"); + assert_eq!(harness.tab().current_sort(), None); + assert!(harness.grid().data_view_column(0).expect("column").sorter().is_none()); +} + +#[gtk4::test] +fn stale_metadata_cannot_consume_the_pending_default() { + use super::super::{BrowseCommand, BrowseRequestKind, ColumnsReply, DataInput}; + use crate::runtime::Stamped; + use crate::ui::tab_load::LoadFailure; + use tablepro_core::meta::RowIdentity; + + let mut script = serving_rows(); + script.fetch_columns.always(FakeReply::UntilStopped); + let harness = Harness::open_with_sort(script, InitialSort::Default, "primary-key", "descending"); + let (stale, current) = { + let mut borrowed = harness.tab().imp().model.borrow_mut(); + let model = borrowed.as_mut().expect("model"); + ( + model.sequencer.issue(BrowseRequestKind::Columns), + model.sequencer.issue(BrowseRequestKind::Columns), + ) + }; + let reply = || ColumnsReply { + columns: vec![column("id", true), column("name", false)].into(), + identity: RowIdentity::UniqueKey { + columns: vec!["id".into()], + }, + }; + harness + .tab() + .send(DataInput::Command(Box::new(BrowseCommand::Columns(Stamped { + stamp: stale.stamp, + value: Ok(reply()), + })))); + assert_eq!(harness.tab().current_sort(), None); + assert!( + harness + .tab() + .imp() + .model + .borrow() + .as_ref() + .expect("model") + .default_sort + .is_some() + ); + harness + .tab() + .send(DataInput::Command(Box::new(BrowseCommand::Columns(Stamped { + stamp: current.stamp, + value: Err(LoadFailure::NoColumns), + })))); + assert!( + harness + .tab() + .imp() + .model + .borrow() + .as_ref() + .expect("model") + .default_sort + .is_some() + ); + let retry = harness + .tab() + .imp() + .model + .borrow_mut() + .as_mut() + .expect("model") + .sequencer + .issue(BrowseRequestKind::Columns); + harness + .tab() + .send(DataInput::Command(Box::new(BrowseCommand::Columns(Stamped { + stamp: retry.stamp, + value: Ok(reply()), + })))); + assert_eq!(harness.tab().current_sort(), Some((0, false))); + assert!( + harness + .tab() + .imp() + .model + .borrow() + .as_ref() + .expect("model") + .default_sort + .is_none() + ); +} diff --git a/linux/crates/app/src/ui/browse_tab/tests/mod.rs b/linux/crates/app/src/ui/browse_tab/tests/mod.rs index 73c7f5278d..49a600fc2c 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/mod.rs @@ -1,3 +1,4 @@ +mod default_sort; mod load; mod references; mod rows; @@ -16,7 +17,9 @@ use tablepro_session::Session; use tablepro_session::fakes::FakeEstablish; use tablepro_test_support::{CallCounters, ConnectionScript, FakeConnection, FakeReply}; -use super::{BrowseTab, BrowseTabInit, DataInput, GridInput, PagingInput, RowTotal, SaveInput, TableFilter}; +use super::{ + BrowseTab, BrowseTabInit, DataInput, GridInput, InitialSort, PagingInput, RowTotal, SaveInput, TableFilter, +}; use crate::services::change_tracker::RowKey; use crate::services::tab_tracker_handle::TabTrackerHandle; use crate::services::tracker_delta::TrackerDelta; @@ -162,24 +165,50 @@ impl Harness { filter: TableFilter, read_only: bool, ) -> Self { - libadwaita::init().expect("libadwaita initialises under the test backend"); - crate::register_test_resources(); - let runtime = crate::test_support::test_runtime(); - let fake = FakeSession::start(script, reconnects, runtime.tasks()); - let stores = TabStores::new(); - let tracker = TabTrackerHandle::default(); - let tab = table_tab( - &fake.session, - &runtime, - &stores, + Self::open_configured( + script, + reconnects, Opening { saved, filter, - tracker: tracker.clone(), read_only, ..Opening::users() }, - ); + TabStores::new(), + ) + } + + fn open_with_sort(script: ConnectionScript, initial_sort: InitialSort, choice: &str, direction: &str) -> Self { + let stores = TabStores::new(); + stores.settings.get().set_default_sort(choice).expect("default sort"); + stores + .settings + .get() + .set_default_sort_direction(direction) + .expect("default direction"); + Self::open_configured( + script, + [], + Opening { + initial_sort, + ..Opening::users() + }, + stores, + ) + } + + fn open_configured( + script: ConnectionScript, + reconnects: impl IntoIterator, + opening: Opening, + stores: TabStores, + ) -> Self { + libadwaita::init().expect("libadwaita initialises under the test backend"); + crate::register_test_resources(); + let runtime = crate::test_support::test_runtime(); + let fake = FakeSession::start(script, reconnects, runtime.tasks()); + let tracker = opening.tracker.clone(); + let tab = table_tab(&fake.session, &runtime, &stores, opening); Self { tab: Some(tab), tracker, @@ -349,6 +378,7 @@ pub(super) struct Opening { pub(super) filter: TableFilter, pub(super) tracker: TabTrackerHandle, pub(super) read_only: bool, + pub(super) initial_sort: InitialSort, } impl Opening { @@ -359,6 +389,7 @@ impl Opening { filter: TableFilter::Remembered, tracker: TabTrackerHandle::default(), read_only: false, + initial_sort: InitialSort::Default, } } } @@ -375,6 +406,7 @@ pub(super) fn table_tab( filter, tracker, read_only, + initial_sort, } = opening; let tasks = runtime.tasks(); let connection_id = uuid::Uuid::new_v4(); @@ -389,7 +421,7 @@ pub(super) fn table_tab( read_only, page_size: 100, initial_offset: 0, - initial_sort: None, + initial_sort, filter, column_layouts: crate::persistence::ColumnLayoutStore::load(root.join("column_layouts.json"), &tasks), filter_settings, @@ -1621,6 +1653,26 @@ fn a_dotted_field_of_a_document_neither_sorts_nor_takes_an_edit() { assert_eq!(harness.tracker.pending_count(), 0); } +#[gtk4::test] +fn a_new_tab_opens_sorted_by_the_default_sort() { + let mut script = serving_table(); + script.count_rows.always(FakeReply::ok(1_000)); + script.query_bound.always(FakeReply::ok(full_page(0))); + let mut harness = Harness::open(script, []); + wait_until(WAIT, || harness.shown().len() == 100).expect("the first page"); + assert_eq!(harness.tab().current_sort(), None, "no default sort until asked"); + + let settings = harness.stores.settings.get().clone(); + settings.set_default_sort("primary-key").expect("store the sort"); + settings + .set_default_sort_direction("descending") + .expect("store the direction"); + let another = harness.open_another(); + wait_until(WAIT, || another.current_sort().is_some()).expect("the default sort"); + + assert_eq!(another.current_sort(), Some((0, false))); +} + #[gtk4::test] fn the_bottom_bar_switches_between_data_and_structure() { use gtk4::subclass::prelude::ObjectSubclassIsExt; diff --git a/linux/crates/app/src/ui/data_grid/copy/mod.rs b/linux/crates/app/src/ui/data_grid/copy/mod.rs index 222b60e39f..decb23cc3f 100644 --- a/linux/crates/app/src/ui/data_grid/copy/mod.rs +++ b/linux/crates/app/src/ui/data_grid/copy/mod.rs @@ -5,6 +5,7 @@ use gtk4::{self as gtk, glib}; use tablepro_core::column::{ColumnInfo, ResultColumn}; use tablepro_core::edit::CellInput; use tablepro_core::{FilterRule, Value}; +use tablepro_linux_platform::settings::RowCopyFormat; use super::grid_actions::{add, add_for_column, enable}; use super::selection::Resolved; @@ -165,7 +166,6 @@ impl ShownColumns { } } -/// Copy: the target cell's value when one row is in play, else the rows. fn copy(grid: &DataGrid) { let Some(target) = grid.target() else { return; @@ -173,7 +173,22 @@ fn copy(grid: &DataGrid) { let column = target.cell.as_ref().map(|(_, column)| *column); match (copy_scope(target.rows.len(), column), &target.cell) { (CopyScope::Value(column), Some((row, _))) => copy_value(grid, row, column), - _ => copy_rows(grid, &target.rows, CopyKind::Rows), + _ => copy_rows(grid, &target.rows, preferred_format(grid)), + } +} + +fn preferred_format(grid: &DataGrid) -> CopyKind { + match grid + .config() + .map(|config| config.settings.row_copy_format()) + .unwrap_or_default() + { + RowCopyFormat::Rows => CopyKind::Rows, + RowCopyFormat::RowsWithHeaders => CopyKind::RowsWithHeaders, + RowCopyFormat::Json => CopyKind::Json, + RowCopyFormat::Csv => CopyKind::Csv, + RowCopyFormat::CsvWithHeaders => CopyKind::CsvWithHeaders, + RowCopyFormat::Markdown => CopyKind::Markdown, } } diff --git a/linux/crates/app/src/ui/data_grid/copy/tests.rs b/linux/crates/app/src/ui/data_grid/copy/tests.rs index 8a46da5545..afab86f749 100644 --- a/linux/crates/app/src/ui/data_grid/copy/tests.rs +++ b/linux/crates/app/src/ui/data_grid/copy/tests.rs @@ -25,6 +25,7 @@ use crate::ui::data_grid::{DataGrid, GridCell, GridRequest}; use crate::ui::export::ExportSource; const BEFORE: &str = "nothing copied yet"; +const TWO_TEXT_ROWS_JSON: &str = "[\n{\"id\":1,\"name\":\"A\"},\n{\"id\":2,\"name\":\"B\"}\n]"; /// What a copy test drives: a grid and the requests it made. trait Copies { @@ -747,3 +748,49 @@ fn the_text_copies_take_the_columns_on_screen() { assert_eq!(lines, "{\"id\":1,\"name\":\"Ada\"}\n{\"id\":2,\"name\":\"Grace\"}\n"); assert_eq!(one_row, "1, 'Ada', 2, 'Grace'"); } + +#[gtk4::test] +fn copy_writes_several_rows_in_the_preferred_format() { + use tablepro_linux_platform::settings::RowCopyFormat; + + let grid = Grid::open(two_text_columns(), two_text_values()); + select_all(&grid); + let settings = &grid.grid.config().expect("a configured grid").settings; + for format in RowCopyFormat::ALL { + settings.set_row_copy_format(format.nick()).expect("store the format"); + + let text = copied(&grid, || activate(&grid.grid, "copy")); + + match format { + RowCopyFormat::Rows => assert_eq!(text, "1\tA\n2\tB\n"), + RowCopyFormat::RowsWithHeaders => assert_eq!(text, "id\tname\n1\tA\n2\tB\n"), + RowCopyFormat::Csv => assert_eq!(text, "1,A\n2,B\n"), + RowCopyFormat::CsvWithHeaders => assert_eq!(text, "id,name\n1,A\n2,B\n"), + RowCopyFormat::Markdown => assert_eq!(text, "| id | name |\n| --- | --- |\n| 1 | A |\n| 2 | B |"), + RowCopyFormat::Json => assert_eq!(text, TWO_TEXT_ROWS_JSON), + } + } +} + +#[gtk4::test] +fn preferred_row_format_preserves_single_cell_copy_and_explicit_formats() { + let grid = Grid::open(two_text_columns(), two_text_values()); + grid.grid + .config() + .expect("a configured grid") + .settings + .set_row_copy_format("json") + .expect("store the format"); + grid.grid.selection().select_item(0, true); + grid.focus(0, 1); + + assert_eq!(copied(&grid, || activate(&grid.grid, "copy")), "A"); + + select_all(&grid); + assert_eq!( + copied(&grid, || activate(&grid.grid, "copy-csv-headers")), + "id,name\n1,A\n2,B\n" + ); + let text = copied(&grid, || activate(&grid.grid, "copy")); + assert_eq!(text, TWO_TEXT_ROWS_JSON); +} diff --git a/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs b/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs index 1dc09f2a7a..900d3d92d9 100644 --- a/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs +++ b/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs @@ -6,7 +6,7 @@ use libadwaita::prelude::*; use tablepro_core::Value; use tablepro_core::edit::CellInput; -use super::{editing, none, pending, press, two_text_rows}; +use super::{details_shown, editing, none, pending, press, two_text_rows}; use crate::services::change_tracker::RowState; use crate::services::grid::edit_policy; use crate::test_support::{drain_main_context, respond, wait_until}; @@ -526,3 +526,97 @@ fn a_deleted_focus_does_not_disable_presets_for_other_selected_rows() { assert_eq!(pending(&grid, 2, 1), Some(CellInput::Value(Value::Null))); assert_eq!(grid.tracker.row_state(&key(1)), RowState::PendingDelete); } + +#[gtk4::test] +fn selecting_a_row_opens_the_details_only_when_preferences_ask() { + let grid = two_text_rows(); + let settings = grid.grid.config().expect("a configured grid").settings.clone(); + + grid.focus(0, 1); + grid.grid.selection().select_item(0, true); + assert!(!details_shown(&grid), "off by default"); + + settings.set_auto_show_inspector(true).expect("store the flag"); + drain_main_context(); + assert!(!details_shown(&grid), "the preference waits for a new selection"); + grid.focus(0, 0); + assert!(!details_shown(&grid), "focus alone does not select a row"); + grid.grid.selection().select_item(1, true); + drain_main_context(); + assert!(details_shown(&grid)); + + settings + .set_auto_show_inspector(false) + .expect("turn automatic opening off"); + drain_main_context(); + assert!(details_shown(&grid), "turning the preference off leaves the pane open"); + grid.activate("show-details"); + grid.grid.selection().select_item(0, true); + drain_main_context(); + assert!(!details_shown(&grid)); +} + +#[gtk4::test] +fn closing_details_keeps_it_closed_through_focus_moves_and_escape() { + let grid = two_text_rows(); + let settings = grid.grid.config().expect("a configured grid").settings.clone(); + settings + .set_auto_show_inspector(true) + .expect("enable automatic opening"); + select_all_from(&grid, 0, 1); + assert!(details_shown(&grid)); + + assert!(press(&grid, gdk::Key::Return, gdk::ModifierType::ALT_MASK)); + assert!(!details_shown(&grid)); + grid.focus(1, 0); + assert!( + !details_shown(&grid), + "moving focus with the same selection keeps it closed" + ); + assert!(press(&grid, gdk::Key::Escape, none())); + drain_main_context(); + assert!(grid.grid.selection().selection().is_empty()); + assert!( + grid.grid.focused_cell().is_some(), + "the action target still has a focused row" + ); + assert!(!details_shown(&grid), "clearing the selection must not reopen details"); + grid.focus(0, 1); + assert!( + !details_shown(&grid), + "a focused cell without a selection keeps it closed" + ); + + grid.grid.selection().select_item(0, true); + drain_main_context(); + assert!(details_shown(&grid), "a new selection opens details again"); +} + +#[gtk4::test] +fn open_grids_use_the_shared_auto_details_preference_on_their_next_selection() { + let first = two_text_rows(); + let settings = first.grid.config().expect("a configured grid").settings.clone(); + let second = Grid::build( + GridSpec { + settings: Some(settings.clone()), + ..GridSpec::table(two_text_columns()) + }, + page(1..3), + ); + let isolated = two_text_rows(); + for grid in [&first, &second, &isolated] { + grid.grid.selection().unselect_all(); + assert!(!details_shown(grid)); + } + + settings + .set_auto_show_inspector(true) + .expect("enable automatic opening"); + for grid in [&first, &second, &isolated] { + grid.grid.selection().select_item(0, true); + } + drain_main_context(); + assert!(details_shown(&first)); + assert!(details_shown(&second)); + assert!(!details_shown(&isolated)); +} diff --git a/linux/crates/app/src/ui/data_grid/grid_actions.rs b/linux/crates/app/src/ui/data_grid/grid_actions.rs index 1b7e5e095c..7acbc5abf3 100644 --- a/linux/crates/app/src/ui/data_grid/grid_actions.rs +++ b/linux/crates/app/src/ui/data_grid/grid_actions.rs @@ -152,6 +152,20 @@ impl DataGrid { self.target()?.cell.map(|(_, column)| column) } + pub(super) fn open_details_for_selection(&self) { + let wanted = self + .config() + .is_some_and(|config| config.settings.auto_show_inspector()); + // Action targets include a focused row after Escape clears the selection. + let selected = !self.selection().selection().is_empty(); + if wanted + && selected + && let Some(details) = self.imp().actions.lookup_action("show-details") + { + details.change_state(&true.to_variant()); + } + } + /// Open the detail pane on the focused row, with `column`'s field. pub(crate) fn show_details_for(&self, column: usize) { self.imp().detail_pane.select_field(column); diff --git a/linux/crates/app/src/ui/data_grid/mod.rs b/linux/crates/app/src/ui/data_grid/mod.rs index 8fbf4b920e..0b664e0d0d 100644 --- a/linux/crates/app/src/ui/data_grid/mod.rs +++ b/linux/crates/app/src/ui/data_grid/mod.rs @@ -417,6 +417,7 @@ impl DataGrid { fn selection_moved(&self) { self.refresh_actions(); self.imp().detail_pane.follow_focus(); + self.open_details_for_selection(); self.emit_by_name::<()>("selection-changed", &[]); } 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 cbecb66443..024d47f75c 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 @@ -1968,3 +1968,24 @@ fn search_keys_and_tab_order_reach_the_filter_list_and_value() { .expect("Escape"); wait_until(WAIT, || !grid.grid.imp().split_view.shows_sidebar()).expect("Escape closes the empty overlay search"); } + +#[gtk4::test] +fn changing_automatic_details_opening_keeps_an_active_value_draft() { + let (grid, pane) = opened(two_text_columns(), two_text_values()); + edit_field(&grid, &pane, 0, 1); + type_value(&pane, "unfinished"); + let settings = grid.grid.config().expect("a configured grid").settings.clone(); + + settings + .set_auto_show_inspector(true) + .expect("enable automatic opening"); + settings + .set_auto_show_inspector(false) + .expect("disable automatic opening"); + drain_main_context(); + + assert!(pane.is_open()); + assert!(pane.is_editing_value()); + assert_eq!(pane.typed_text(), "unfinished"); + assert_eq!(pending(&grid, 1, 1), None); +} diff --git a/linux/crates/app/src/ui/data_grid/row_detail/value_editor.rs b/linux/crates/app/src/ui/data_grid/row_detail/value_editor.rs index 56c18441f8..4e6e1936de 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/value_editor.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/value_editor.rs @@ -247,7 +247,7 @@ impl RowDetailPane { } } - fn is_editing_value(&self) -> bool { + pub(super) fn is_editing_value(&self) -> bool { self.imp().edit.borrow().is_some() } diff --git a/linux/crates/app/src/ui/preferences_dialog/data_browser_group.rs b/linux/crates/app/src/ui/preferences_dialog/data_browser_group.rs index b811995241..e1451ee26f 100644 --- a/linux/crates/app/src/ui/preferences_dialog/data_browser_group.rs +++ b/linux/crates/app/src/ui/preferences_dialog/data_browser_group.rs @@ -4,7 +4,7 @@ use gtk4::prelude::*; use gtk4::subclass::prelude::*; use libadwaita as adw; use tablepro_linux_platform::AppSettings; -use tablepro_linux_platform::settings::{GridRowHeight, keys}; +use tablepro_linux_platform::settings::{DefaultSort, GridRowHeight, GridSortDirection, RowCopyFormat, keys}; mod imp { use libadwaita::prelude::*; @@ -30,6 +30,14 @@ mod imp { #[template_child] pub row_numbers_row: TemplateChild, #[template_child] + pub auto_inspector_row: TemplateChild, + #[template_child] + pub default_sort_row: TemplateChild, + #[template_child] + pub default_sort_direction_row: TemplateChild, + #[template_child] + pub row_copy_format_row: TemplateChild, + #[template_child] pub row_height_row: TemplateChild, #[template_child] pub null_display_row: TemplateChild, @@ -113,22 +121,55 @@ impl DataBrowserGroup { }) .build(); gio_settings - .bind(keys::GRID_ROW_HEIGHT, &imp.row_height_row.get(), "selected") - .mapping(|variant, _| { - let height = variant.str()?; - let index = GridRowHeight::ALL - .iter() - .position(|candidate| candidate.nick() == height)?; - Some((index as u32).to_value()) - }) - .set_mapping(|value, _| { - let index = value.get::().ok()?; - Some(GridRowHeight::ALL.get(index as usize)?.nick().to_variant()) - }) + .bind(keys::AUTO_SHOW_INSPECTOR, &imp.auto_inspector_row.get(), "active") .build(); + bind_choice( + &imp.row_height_row.get(), + gio_settings, + keys::GRID_ROW_HEIGHT, + GridRowHeight::ALL.map(GridRowHeight::nick), + ); + bind_choice( + &imp.default_sort_row.get(), + gio_settings, + keys::DEFAULT_SORT, + DefaultSort::ALL.map(DefaultSort::nick), + ); + bind_choice( + &imp.default_sort_direction_row.get(), + gio_settings, + keys::DEFAULT_SORT_DIRECTION, + GridSortDirection::ALL.map(GridSortDirection::nick), + ); + bind_choice( + &imp.row_copy_format_row.get(), + gio_settings, + keys::ROW_COPY_FORMAT, + RowCopyFormat::ALL.map(RowCopyFormat::nick), + ); } } +fn bind_choice( + row: &adw::ComboRow, + settings: &gio::Settings, + key: &'static str, + words: [&'static str; N], +) { + settings + .bind(key, row, "selected") + .mapping(move |variant, _| { + let word = variant.str()?; + let index = words.iter().position(|candidate| *candidate == word)?; + Some((index as u32).to_value()) + }) + .set_mapping(move |value, _| { + let index = value.get::().ok()?; + Some(words.get(index as usize)?.to_variant()) + }) + .build(); +} + #[cfg(test)] mod tests { use libadwaita::prelude::*; @@ -169,6 +210,21 @@ mod tests { assert!(settings.get().show_alternate_rows()); } + #[gtk4::test] + fn automatic_details_switches_stay_in_sync() { + let settings = MemorySettings::new(); + let first = bound_group(&settings); + let second = bound_group(&settings); + assert!(!first.imp().auto_inspector_row.is_active()); + + first.imp().auto_inspector_row.set_active(true); + assert!(settings.get().auto_show_inspector()); + assert!(second.imp().auto_inspector_row.is_active()); + settings.get().set_auto_show_inspector(false).expect("store the flag"); + assert!(!first.imp().auto_inspector_row.is_active()); + assert!(!second.imp().auto_inspector_row.is_active()); + } + #[gtk4::test] fn the_group_is_titled_for_the_data_browser() { let settings = MemorySettings::new(); @@ -258,4 +314,50 @@ mod tests { assert!(first.imp().grid_system_font_row.is_active()); assert!(!second.imp().grid_font_row.is_sensitive()); } + + #[gtk4::test] + fn copy_format_rows_follow_every_choice_from_both_windows() { + let settings = MemorySettings::new(); + let first = bound_group(&settings); + let second = bound_group(&settings); + + for (index, format) in RowCopyFormat::ALL.into_iter().enumerate() { + first.imp().row_copy_format_row.set_selected(index as u32); + assert_eq!(settings.get().row_copy_format(), format); + assert_eq!(second.imp().row_copy_format_row.selected(), index as u32); + } + for (index, format) in RowCopyFormat::ALL.into_iter().enumerate().rev() { + settings + .get() + .set_row_copy_format(format.nick()) + .expect("store copy format"); + assert_eq!(first.imp().row_copy_format_row.selected(), index as u32); + assert_eq!(second.imp().row_copy_format_row.selected(), index as u32); + } + second.imp().row_copy_format_row.set_selected(2); + assert_eq!(first.imp().row_copy_format_row.selected(), 2); + assert_eq!(settings.get().row_copy_format(), RowCopyFormat::Json); + } + #[gtk4::test] + fn default_sort_rows_follow_other_windows_and_external_settings() { + let settings = MemorySettings::new(); + let first = bound_group(&settings); + let second = bound_group(&settings); + first.imp().default_sort_row.set_selected(1); + first.imp().default_sort_direction_row.set_selected(1); + assert_eq!(settings.get().default_sort(), DefaultSort::PrimaryKey); + assert_eq!(settings.get().default_sort_direction(), GridSortDirection::Descending); + assert_eq!(second.imp().default_sort_row.selected(), 1); + assert_eq!(second.imp().default_sort_direction_row.selected(), 1); + + settings.get().set_default_sort("first-column").expect("default sort"); + settings + .get() + .set_default_sort_direction("ascending") + .expect("direction"); + for group in [&first, &second] { + assert_eq!(group.imp().default_sort_row.selected(), 2); + assert_eq!(group.imp().default_sort_direction_row.selected(), 0); + } + } } diff --git a/linux/crates/app/src/ui/workspace/tab_spec.rs b/linux/crates/app/src/ui/workspace/tab_spec.rs index ad6bdbf233..e27f926216 100644 --- a/linux/crates/app/src/ui/workspace/tab_spec.rs +++ b/linux/crates/app/src/ui/workspace/tab_spec.rs @@ -2,7 +2,7 @@ use tablepro_core::meta::TableRef; use tablepro_storage::DraftId; use super::structure_target::StructureTarget; -use crate::ui::browse_tab::TableFilter; +use crate::ui::browse_tab::{InitialSort, TableFilter}; use crate::workspace::{DiagramPlace, EditorFileRecord}; /// A tab to open. Every way a tab opens builds one of these: the sidebar, @@ -45,8 +45,7 @@ pub(crate) enum TabSpec { pub(crate) struct TablePage { pub offset: u64, pub page_size: u64, - /// The column index and whether it sorts ascending. - pub sort: Option<(usize, bool)>, + pub sort: InitialSort, } impl TablePage { @@ -54,7 +53,7 @@ impl TablePage { Self { offset: 0, page_size, - sort: None, + sort: InitialSort::Default, } } } diff --git a/linux/crates/app/src/ui/workspace/tests/references.rs b/linux/crates/app/src/ui/workspace/tests/references.rs index b054047d2b..b97a0ebd0c 100644 --- a/linux/crates/app/src/ui/workspace/tests/references.rs +++ b/linux/crates/app/src/ui/workspace/tests/references.rs @@ -234,3 +234,106 @@ fn a_followed_tab_keeps_its_filter_in_the_saved_tabs_and_through_a_reopen() { assert_eq!(reopened.table(), "customers"); assert_eq!(reopened.applied_filter(), customer("42").filter); } + +#[gtk4::test] +fn reopening_a_closed_unsorted_table_does_not_apply_the_default() { + let test = TestWindow::connected_with("ReopenUnsortedGrid", serving_tables); + test.services + .settings + .set_default_sort("primary-key") + .expect("default sort"); + test.services + .settings + .set_default_sort_direction("descending") + .expect("direction"); + let (_, page) = open_orders(&test); + let tab = page.child().downcast::().expect("table tab"); + wait_until(WAIT, || !tab.is_loading() && tab.grid().store().len() == 1).expect("initial page"); + assert_eq!(tab.current_sort(), Some((0, false))); + tab.grid().sort_by(None); + wait_until(WAIT, || !tab.is_loading() && tab.current_sort().is_none()).expect("clear sort"); + let workspace = test.workspace(); + let view = shell_of(&workspace).imp().tab_view.clone(); + let count = view.n_pages(); + workspace + .sender() + .expect("input") + .deliver(WorkspaceInput::CloseActiveWorkspaceTab); + wait_until(WAIT, || view.n_pages() < count).expect("closed table"); + + WidgetExt::activate_action(&test.window, "win.reopen-closed-tab", None).expect("reopen"); + let mut reopened = None; + wait_until(WAIT, || { + reopened = view + .selected_page() + .filter(|candidate| candidate != &page) + .and_then(|page| page.child().downcast::().ok()); + reopened + .as_ref() + .is_some_and(|tab| !tab.is_loading() && tab.grid().store().len() == 1) + }) + .expect("reopened table"); + assert_eq!(reopened.expect("tab").current_sort(), None); +} + +#[gtk4::test] +fn session_restore_keeps_an_unsorted_first_page() { + use crate::test_support::finish_on_main; + use crate::ui::SessionWindowInput; + use crate::ui::session_window::tests::Script; + use crate::workspace::WorkspaceRecord; + + let mut connection = ConnectionScript::default(); + serving_tables(&mut connection); + let test = TestWindow::with_script( + "RestoreUnsortedGrid", + Script { + connection, + ..Script::default() + }, + ); + test.services + .settings + .set_default_sort("primary-key") + .expect("default sort"); + test.services + .settings + .set_default_sort_direction("descending") + .expect("direction"); + let store = test.services.storage.workspaces(); + store + .schedule( + &test.key(), + WorkspaceRecord { + active_tab: Some(0), + tabs: vec![TabRecord::Table { + schema: None, + table: "orders".into(), + offset: 0, + page_size: 100, + sort: None, + filter: None, + }], + }, + ) + .expect("saved table"); + finish_on_main(WAIT, store.flush(&test.key())) + .expect("flush") + .expect("save"); + + test.window + .send(SessionWindowInput::OpenSaved(Box::new(test.saved.clone()))); + test.wait_for_page("workspace"); + let view = shell_of(&test.workspace()).imp().tab_view.clone(); + let mut restored = None; + wait_until(WAIT, || { + restored = view + .selected_page() + .and_then(|page| page.child().downcast::().ok()); + restored + .as_ref() + .is_some_and(|tab| !tab.is_loading() && tab.grid().store().len() == 1) + }) + .expect("restored table"); + assert_eq!(restored.expect("tab").current_sort(), None); +} diff --git a/linux/crates/app/src/ui/workspace/workspace_tabs.rs b/linux/crates/app/src/ui/workspace/workspace_tabs.rs index 98e2fe5436..38286b614f 100644 --- a/linux/crates/app/src/ui/workspace/workspace_tabs.rs +++ b/linux/crates/app/src/ui/workspace/workspace_tabs.rs @@ -1,3 +1,4 @@ +use crate::ui::browse_tab::InitialSort; use std::cell::RefCell; use std::collections::{HashMap, HashSet}; use std::rc::Rc; @@ -145,7 +146,7 @@ impl WorkspaceModel { page: TablePage { offset, page_size, - sort: sort.map(|sort| (sort.column, sort.ascending)), + sort: InitialSort::Kept(sort.map(|sort| (sort.column, sort.ascending))), }, filter: filter.map_or(TableFilter::Remembered, TableFilter::Kept), }, @@ -985,7 +986,7 @@ impl WorkspaceModel { page: TablePage { offset, page_size, - sort, + sort: InitialSort::Kept(sort), }, filter: TableFilter::Kept(filter), }); diff --git a/linux/crates/platform/src/settings/grid_preferences.rs b/linux/crates/platform/src/settings/grid_preferences.rs index f23cbb69dc..3384168b73 100644 --- a/linux/crates/platform/src/settings/grid_preferences.rs +++ b/linux/crates/platform/src/settings/grid_preferences.rs @@ -47,23 +47,132 @@ impl GridRowHeight { } } +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] +pub enum RowCopyFormat { + #[default] + Rows, + RowsWithHeaders, + Json, + Csv, + CsvWithHeaders, + Markdown, +} + +impl RowCopyFormat { + pub const ALL: [Self; 6] = [ + Self::Rows, + Self::RowsWithHeaders, + Self::Json, + Self::Csv, + Self::CsvWithHeaders, + Self::Markdown, + ]; + + pub fn from_nick(nick: &str) -> Self { + match nick { + "rows-headers" => Self::RowsWithHeaders, + "json" => Self::Json, + "csv" => Self::Csv, + "csv-headers" => Self::CsvWithHeaders, + "markdown" => Self::Markdown, + _ => Self::Rows, + } + } + + pub fn nick(self) -> &'static str { + match self { + Self::Rows => "rows", + Self::RowsWithHeaders => "rows-headers", + Self::Json => "json", + Self::Csv => "csv", + Self::CsvWithHeaders => "csv-headers", + Self::Markdown => "markdown", + } + } +} + +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] +pub enum DefaultSort { + #[default] + None, + PrimaryKey, + FirstColumn, +} + +impl DefaultSort { + pub const ALL: [Self; 3] = [Self::None, Self::PrimaryKey, Self::FirstColumn]; + + pub fn from_nick(nick: &str) -> Self { + match nick { + "primary-key" => Self::PrimaryKey, + "first-column" => Self::FirstColumn, + _ => Self::None, + } + } + + pub fn nick(self) -> &'static str { + match self { + Self::None => "none", + Self::PrimaryKey => "primary-key", + Self::FirstColumn => "first-column", + } + } +} + +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] +pub enum GridSortDirection { + #[default] + Ascending, + Descending, +} + +impl GridSortDirection { + pub const ALL: [Self; 2] = [Self::Ascending, Self::Descending]; + + pub fn from_nick(nick: &str) -> Self { + match nick { + "descending" => Self::Descending, + _ => Self::Ascending, + } + } + + pub fn nick(self) -> &'static str { + match self { + Self::Ascending => "ascending", + Self::Descending => "descending", + } + } + + pub fn ascending(self) -> bool { + self == Self::Ascending + } +} + #[derive(Debug, Clone, PartialEq, Eq)] pub struct GridPreferenceValues { + pub default_sort: DefaultSort, + pub default_sort_direction: GridSortDirection, pub show_row_numbers: bool, pub show_alternate_rows: bool, pub row_height: GridRowHeight, pub null_display: String, pub font: EditorFont, + pub row_copy_format: RowCopyFormat, + pub auto_show_inspector: bool, } impl Default for GridPreferenceValues { fn default() -> Self { Self { + default_sort: DefaultSort::None, + default_sort_direction: GridSortDirection::Ascending, show_row_numbers: true, show_alternate_rows: true, row_height: GridRowHeight::Normal, null_display: "NULL".to_owned(), font: EditorFont::System, + row_copy_format: RowCopyFormat::Rows, + auto_show_inspector: false, } } } @@ -71,6 +180,10 @@ impl Default for GridPreferenceValues { impl GridPreferenceValues { fn read(settings: &gio::Settings) -> Self { Self { + row_copy_format: RowCopyFormat::from_nick(&settings.string(keys::ROW_COPY_FORMAT)), + auto_show_inspector: settings.boolean(keys::AUTO_SHOW_INSPECTOR), + default_sort: DefaultSort::from_nick(&settings.string(keys::DEFAULT_SORT)), + default_sort_direction: GridSortDirection::from_nick(&settings.string(keys::DEFAULT_SORT_DIRECTION)), show_row_numbers: settings.boolean(keys::SHOW_ROW_NUMBERS), show_alternate_rows: settings.boolean(keys::SHOW_ALTERNATE_ROWS), row_height: GridRowHeight::from_nick(&settings.string(keys::GRID_ROW_HEIGHT)), @@ -143,11 +256,15 @@ impl GridPreferences { if matches!( key, keys::SHOW_ROW_NUMBERS + | keys::DEFAULT_SORT + | keys::DEFAULT_SORT_DIRECTION | keys::SHOW_ALTERNATE_ROWS | keys::GRID_ROW_HEIGHT | keys::NULL_DISPLAY | keys::GRID_USE_SYSTEM_FONT | keys::GRID_FONT + | keys::ROW_COPY_FORMAT + | keys::AUTO_SHOW_INSPECTOR ) && let Some(preferences) = weak.upgrade() { preferences.update(GridPreferenceValues::read(settings)); diff --git a/linux/crates/platform/src/settings/keys.rs b/linux/crates/platform/src/settings/keys.rs index fd4fe976b9..4017ad113c 100644 --- a/linux/crates/platform/src/settings/keys.rs +++ b/linux/crates/platform/src/settings/keys.rs @@ -11,6 +11,10 @@ pub const USE_SYSTEM_FONT: &str = "use-system-font"; pub const CUSTOM_FONT: &str = "custom-font"; pub const GRID_USE_SYSTEM_FONT: &str = "grid-use-system-font"; pub const GRID_FONT: &str = "grid-font"; +pub const AUTO_SHOW_INSPECTOR: &str = "auto-show-inspector"; +pub const DEFAULT_SORT: &str = "default-sort"; +pub const DEFAULT_SORT_DIRECTION: &str = "default-sort-direction"; +pub const ROW_COPY_FORMAT: &str = "row-copy-format"; pub const STYLE_SCHEME: &str = "style-scheme"; pub const VIM_KEYBINDINGS: &str = "vim-keybindings"; pub const CONNECT_DIALOG_DRIVER: &str = "connect-dialog-driver"; diff --git a/linux/crates/platform/src/settings/mod.rs b/linux/crates/platform/src/settings/mod.rs index 2ececf6c1d..7797f02751 100644 --- a/linux/crates/platform/src/settings/mod.rs +++ b/linux/crates/platform/src/settings/mod.rs @@ -14,7 +14,9 @@ use tablepro_core::export::{CsvDecimal, CsvDelimiter, CsvLineBreak, CsvOptions, pub use editor_font::EditorFont; pub use error::SettingsError; -pub use grid_preferences::{GridPreferenceValues, GridPreferences, GridRowHeight}; +pub use grid_preferences::{ + DefaultSort, GridPreferenceValues, GridPreferences, GridRowHeight, GridSortDirection, RowCopyFormat, +}; pub use window_geometry::WindowGeometry; /// The provider setting's value while the assistant is off. @@ -115,6 +117,38 @@ impl AppSettings { self.set_string(keys::GRID_ROW_HEIGHT, height) } + pub fn auto_show_inspector(&self) -> bool { + self.grid_preferences().snapshot().auto_show_inspector + } + + pub fn set_auto_show_inspector(&self, show: bool) -> Result<(), SettingsError> { + self.set_boolean(keys::AUTO_SHOW_INSPECTOR, show) + } + + pub fn default_sort(&self) -> DefaultSort { + self.grid_preferences().snapshot().default_sort + } + + pub fn set_default_sort(&self, behavior: &str) -> Result<(), SettingsError> { + self.set_string(keys::DEFAULT_SORT, behavior) + } + + pub fn default_sort_direction(&self) -> GridSortDirection { + self.grid_preferences().snapshot().default_sort_direction + } + + pub fn set_default_sort_direction(&self, direction: &str) -> Result<(), SettingsError> { + self.set_string(keys::DEFAULT_SORT_DIRECTION, direction) + } + + pub fn row_copy_format(&self) -> RowCopyFormat { + self.grid_preferences().snapshot().row_copy_format + } + + pub fn set_row_copy_format(&self, format: &str) -> Result<(), SettingsError> { + self.set_string(keys::ROW_COPY_FORMAT, format) + } + pub fn null_display(&self) -> String { self.grid_preferences().snapshot().null_display.clone() } diff --git a/linux/crates/platform/tests/settings.rs b/linux/crates/platform/tests/settings.rs index b30491b437..04c21a7fa7 100644 --- a/linux/crates/platform/tests/settings.rs +++ b/linux/crates/platform/tests/settings.rs @@ -533,3 +533,78 @@ async fn grid_font_uses_the_shared_snapshot_and_preserves_the_editor_font() -> T assert_eq!(calls.get(), 3); Ok(()) } + +#[glib::async_test] +async fn row_copy_format_publishes_every_format_through_the_shared_model() -> TestResult { + use std::cell::RefCell; + use std::rc::Rc; + use tablepro_linux_platform::settings::RowCopyFormat; + + let fixture = Fixture::new()?; + let preferences = fixture.settings.grid_preferences(); + let original = preferences.snapshot(); + let observed = Rc::new(RefCell::new(Vec::new())); + let updates = observed.clone(); + preferences.connect_changed(move |preferences| updates.borrow_mut().push(preferences.snapshot().row_copy_format)); + + assert_eq!(fixture.settings.row_copy_format(), RowCopyFormat::Rows); + for format in RowCopyFormat::ALL { + fixture.settings.set_row_copy_format(format.nick())?; + assert_eq!(fixture.settings.row_copy_format(), format); + assert_eq!(preferences.snapshot().row_copy_format, format); + assert_eq!(RowCopyFormat::from_nick(format.nick()), format); + } + assert_eq!(observed.borrow().as_slice(), &RowCopyFormat::ALL[1..]); + assert_eq!(original.row_copy_format, RowCopyFormat::Rows); + assert_eq!(RowCopyFormat::from_nick("unknown"), RowCopyFormat::Rows); + Ok(()) +} + +#[glib::async_test] +async fn automatic_details_preference_is_published_in_the_shared_snapshot() -> TestResult { + use gio::prelude::SettingsExt; + use std::cell::RefCell; + use std::rc::Rc; + + let fixture = Fixture::new()?; + let preferences = fixture.settings.grid_preferences(); + let original = preferences.snapshot(); + let observed = Rc::new(RefCell::new(Vec::new())); + let changes = observed.clone(); + preferences.connect_changed(move |preferences| { + changes.borrow_mut().push(preferences.snapshot().auto_show_inspector); + }); + assert!(!fixture.settings.auto_show_inspector()); + + fixture.settings.set_auto_show_inspector(true)?; + assert!(fixture.settings.auto_show_inspector()); + fixture.settings.gio().set_boolean(keys::AUTO_SHOW_INSPECTOR, false)?; + assert!(!fixture.settings.auto_show_inspector()); + assert_eq!(observed.borrow().as_slice(), &[true, false]); + assert!(!original.auto_show_inspector); + Ok(()) +} + +#[glib::async_test] +async fn default_sort_choices_and_direction_share_the_grid_snapshot() -> TestResult { + use tablepro_linux_platform::settings::{DefaultSort, GridSortDirection}; + + let fixture = Fixture::new()?; + let preferences = fixture.settings.grid_preferences(); + assert_eq!(preferences.snapshot().default_sort, DefaultSort::None); + assert_eq!( + preferences.snapshot().default_sort_direction, + GridSortDirection::Ascending + ); + for choice in DefaultSort::ALL { + fixture.settings.set_default_sort(choice.nick())?; + assert_eq!(preferences.snapshot().default_sort, choice); + } + for direction in GridSortDirection::ALL { + fixture.settings.set_default_sort_direction(direction.nick())?; + assert_eq!(preferences.snapshot().default_sort_direction, direction); + } + assert!(fixture.settings.set_default_sort("unknown").is_err()); + assert!(fixture.settings.set_default_sort_direction("sideways").is_err()); + Ok(()) +} diff --git a/linux/data/app.tablepro.TablePro.gschema.xml.in b/linux/data/app.tablepro.TablePro.gschema.xml.in index c82785d5ae..591601ee70 100644 --- a/linux/data/app.tablepro.TablePro.gschema.xml.in +++ b/linux/data/app.tablepro.TablePro.gschema.xml.in @@ -89,6 +89,47 @@ How much room a data grid row takes around its text. + + + + + + + + + + "rows" + Format of copied rows + The format Copy writes when several rows are selected. + + + + false + Open row details when a row is selected + Whether selecting a row in a data grid opens its row details pane. + + + + + + + + + "none" + Default sort of a table + The column a table tab sorts by when it opens, until the user picks another. + + + + + + + + "ascending" + Direction of the default sort + Which way a table tab sorts by its default column. + + "NULL" Text for a NULL value diff --git a/linux/data/resources/ui/preferences-data-browser-group.ui b/linux/data/resources/ui/preferences-data-browser-group.ui index 40c40db731..345df01665 100644 --- a/linux/data/resources/ui/preferences-data-browser-group.ui +++ b/linux/data/resources/ui/preferences-data-browser-group.ui @@ -43,6 +43,58 @@ + + + Open Row Details on Selection + Selecting a row opens its details pane + + + + + Default Sort + How a table is ordered when it opens + + + + No sorting (server order) + Primary key + First column + + + + + + + + Default Sort Direction + + + + Ascending + Descending + + + + + + + + Copy Rows As + The format Copy writes when several rows are selected + + + + TSV + TSV with Headers + JSON + CSV + CSV with Headers + Markdown + + + + + Text for NULL diff --git a/linux/docs/state-management.md b/linux/docs/state-management.md index 5aca04ebab..5e1fae1fc1 100644 --- a/linux/docs/state-management.md +++ b/linux/docs/state-management.md @@ -93,10 +93,12 @@ A tab belongs to its session, and a session to one window ([decisions/0028-sessi ## Grid preferences -`AppSettings` owns one `GridPreferences` object. It reads the grid keys from GSettings and announces each changed snapshot. Every grid holds that object through its settings and follows its change signal. Preferences rows bind directly to GSettings, including both directions for choices stored as strings. Each grid owns its font CSS provider, scoped to that grid and removed when the grid closes. Its custom font description supplies both the rendered font and column width measurement. +`AppSettings` owns one `GridPreferences` object. It reads the grid keys from GSettings and announces each changed snapshot. Every grid holds that object through its settings and follows its change signal. Preferences rows bind directly to GSettings, including both directions for choices stored as strings. Each grid owns its font CSS provider, scoped to that grid and removed when the grid closes. Its custom font description supplies both the rendered font and column width measurement. Automatic Row Details opening reads the same snapshot when the selection changes and opens only for a nonempty selection. Closing it keeps it closed through focus changes and clearing the selection. Turning the preference off leaves an open pane alone. Copy reads the row format from the shared snapshot when it runs; a single focused cell keeps its value format, and Copy As keeps the requested format. The snapshot belongs to its settings backend, so isolated test settings cannot change another grid. A display change redraws the existing row slots and resizes automatic columns. It keeps row selection, user column widths and active editor drafts. The formatting helpers receive display choices explicitly and keep no global preference state. +A new table tab snapshots the default sort from `GridPreferences`. `InitialSort::Default` is resolved once after accepted initial metadata, before its first page query. A metadata failure keeps it pending, and an explicit sort cancels it. Restored and reopened tabs carry `InitialSort::Kept`, including an unsorted first page. Later preference changes and refreshes preserve the tab's sort. The saved workspace format stays the same. + ## The SQL editor `SqlEditor` (`crates/app/src/ui/editor/`) runs SQL on a connection of its own and lists what each statement returned. diff --git a/linux/docs/storage.md b/linux/docs/storage.md index d70a66a716..a0ea0ffb4d 100644 --- a/linux/docs/storage.md +++ b/linux/docs/storage.md @@ -345,6 +345,10 @@ The schema id is the application id and the path follows it: `app.tablepro.Table | `show-row-numbers` | `b` | `true` | | | `grid-use-system-font` | `b` | `true` | | | `grid-font` | `s` | `Monospace 10` | | +| `auto-show-inspector` | `b` | `false` | | +| `row-copy-format` | `s` | `rows` | rows, rows-headers, json, csv, csv-headers, markdown | +| `default-sort` | `s` | `none` | `none`, `primary-key`, `first-column` | +| `default-sort-direction` | `s` | `ascending` | `ascending`, `descending` | | `grid-row-height` | `s` | `normal` | compact, normal, comfortable, spacious | | `null-display` | `s` | `NULL` | Displayed as at most 20 characters, without control characters; blank uses NULL | | `confirm-bulk-delete` | `b` | `true` | | diff --git a/linux/po/POTFILES.in b/linux/po/POTFILES.in index 879e1aa5b7..39f47748fc 100644 --- a/linux/po/POTFILES.in +++ b/linux/po/POTFILES.in @@ -193,6 +193,7 @@ crates/app/src/ui/browse_tab/count_failure_text.rs crates/app/src/ui/browse_tab/count_policy.rs crates/app/src/ui/browse_tab/data_handlers.rs crates/app/src/ui/browse_tab/data_input.rs +crates/app/src/ui/browse_tab/default_sort.rs crates/app/src/ui/browse_tab/fetch.rs crates/app/src/ui/browse_tab/grid_handlers.rs crates/app/src/ui/browse_tab/grid_input.rs @@ -211,6 +212,7 @@ crates/app/src/ui/browse_tab/row_total.rs crates/app/src/ui/browse_tab/save_handlers.rs crates/app/src/ui/browse_tab/save_input.rs crates/app/src/ui/browse_tab/table_filter.rs +crates/app/src/ui/browse_tab/tests/default_sort.rs crates/app/src/ui/browse_tab/tests/load.rs crates/app/src/ui/browse_tab/tests/mod.rs crates/app/src/ui/browse_tab/tests/references.rs