diff --git a/linux/changelog.d/4130.added.md b/linux/changelog.d/4130.added.md new file mode 100644 index 0000000000..6f75e6aca4 --- /dev/null +++ b/linux/changelog.d/4130.added.md @@ -0,0 +1 @@ +Organize saved queries in folders in the Favorites sidebar. diff --git a/linux/crates/app/src/ui/workspace/favorite_folders.rs b/linux/crates/app/src/ui/workspace/favorite_folders.rs new file mode 100644 index 0000000000..b871b144de --- /dev/null +++ b/linux/crates/app/src/ui/workspace/favorite_folders.rs @@ -0,0 +1,438 @@ +use gtk4 as gtk; +use gtk4::prelude::*; +use gtk4::subclass::prelude::*; +use libadwaita as adw; +use libadwaita::prelude::{AdwDialogExt, AlertDialogExt, PreferencesGroupExt}; +use tablepro_storage::StorageError; +use tablepro_storage::saved_queries::{SavedQuery, SavedQueryFolder}; +use uuid::Uuid; + +use super::WorkspaceShell; +use crate::i18n::{gettext, gettext_f}; + +impl WorkspaceShell { + pub(crate) fn move_favorite(&self, id: i64, folder: Option) { + self.change_favorites_with( + async move |history| history.saved_queries().set_folder(id, folder).await, + gettext("Could not move that saved query."), + move_failure_text, + ); + } + + #[cfg(test)] + pub(crate) fn create_folder(&self, name: String, parent: Option) { + if let Some(connection) = self.front().and_then(|front| front.connection_id()) { + self.create_folder_for(connection, name, parent); + } + } + + fn create_folder_for(&self, connection: Uuid, name: String, parent: Option) { + self.change_favorites_with( + async move |history| { + history + .saved_query_folders() + .create(connection, &name, parent) + .await + .map(drop) + }, + gettext("Could not create that folder."), + folder_failure_text, + ); + } + + fn rename_folder(&self, id: i64, name: String) { + self.change_favorites_with( + async move |history| history.saved_query_folders().rename(id, &name).await, + gettext("Could not rename that folder."), + folder_failure_text, + ); + } + + pub(crate) fn delete_folder(&self, id: i64) { + self.change_favorites_with( + async move |history| history.saved_query_folders().delete(id).await, + gettext("Could not delete that folder."), + folder_failure_text, + ); + } + + pub(super) fn ask_folder_name(&self, parent: Option, rename: Option) { + let Some(connection) = rename + .as_ref() + .or(parent.as_ref()) + .map(|folder| folder.connection_id) + .or_else(|| self.front().and_then(|front| front.connection_id())) + else { + return; + }; + let title = match (&rename, &parent) { + (Some(_), _) => gettext("Rename Folder"), + (None, Some(_)) => gettext("New Subfolder"), + (None, None) => gettext("New Folder"), + }; + let verb = if rename.is_some() { + gettext("Rename") + } else { + gettext("Create") + }; + let dialog = adw::AlertDialog::new(Some(&title), None); + let entry = adw::EntryRow::builder() + .title(gettext("Name")) + .activates_default(true) + .build(); + if let Some(folder) = &rename { + entry.set_text(&folder.name); + } + let group = adw::PreferencesGroup::new(); + group.add(&entry); + dialog.set_extra_child(Some(&group)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("ok", &verb); + dialog.set_response_appearance("ok", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("ok")); + dialog.set_close_response("cancel"); + crate::ui::name_entry::require_name(&dialog, "ok", &entry); + dialog.set_focus(Some(&entry)); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + let name = entry.text().trim().to_owned(); + let Some(shell) = shell.upgrade().filter(|_| response == "ok" && !name.is_empty()) else { + return; + }; + match &rename { + Some(folder) if name != folder.name => shell.rename_folder(folder.id, name), + Some(_) => {} + None => shell.create_folder_for(connection, name, parent.as_ref().map(|folder| folder.id)), + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + pub(super) fn ask_folder_deletion(&self, folder: SavedQueryFolder) { + let dialog = adw::AlertDialog::new( + Some(&gettext_f("Delete “{name}”?", &[("name", &folder.name)])), + Some(&gettext( + "This folder and its subfolders will be deleted. Their saved queries will move to the top level.", + )), + ); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("delete", &gettext("Delete")); + dialog.set_response_appearance("delete", adw::ResponseAppearance::Destructive); + dialog.set_default_response(Some("cancel")); + dialog.set_close_response("cancel"); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + if let (true, Some(shell)) = (response == "delete", shell.upgrade()) { + shell.delete_folder(folder.id); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } + + pub(super) fn ask_folder_for(&self, favorite: SavedQuery) { + let Some(pane) = self.imp().favorites.get() else { + return; + }; + let folders = pane.folder_destinations(); + let top = gettext("No Folder"); + let names: Vec<&str> = std::iter::once(top.as_str()) + .chain(folders.iter().map(|(_, path)| path.as_str())) + .collect(); + let choice = gtk::DropDown::from_strings(&names); + choice.set_enable_search(true); + choice.update_property(&[gtk::accessible::Property::Label(&gettext("Folder"))]); + let at = match favorite.folder_id { + None => 0, + Some(id) => folders + .iter() + .position(|(held, _)| *held == id) + .and_then(|position| u32::try_from(position + 1).ok()) + .unwrap_or(gtk::INVALID_LIST_POSITION), + }; + choice.set_selected(at); + choice.set_tooltip_text(names.get(at as usize).copied()); + let dialog = adw::AlertDialog::new(Some(&gettext_f("Move “{name}”", &[("name", &favorite.name)])), None); + dialog.set_extra_child(Some(&choice)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("move", &gettext("Move")); + dialog.set_response_appearance("move", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("move")); + dialog.set_close_response("cancel"); + dialog.set_response_enabled("move", false); + choice.connect_selected_notify(gtk::glib::clone!( + #[weak] + dialog, + move |choice| { + dialog.set_response_enabled( + "move", + choice.selected() != gtk::INVALID_LIST_POSITION && choice.selected() != at, + ); + let label = choice + .selected_item() + .and_downcast::() + .map(|item| item.string()); + choice.set_tooltip_text(label.as_deref()); + } + )); + dialog.set_focus(Some(&choice)); + let shell = self.downgrade(); + dialog.connect_response(None, move |_, response| { + let Some(shell) = shell.upgrade().filter(|_| response == "move") else { + return; + }; + let Some(folder) = destination(&folders, choice.selected()) else { + return; + }; + if folder != favorite.folder_id { + shell.move_favorite(favorite.id, folder); + } + }); + dialog.present(self.imp().window.upgrade().as_ref()); + } +} + +fn destination(folders: &[(i64, String)], selected: u32) -> Option> { + if selected == 0 { + Some(None) + } else { + folders.get(selected as usize - 1).map(|(id, _)| Some(*id)) + } +} + +fn folder_failure_text(error: &StorageError, fallback: &str) -> String { + match error { + StorageError::FolderNameTaken => gettext("That name is already used by another folder in the same place."), + StorageError::FolderNameInvalid => gettext("Folder names cannot contain control characters."), + StorageError::TooLarge { .. } => gettext("That folder name is too long."), + StorageError::EmptyName => gettext("Enter a name for the folder."), + StorageError::FolderCycle { .. } => gettext("A folder cannot be moved inside itself or one of its subfolders."), + StorageError::NotFound => gettext("That folder was deleted elsewhere."), + StorageError::NotInitialised => gettext("Favorites are unavailable. Restart TablePro to try again."), + _ => fallback.to_owned(), + } +} + +fn move_failure_text(error: &StorageError, fallback: &str) -> String { + match error { + StorageError::NotFound => gettext("The saved query or destination folder was deleted elsewhere."), + StorageError::NotInitialised => gettext("Favorites are unavailable. Restart TablePro to try again."), + _ => fallback.to_owned(), + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::test_support::{descendants, finish_on_main, wait_until}; + use crate::ui::session_window::tests::{TestWindow, WAIT}; + use crate::workspace::{answer, visible_alert}; + + fn ready(test: &TestWindow) -> tablepro_storage::QueryHistory { + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("history ready"); + wait_until(WAIT, || test.hold.live() == 0).expect("initial work finished"); + test.services.history().store().expect("history") + } + + fn folders(test: &TestWindow, owner: Uuid) -> Vec { + let history = test.services.history().store().expect("history"); + let task = test + .services + .tasks + .spawn_task(async move { history.saved_query_folders().list(owner).await }); + finish_on_main(WAIT, task) + .expect("read finished") + .expect("task") + .expect("folders") + } + + #[gtk4::test] + fn a_folder_write_keeps_its_hold_after_the_window_closes() { + let test = TestWindow::connected("FolderWriteClosed"); + ready(&test); + let owner = test.workspace().connection_id().expect("owner"); + let shell = test.window.shell().expect("shell"); + let (release, released) = tokio::sync::oneshot::channel(); + shell.change_favorites_with( + move |history| async move { + released.await.expect("release write"); + history + .saved_query_folders() + .create(owner, "Reports", None) + .await + .map(drop) + }, + "Create failed".to_owned(), + folder_failure_text, + ); + assert_eq!(test.hold.live(), 1); + let held = test.hold_tokens.borrow().last().expect("folder hold").clone(); + test.window.close(); + wait_until(WAIT, || !test.window.is_visible()).expect("window closed"); + assert!(held.upgrade().is_some()); + release.send(()).expect("write still waiting"); + wait_until(WAIT, || held.upgrade().is_none()).expect("folder write finished"); + assert_eq!(folders(&test, owner)[0].name, "Reports"); + } + + #[gtk4::test] + fn a_new_folder_dialog_keeps_the_connection_it_opened_for() { + let test = TestWindow::connected("FolderCapturedOwner"); + ready(&test); + let owner = test.workspace().connection_id().expect("owner"); + let shell = test.window.shell().expect("shell"); + shell.ask_folder_name(None, None); + let dialog = visible_alert(&test.window).expect("new folder prompt"); + let entry = descendants(&dialog) + .into_iter() + .find_map(|widget| widget.downcast::().ok()) + .expect("entry"); + assert!(!dialog.is_response_enabled("ok")); + entry.set_text("Reports"); + assert!(dialog.is_response_enabled("ok")); + shell.imp().front.replace(None); + shell.reload_favorites(); + answer(&test.window, "ok"); + assert_eq!(test.hold.live(), 1); + wait_until(WAIT, || test.hold.live() == 0).expect("create finished"); + let saved = folders(&test, owner); + assert_eq!(saved.len(), 1); + assert_eq!(saved[0].name, "Reports"); + assert_eq!(saved[0].connection_id, owner); + } + + #[gtk4::test] + fn choosing_the_current_destination_does_not_reorder_the_query() { + let test = TestWindow::connected("FolderMoveUnchanged"); + let history = ready(&test); + let owner = test.workspace().connection_id().expect("owner"); + let task = test.services.tasks.spawn_task(async move { + let store = history.saved_queries(); + for name in ["First", "Second"] { + store + .save(tablepro_storage::saved_queries::NewSavedQuery { + name: name.to_owned(), + query: "SELECT 1".to_owned(), + connection_id: owner, + connection_name: "local".to_owned(), + }) + .await + .expect("save"); + } + store.snapshot(owner).await.expect("snapshot") + }); + let before = finish_on_main(WAIT, task).expect("read finished").expect("task"); + let favorite = before.queries[0].clone(); + let shell = test.window.shell().expect("shell"); + shell.imp().favorites.get().expect("pane").show(before.clone()); + let history = test.services.history().store().expect("history"); + let changes = history.saved_queries().changes(); + shell.ask_folder_for(favorite.clone()); + let dialog = visible_alert(&test.window).expect("move prompt"); + assert!(!dialog.is_response_enabled("move")); + answer(&test.window, "move"); + assert_eq!(test.hold.live(), 0); + assert!(!changes.has_changed().expect("no change")); + shell.move_favorite(favorite.id, None); + wait_until(WAIT, || test.hold.live() == 0).expect("no-op finished"); + let task = test + .services + .tasks + .spawn_task(async move { history.saved_queries().snapshot(owner).await }); + let after = finish_on_main(WAIT, task) + .expect("read finished") + .expect("task") + .expect("snapshot"); + assert_eq!(after, before); + assert!(!changes.has_changed().expect("no revision")); + } + + #[gtk4::test] + fn folder_deletion_requires_confirmation_and_preserves_queries() { + let test = TestWindow::connected("FolderDeleteConfirmed"); + let history = ready(&test); + let owner = test.workspace().connection_id().expect("owner"); + let task = test.services.tasks.spawn_task(async move { + let folders = history.saved_query_folders(); + let parent = folders.create(owner, "Reports", None).await.expect("parent"); + let child = folders.create(owner, "Monthly", Some(parent)).await.expect("child"); + let saved = history + .saved_queries() + .save(tablepro_storage::saved_queries::NewSavedQuery { + name: "Report".to_owned(), + query: "SELECT 1".to_owned(), + connection_id: owner, + connection_name: "local".to_owned(), + }) + .await + .expect("save"); + history + .saved_queries() + .move_to_folder(saved.id, Some(child), None) + .await + .expect("file"); + folders + .list(owner) + .await + .expect("folders") + .into_iter() + .find(|folder| folder.id == parent) + .expect("parent") + }); + let parent = finish_on_main(WAIT, task).expect("read finished").expect("task"); + let shell = test.window.shell().expect("shell"); + shell.ask_folder_deletion(parent.clone()); + let dialog = visible_alert(&test.window).expect("delete prompt"); + assert_eq!(dialog.default_response().as_deref(), Some("cancel")); + assert_eq!( + dialog.response_appearance("delete"), + adw::ResponseAppearance::Destructive + ); + answer(&test.window, "cancel"); + wait_until(WAIT, || visible_alert(&test.window).is_none()).expect("cancelled"); + assert_eq!(folders(&test, owner).len(), 2); + shell.ask_folder_deletion(parent); + answer(&test.window, "delete"); + assert_eq!(test.hold.live(), 1); + wait_until(WAIT, || test.hold.live() == 0).expect("deleted"); + assert!(folders(&test, owner).is_empty()); + let history = test.services.history().store().expect("history"); + let task = test + .services + .tasks + .spawn_task(async move { history.saved_queries().list(Some(owner)).await }); + let saved = finish_on_main(WAIT, task) + .expect("read finished") + .expect("task") + .expect("queries"); + assert_eq!(saved.len(), 1); + assert_eq!(saved[0].query, "SELECT 1"); + assert_eq!(saved[0].folder_id, None); + } + + #[test] + fn a_destination_never_converts_an_invalid_selection_into_the_root() { + let choices = vec![(42, "/No Folder".to_owned()), (7, "/Reports/Monthly".to_owned())]; + assert_eq!(destination(&choices, 0), Some(None)); + assert_eq!(destination(&choices, 1), Some(Some(42))); + assert_eq!(destination(&choices, 2), Some(Some(7))); + assert_eq!(destination(&choices, 3), None); + assert_eq!(destination(&choices, gtk::INVALID_LIST_POSITION), None); + } + + #[test] + fn folder_and_move_failures_name_the_missing_record() { + assert_eq!( + folder_failure_text(&StorageError::NotFound, "fallback"), + "That folder was deleted elsewhere." + ); + assert_eq!( + move_failure_text(&StorageError::NotFound, "fallback"), + "The saved query or destination folder was deleted elsewhere." + ); + assert_eq!( + folder_failure_text(&StorageError::FolderNameTaken, "fallback"), + "That name is already used by another folder in the same place." + ); + } +} diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 0e99c0bf75..2a788dcce5 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -13,6 +13,7 @@ mod database_transfer; mod definitions; mod diagram; mod editor_label; +mod favorite_folders; mod finished_work; mod health_banner; mod imp; diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_index.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_index.rs new file mode 100644 index 0000000000..741cee5351 --- /dev/null +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_index.rs @@ -0,0 +1,229 @@ +use std::collections::{HashMap, HashSet}; + +use tablepro_storage::saved_queries::{SavedQueriesSnapshot, SavedQuery, SavedQueryFolder}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub(super) enum Key { + Folder(i64), + Query(i64), +} + +impl Key { + pub(super) fn target(self) -> String { + match self { + Self::Folder(id) => format!("f{id}"), + Self::Query(id) => format!("q{id}"), + } + } + + pub(super) fn parse(target: &str) -> Option { + let (kind, id) = target.split_at_checked(1)?; + let id = id.parse().ok()?; + match kind { + "f" => Some(Self::Folder(id)), + "q" => Some(Self::Query(id)), + _ => None, + } + } +} + +#[derive(Debug, Clone)] +pub(super) enum Node { + Folder(SavedQueryFolder), + Query(SavedQuery), +} + +impl Node { + pub(super) fn key(&self) -> Key { + match self { + Self::Folder(folder) => Key::Folder(folder.id), + Self::Query(query) => Key::Query(query.id), + } + } + + pub(super) fn name(&self) -> &str { + match self { + Self::Folder(folder) => &folder.name, + Self::Query(query) => &query.name, + } + } + + pub(super) fn parent(&self) -> Option { + match self { + Self::Folder(folder) => folder.parent_id, + Self::Query(query) => query.folder_id, + } + } + + fn order(&self) -> (u8, i64, String, i64) { + match self { + Self::Folder(folder) => (0, folder.order, folder.name.to_lowercase(), folder.id), + Self::Query(query) => (1, query.order, query.name.to_lowercase(), query.id), + } + } +} + +#[derive(Default)] +pub(super) struct Index { + pub(super) nodes: HashMap, + children: HashMap, Vec>, + paths: HashMap, +} + +impl Index { + pub(super) fn new(snapshot: SavedQueriesSnapshot) -> Option { + let mut index = Self::default(); + let mut owners = HashSet::new(); + for node in snapshot + .folders + .into_iter() + .map(Node::Folder) + .chain(snapshot.queries.into_iter().map(Node::Query)) + { + owners.insert(match &node { + Node::Folder(folder) => folder.connection_id, + Node::Query(query) => query.connection_id, + }); + index.children.entry(node.parent()).or_default().push(node.key()); + if index.nodes.insert(node.key(), node).is_some() { + return None; + } + } + if owners.len() > 1 { + return None; + } + for keys in index.children.values_mut() { + keys.sort_by_cached_key(|key| index.nodes[key].order()); + } + let mut pending = vec![(None, String::new())]; + let mut visited = HashSet::new(); + while let Some((parent, path)) = pending.pop() { + for key in index.children.get(&parent).into_iter().flatten() { + if !visited.insert(*key) { + return None; + } + if let Key::Folder(id) = key { + let name = index.nodes[key].name().replace('\\', "\\\\").replace('/', "\\/"); + let path = format!("{path}/{name}"); + index.paths.insert(*id, path.clone()); + pending.push((Some(*id), path)); + } + } + } + (visited.len() == index.nodes.len()).then_some(index) + } + + pub(super) fn children(&self, parent: Option) -> &[Key] { + self.children.get(&parent).map_or(&[], Vec::as_slice) + } + + pub(super) fn path(&self, id: i64) -> Option<&str> { + self.paths.get(&id).map(String::as_str) + } + + pub(super) fn destinations(&self) -> Vec<(i64, String)> { + let mut folders: Vec<_> = self.paths.iter().map(|(id, path)| (*id, path.clone())).collect(); + folders.sort_by_cached_key(|(id, path)| (path.to_lowercase(), path.clone(), *id)); + folders + } + + #[cfg(test)] + pub(super) fn queries(&self) -> Vec { + let mut queries: Vec<_> = self + .nodes + .values() + .filter_map(|node| match node { + Node::Query(query) => Some(query.clone()), + Node::Folder(_) => None, + }) + .collect(); + queries.sort_by_key(|query| (query.folder_id, query.order, query.name.to_lowercase(), query.id)); + queries + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::time::SystemTime; + use uuid::Uuid; + + fn folder(id: i64, name: &str, parent_id: Option) -> SavedQueryFolder { + SavedQueryFolder { + id, + name: name.to_owned(), + parent_id, + connection_id: Uuid::nil(), + order: 0, + created_at: SystemTime::UNIX_EPOCH, + updated_at: SystemTime::UNIX_EPOCH, + } + } + + #[test] + fn folder_destinations_distinguish_ancestry_separators_and_the_root_label() { + let index = Index::new(SavedQueriesSnapshot { + queries: vec![], + folders: vec![ + folder(1, "Reports", None), + folder(2, "Monthly", Some(1)), + folder(3, "Archive", None), + folder(4, "Monthly", Some(3)), + folder(5, "Reports/Monthly", None), + folder(6, "No Folder", None), + folder(7, "a\\/b", None), + ], + }) + .expect("valid hierarchy"); + assert_eq!( + index.destinations(), + vec![ + (7, "/a\\\\\\/b".to_owned()), + (3, "/Archive".to_owned()), + (4, "/Archive/Monthly".to_owned()), + (6, "/No Folder".to_owned()), + (1, "/Reports".to_owned()), + (2, "/Reports/Monthly".to_owned()), + (5, "/Reports\\/Monthly".to_owned()), + ] + ); + } + + #[test] + fn malformed_hierarchies_are_refused_instead_of_hiding_queries_or_recursing() { + for folders in [ + vec![folder(1, "Orphan", Some(99))], + vec![folder(1, "Cycle", Some(2)), folder(2, "Cycle", Some(1))], + vec![folder(1, "Duplicate", None), folder(1, "Duplicate", None)], + ] { + assert!( + Index::new(SavedQueriesSnapshot { + queries: vec![], + folders + }) + .is_none() + ); + } + } + + #[test] + fn typed_keys_and_sibling_order_are_stable() { + let mut first = folder(8, "Z", None); + first.order = 0; + let mut second = folder(3, "A", None); + second.order = 1; + let index = Index::new(SavedQueriesSnapshot { + queries: vec![], + folders: vec![second, first], + }) + .expect("index"); + assert_eq!(index.children(None), [Key::Folder(8), Key::Folder(3)]); + assert_ne!(Key::Folder(3), Key::Query(3)); + for key in [Key::Folder(3), Key::Query(3)] { + assert_eq!(Key::parse(&key.target()), Some(key)); + } + for text in ["", "😀", "qabc", "x3"] { + assert_eq!(Key::parse(text), None); + } + } +} diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 45dd2c3086..723722ed8c 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -1,131 +1,155 @@ +#[path = "favorites_index.rs"] +mod index; +#[path = "favorites_rows.rs"] +mod rows; +#[cfg(test)] +#[path = "favorites_pane_tests.rs"] +mod tests; + +use std::cell::{Cell, RefCell}; +use std::collections::{HashMap, HashSet}; use std::rc::Rc; use gtk4 as gtk; use gtk4::prelude::*; use gtk4::{gio, glib}; use libadwaita as adw; -use tablepro_storage::saved_queries::SavedQuery; +use tablepro_storage::saved_queries::{SavedQueriesSnapshot, SavedQuery, SavedQueryFolder}; -use crate::i18n::{gettext, gettext_f}; +use crate::i18n::gettext; +use index::{Index, Key, Node}; const LIST: &str = "list"; const EMPTY: &str = "empty"; +const ROW: &str = "favorite-row"; +const KEYS: &str = "favorite-keys"; +const RENAME: &str = "rename"; +const DELETE: &str = "delete"; +const MOVE: &str = "move"; +const NEW_FOLDER: &str = "new-folder"; #[derive(Debug, Clone)] pub(crate) enum FavoriteAction { Open(String), Rename(SavedQuery), Delete(SavedQuery), + MoveTo(SavedQuery), + NewFolder(Option), + RenameFolder(SavedQueryFolder), + DeleteFolder(SavedQueryFolder), } type Asked = Rc; - -const ROW: &str = "favorite-row"; -const RENAME: &str = "rename"; -const DELETE: &str = "delete"; -const KEYS: &str = "favorite-keys"; +type SharedIndex = Rc>>; #[derive(Clone)] pub(crate) struct FavoritesPane { + whole: gtk::Box, stack: gtk::Stack, store: gio::ListStore, + tree: gtk::TreeListModel, + index: SharedIndex, + expansion: Rc, selection: gtk::SingleSelection, menu: gtk::PopoverMenu, error: adw::StatusPage, retry: gtk::Button, stale: adw::Banner, + new_folder: gtk::Button, } impl FavoritesPane { pub(crate) fn new(asked: impl Fn(FavoriteAction) + 'static, retry: impl Fn() + 'static) -> Self { + let asked: Asked = Rc::new(asked); let store = gio::ListStore::new::(); + let index: SharedIndex = Rc::default(); + let tree = gtk::TreeListModel::new(store.clone(), false, false, { + let index = index.clone(); + move |item| match *item.downcast_ref::()?.borrow::() { + Key::Folder(id) => Some(model_of(&index.borrow(), Some(id)).upcast()), + Key::Query(_) => None, + } + }); + let expansion = Rc::new(Expansion::default()); + let selection = gtk::SingleSelection::builder() - .model(&store) + .model(&tree) .autoselect(false) .can_unselect(true) .build(); - let list = gtk::ListView::new(Some(selection.clone()), Some(factory())); + let list = gtk::ListView::new(Some(selection.clone()), Some(rows::factory(index.clone()))); + // Selection and view must process an insertion before restoring expansion emits nested insertions. + tree.connect_items_changed({ + let expansion = Rc::downgrade(&expansion); + move |tree, _, _, _| { + if let Some(expansion) = expansion.upgrade() { + expansion.observe(tree); + } + } + }); list.add_css_class("navigation-sidebar"); list.set_single_click_activate(true); list.update_property(&[gtk::accessible::Property::Label(&gettext("Favorites"))]); - let asked: Asked = Rc::new(asked); - let opened = asked.clone(); - let model = store.clone(); - list.connect_activate(move |_, position| { - if let Some(favorite) = favorite_at(&model, position) { - opened(FavoriteAction::Open(favorite.query)); + list.connect_activate({ + let (tree, index, asked) = (tree.clone(), index.clone(), asked.clone()); + move |_, position| { + let Some(row) = tree.row(position) else { + return; + }; + match key_of(&row).and_then(|key| index.borrow().nodes.get(&key).cloned()) { + Some(Node::Query(query)) => asked(FavoriteAction::Open(query.query)), + Some(Node::Folder(_)) => row.set_expanded(!row.is_expanded()), + None => {} + } } }); - let menu = install_menu(&list, &store, &selection, &asked); - let scrolled = gtk::ScrolledWindow::builder() - .hscrollbar_policy(gtk::PolicyType::Never) - .child(&list) - .build(); - let retry = Rc::new(retry); - let retry_button = gtk::Button::with_label(&gettext("Try Again")); - retry_button.set_halign(gtk::Align::Center); - retry_button.connect_clicked({ - let retry = retry.clone(); - move |_| retry() - }); - let error = adw::StatusPage::builder() - .title(gettext("Favorites Unavailable")) - .icon_name("dialog-warning-symbolic") - .child(&retry_button) - .build(); - error.add_css_class("compact"); - let stale = adw::Banner::builder() - .title(gettext("Favorites could not be refreshed.")) - .button_label(gettext("Try Again")) - .build(); - stale.connect_button_clicked(move |_| retry()); - let content = gtk::Box::new(gtk::Orientation::Vertical, 0); - content.append(&stale); - scrolled.set_vexpand(true); - content.append(&scrolled); - let empty = adw::StatusPage::builder() - .title(gettext("No Favorites")) - .icon_name("starred-symbolic") - .description(gettext("Save a query from the SQL editor to find it here.")) - .build(); - empty.add_css_class("compact"); - let stack = gtk::Stack::new(); - stack.add_named(&content, Some(LIST)); - stack.add_named(&error, Some("error")); - let loading = adw::StatusPage::builder() - .title(gettext("Loading Favorites")) - .child(&adw::Spinner::new()) + let menu = rows::install_menu(&list, &tree, &index, &selection, &asked); + let (stack, error, retry, stale) = status_pages(&list, Rc::new(retry)); + let new_folder = gtk::Button::builder() + .icon_name("folder-new-symbolic") + .halign(gtk::Align::Start) + .margin_top(6) + .margin_bottom(6) + .margin_start(6) + .sensitive(false) .build(); - loading.add_css_class("compact"); - stack.add_named(&loading, Some("loading")); - let disconnected = adw::StatusPage::builder() - .title(gettext("No Connection Selected")) - .description(gettext("Open a connection to see its saved queries.")) - .icon_name("starred-symbolic") - .build(); - disconnected.add_css_class("compact"); - stack.add_named(&disconnected, Some("disconnected")); - stack.add_named(&empty, Some(EMPTY)); - stack.set_visible_child_name(EMPTY); + new_folder.add_css_class("flat"); + new_folder.set_tooltip_text(Some(&gettext("New Folder"))); + new_folder.update_property(&[gtk::accessible::Property::Label(&gettext("New Folder"))]); + new_folder.connect_clicked(move |_| asked(FavoriteAction::NewFolder(None))); + let whole = gtk::Box::new(gtk::Orientation::Vertical, 0); + whole.append(&stack); + whole.append(&new_folder); Self { + whole, stack, store, + tree, + index, + expansion, selection, menu, error, - retry: retry_button, + retry, stale, + new_folder, } } pub(crate) fn widget(&self) -> gtk::Widget { - self.stack.clone().upcast() + self.whole.clone().upcast() } pub(crate) fn clear(&self) { self.menu.popdown(); + self.expansion.reset_rows(); + self.expansion.expanded.borrow_mut().clear(); + self.index.replace(Rc::default()); self.store.remove_all(); + self.expansion.updating.set(false); + self.selection.set_selected(gtk::INVALID_LIST_POSITION); self.stale.set_revealed(false); + self.new_folder.set_sensitive(false); } pub(crate) fn no_connection(&self) { @@ -134,6 +158,7 @@ impl FavoritesPane { } pub(crate) fn loading(&self) { + self.new_folder.set_sensitive(false); self.stale.set_revealed(false); if self.store.n_items() == 0 { self.stack.set_visible_child_name("loading"); @@ -150,6 +175,7 @@ impl FavoritesPane { } pub(crate) fn failed(&self) { + self.new_folder.set_sensitive(false); if self.store.n_items() > 0 { self.stale.set_revealed(true); return; @@ -160,508 +186,196 @@ impl FavoritesPane { self.stack.set_visible_child_name("error"); } - pub(crate) fn show(&self, favorites: Vec) { + pub(crate) fn show(&self, snapshot: SavedQueriesSnapshot) { + let Some(index) = Index::new(snapshot) else { + tracing::warn!("invalid saved query folder hierarchy"); + self.failed(); + return; + }; self.menu.popdown(); - let selected = favorite_at(&self.store, self.selection.selected()).map(|saved| saved.id); - let selected_position = favorites.iter().position(|saved| Some(saved.id) == selected); - let items: Vec = favorites.into_iter().map(glib::BoxedAnyObject::new).collect(); + let selected = self.tree.row(self.selection.selected()).as_ref().and_then(key_of); + self.expansion.reset_rows(); + self.expansion + .expanded + .borrow_mut() + .retain(|id| index.nodes.contains_key(&Key::Folder(*id))); + let items: Vec<_> = index + .children(None) + .iter() + .copied() + .map(glib::BoxedAnyObject::new) + .collect(); + self.index.replace(Rc::new(index)); self.store.splice(0, self.store.n_items(), &items); - self.selection - .set_selected(selected_position.map_or(gtk::INVALID_LIST_POSITION, |position| position as u32)); + self.expansion.updating.set(false); + self.expansion.observe(&self.tree); + self.selection.set_selected( + selected + .and_then(|key| position_of(&self.tree, key)) + .unwrap_or(gtk::INVALID_LIST_POSITION), + ); self.stale.set_revealed(false); + self.new_folder.set_sensitive(true); self.stack .set_visible_child_name(if items.is_empty() { EMPTY } else { LIST }); } + pub(crate) fn folder_destinations(&self) -> Vec<(i64, String)> { + self.index.borrow().destinations() + } + #[cfg(test)] pub(crate) fn ids(&self) -> Vec { - (0..self.store.n_items()) - .filter_map(|position| favorite_at(&self.store, position)) - .map(|favorite| favorite.id) - .collect() + self.index.borrow().queries().iter().map(|query| query.id).collect() } #[cfg(test)] pub(crate) fn names(&self) -> Vec { - (0..self.store.n_items()) - .filter_map(|position| favorite_at(&self.store, position)) - .map(|favorite| favorite.name) + self.index + .borrow() + .queries() + .into_iter() + .map(|query| query.name) .collect() } -} - -fn favorite_at(store: &gio::ListStore, position: u32) -> Option { - let item = store.item(position).and_downcast::()?; - Some(item.borrow::().clone()) -} - -fn factory() -> gtk::SignalListItemFactory { - let factory = gtk::SignalListItemFactory::new(); - factory.connect_setup(|_, item| { - let Some(item) = item.downcast_ref::() else { - return; - }; - let name = gtk::Label::builder() - .xalign(0.0) - .ellipsize(gtk::pango::EllipsizeMode::End) - .build(); - let summary = gtk::Label::builder() - .xalign(0.0) - .ellipsize(gtk::pango::EllipsizeMode::End) - .build(); - summary.add_css_class("caption"); - summary.add_css_class("dimmed"); - let labels = gtk::Box::builder() - .orientation(gtk::Orientation::Vertical) - .spacing(2) - .hexpand(true) - .valign(gtk::Align::Center) - .build(); - labels.append(&name); - labels.append(&summary); - let menu = gtk::MenuButton::builder() - .icon_name("view-more-symbolic") - .valign(gtk::Align::Center) - .build(); - menu.add_css_class("flat"); - let row = gtk::Box::builder().spacing(6).margin_top(6).margin_bottom(6).build(); - row.add_css_class(ROW); - row.append(&labels); - row.append(&menu); - item.set_child(Some(&row)); - }); - factory.connect_bind(move |_, item| { - let Some(item) = item.downcast_ref::() else { - return; - }; - let (Some(object), Some(row)) = (item.item().and_downcast::(), item.child()) else { - return; - }; - let favorite = object.borrow::().clone(); - row.set_widget_name(&favorite.id.to_string()); - if let Some(labels) = row.first_child() { - if let Some(name) = labels.first_child().and_downcast::() { - name.set_label(&favorite.name); - } - if let Some(summary) = labels.last_child().and_downcast::() { - summary.set_label(favorite.summary()); - summary.set_visible(!favorite.summary().is_empty()); - } - } - if let Some(menu) = row.last_child().and_downcast::() { - let label = gettext_f("Options for “{name}”", &[("name", &favorite.name)]); - menu.set_tooltip_text(Some(&label)); - menu.update_property(&[gtk::accessible::Property::Label(&label)]); - menu.set_menu_model(Some(&menu_of(favorite.id))); - } - item.set_accessible_label(&favorite.name); - }); - factory.connect_unbind(|_, item| { - let Some(row) = item.downcast_ref::().and_then(|item| item.child()) else { - return; - }; - row.set_widget_name(""); - if let Some(menu) = row.last_child().and_downcast::() { - menu.popdown(); - menu.set_menu_model(None::<&gio::MenuModel>); - } - }); - factory -} -fn install_menu( - list: >k::ListView, - store: &gio::ListStore, - selection: >k::SingleSelection, - asked: &Asked, -) -> gtk::PopoverMenu { - let actions = gio::SimpleActionGroup::new(); - for (name, make) in [ - (RENAME, FavoriteAction::Rename as fn(SavedQuery) -> FavoriteAction), - (DELETE, FavoriteAction::Delete), - ] { - let action = gio::SimpleAction::new(name, Some(glib::VariantTy::INT64)); - let (store, asked) = (store.clone(), asked.clone()); - action.connect_activate(move |_, target| { - let Some(id) = target.and_then(|target| target.get::()) else { - return; - }; - if let Some(favorite) = favorite_by_id(&store, id) { - asked(make(favorite)); - } - }); - actions.add_action(&action); - } - list.insert_action_group("favorite", Some(&actions)); - - let menu = gtk::PopoverMenu::from_model(None::<&gio::MenuModel>); - menu.set_has_arrow(false); - menu.set_parent(list); - let click = gtk::GestureClick::builder().button(gtk::gdk::BUTTON_SECONDARY).build(); - { - let (list, store, menu) = (list.downgrade(), store.clone(), menu.clone()); - click.connect_pressed(move |gesture, _, x, y| { - let Some(list) = list.upgrade() else { - return; - }; - let Some(favorite) = row_at(&list, &store, x, y) else { - return; - }; - gesture.set_state(gtk::EventSequenceState::Claimed); - menu.set_menu_model(Some(&menu_of(favorite.id))); - menu.set_pointing_to(Some(>k::gdk::Rectangle::new(x as i32, y as i32, 1, 1))); - menu.popup(); - }); + #[cfg(test)] + pub(crate) fn folder_of_first_query(&self) -> Option { + self.index.borrow().queries().first().and_then(|query| query.folder_id) } - list.add_controller(click); - // GTK requires manually parented popovers to leave before their parent is finalized. - list.connect_destroy({ - let menu = menu.clone(); - move |_| menu.unparent() - }); - - install_keys(list, store, selection, asked, &menu); - menu } -fn install_keys( - list: >k::ListView, - store: &gio::ListStore, - selection: >k::SingleSelection, - asked: &Asked, - menu: >k::PopoverMenu, -) { - let keys = gtk::EventControllerKey::new(); - keys.set_name(Some(KEYS)); - let (selection, store, asked, menu_for_key, list_weak) = ( - selection.clone(), - store.clone(), - asked.clone(), - menu.clone(), - list.downgrade(), - ); - keys.connect_key_pressed(move |_, key, _, modifiers| { - let modifiers = modifiers.intersection(gtk::accelerator_get_default_mod_mask()); - let Some(favorite) = favorite_at(&store, selection.selected()) else { - return glib::Propagation::Proceed; - }; - if (key == gtk::gdk::Key::Menu && modifiers.is_empty()) - || (key == gtk::gdk::Key::F10 && modifiers == gtk::gdk::ModifierType::SHIFT_MASK) - { - let Some(list) = list_weak.upgrade() else { - return glib::Propagation::Proceed; - }; - let bounds = find_row(&list, favorite.id).and_then(|row| row.compute_bounds(&list)); - let anchor = bounds.map(|bounds| { - gtk::gdk::Rectangle::new( - bounds.x() as i32, - bounds.y() as i32, - bounds.width() as i32, - bounds.height() as i32, - ) - }); - menu_for_key.set_menu_model(Some(&menu_of(favorite.id))); - menu_for_key.set_pointing_to(anchor.as_ref()); - menu_for_key.popup(); - return glib::Propagation::Stop; - } - if !modifiers.is_empty() { - return glib::Propagation::Proceed; - } - match key { - gtk::gdk::Key::F2 => asked(FavoriteAction::Rename(favorite)), - gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete => asked(FavoriteAction::Delete(favorite)), - _ => return glib::Propagation::Proceed, - } - glib::Propagation::Stop +fn status_pages(list: >k::ListView, retry: Rc) -> (gtk::Stack, adw::StatusPage, gtk::Button, adw::Banner) { + let retry_button = gtk::Button::with_label(&gettext("Try Again")); + retry_button.set_halign(gtk::Align::Center); + retry_button.connect_clicked({ + let retry = retry.clone(); + move |_| retry() }); - list.add_controller(keys); + let error = adw::StatusPage::builder() + .title(gettext("Favorites Unavailable")) + .icon_name("dialog-warning-symbolic") + .child(&retry_button) + .build(); + error.add_css_class("compact"); + let stale = adw::Banner::builder() + .title(gettext("Favorites could not be refreshed.")) + .button_label(gettext("Try Again")) + .build(); + stale.connect_button_clicked(move |_| retry()); + let content = gtk::Box::new(gtk::Orientation::Vertical, 0); + content.append(&stale); + content.append( + >k::ScrolledWindow::builder() + .hscrollbar_policy(gtk::PolicyType::Never) + .vexpand(true) + .child(list) + .build(), + ); + let empty = adw::StatusPage::builder() + .title(gettext("No Favorites")) + .icon_name("starred-symbolic") + .description(gettext( + "Save a query from the SQL editor or create a folder to organize favorites.", + )) + .build(); + empty.add_css_class("compact"); + let stack = gtk::Stack::builder().vexpand(true).build(); + stack.add_named(&content, Some(LIST)); + stack.add_named(&error, Some("error")); + let loading = adw::StatusPage::builder() + .title(gettext("Loading Favorites")) + .child(&adw::Spinner::new()) + .build(); + loading.add_css_class("compact"); + stack.add_named(&loading, Some("loading")); + let disconnected = adw::StatusPage::builder() + .title(gettext("No Connection Selected")) + .description(gettext("Open a connection to see its saved queries.")) + .icon_name("starred-symbolic") + .build(); + disconnected.add_css_class("compact"); + stack.add_named(&disconnected, Some("disconnected")); + stack.add_named(&empty, Some(EMPTY)); + stack.set_visible_child_name(EMPTY); + (stack, error, retry_button, stale) } -fn menu_of(id: i64) -> gio::Menu { - let menu = gio::Menu::new(); - for (label, action) in [(gettext("_Rename…"), RENAME), (gettext("_Delete…"), DELETE)] { - let item = gio::MenuItem::new(Some(&label), None); - item.set_action_and_target_value(Some(&format!("favorite.{action}")), Some(&id.to_variant())); - menu.append_item(&item); +fn model_of(index: &Index, parent: Option) -> gio::ListStore { + let store = gio::ListStore::new::(); + for key in index.children(parent) { + store.append(&glib::BoxedAnyObject::new(*key)); } - menu + store } -fn favorite_by_id(store: &gio::ListStore, id: i64) -> Option { - (0..store.n_items()) - .filter_map(|position| favorite_at(store, position)) - .find(|favorite| favorite.id == id) +fn key_of(row: >k::TreeListRow) -> Option { + Some(*row.item().and_downcast::()?.borrow::()) } -fn row_at(list: >k::ListView, store: &gio::ListStore, x: f64, y: f64) -> Option { - let mut widget = list.pick(x, y, gtk::PickFlags::DEFAULT); - while let Some(candidate) = widget { - if candidate.has_css_class(ROW) { - return candidate - .widget_name() - .parse() - .ok() - .and_then(|id| favorite_by_id(store, id)); - } - widget = candidate.parent(); - } - None +fn position_of(tree: >k::TreeListModel, key: Key) -> Option { + (0..tree.n_items()).find(|position| tree.row(*position).as_ref().and_then(key_of) == Some(key)) } -fn find_row(widget: &impl IsA, id: i64) -> Option { - let widget = widget.as_ref(); - if widget.has_css_class(ROW) && widget.widget_name() == id.to_string() { - return Some(widget.clone()); - } - let mut child = widget.first_child(); - while let Some(current) = child { - if let Some(row) = find_row(¤t, id) { - return Some(row); - } - child = current.next_sibling(); - } - None +#[derive(Default)] +struct Expansion { + expanded: RefCell>, + watched: RefCell>, + updating: Cell, } -#[cfg(test)] -mod tests { - use super::*; - use std::time::SystemTime; - use uuid::Uuid; - - fn saved(id: i64, name: &str) -> SavedQuery { - SavedQuery { - id, - name: name.to_owned(), - query: "SELECT 1".to_owned(), - connection_id: Uuid::nil(), - connection_name: "Database".to_owned(), - keyword: None, - folder_id: None, - order: 0, - created_at: SystemTime::UNIX_EPOCH, - updated_at: SystemTime::UNIX_EPOCH, +impl Expansion { + fn reset_rows(&self) { + self.updating.set(true); + for (_, (row, watch)) in self.watched.take() { + row.disconnect(watch); } } - #[gtk4::test] - fn favorites_keep_selection_by_id_after_rename_and_reorder() { - let pane = FavoritesPane::new(|_| {}, || {}); - pane.show(vec![saved(1, "One"), saved(2, "Two")]); - pane.selection.set_selected(1); - pane.show(vec![saved(2, "Renamed"), saved(1, "One")]); - assert_eq!(pane.selection.selected(), 0); - pane.show(vec![saved(1, "One")]); - assert_eq!(pane.selection.selected(), gtk::INVALID_LIST_POSITION); - } - - #[gtk4::test] - fn favorites_distinguish_loading_empty_unavailable_and_failed_refresh() { - let retried = Rc::new(std::cell::Cell::new(false)); - let retry = retried.clone(); - let pane = FavoritesPane::new(|_| {}, move || retry.set(true)); - pane.loading(); - assert_eq!(pane.stack.visible_child_name().as_deref(), Some("loading")); - pane.failed(); - assert_eq!(pane.stack.visible_child_name().as_deref(), Some("error")); - pane.retry.emit_clicked(); - assert!(retried.get()); - pane.show(vec![]); - assert_eq!(pane.stack.visible_child_name().as_deref(), Some(EMPTY)); - pane.show(vec![saved(1, "One")]); - pane.failed(); - assert!(pane.stale.is_revealed()); - assert_eq!(pane.names(), ["One"]); - pane.unavailable(); - assert!(!pane.retry.is_visible()); - assert!(pane.names().is_empty()); - pane.no_connection(); - assert_eq!(pane.stack.visible_child_name().as_deref(), Some("disconnected")); - } - - type Actions = Rc>>; - const WAIT: std::time::Duration = std::time::Duration::from_secs(30); - - fn shown() -> (FavoritesPane, crate::test_support::OwnedWindow, Actions) { - adw::init().expect("libadwaita"); - let actions = Actions::default(); - let sink = actions.clone(); - let pane = FavoritesPane::new(move |action| sink.borrow_mut().push(action), || {}); - pane.show(vec![saved(1, "One"), saved(2, "Two")]); - let window = gtk::Window::builder() - .default_width(360) - .default_height(360) - .child(&pane.widget()) - .build(); - let window = crate::test_support::OwnedWindow::presented(window); - crate::test_support::wait_until(WAIT, || find_row(&list(&pane), 2).is_some_and(|row| row.height() > 0)) - .expect("rows laid out"); - (pane, window, actions) - } - - fn list(pane: &FavoritesPane) -> gtk::ListView { - pane.menu - .parent() - .and_downcast::() - .expect("menu belongs to list") - } - - fn press(pane: &FavoritesPane, key: gtk::gdk::Key, modifiers: gtk::gdk::ModifierType) -> bool { - let controllers = list(pane).observe_controllers(); - let keys = (0..controllers.n_items()) - .filter_map(|position| controllers.item(position).and_downcast::()) - .find(|keys| keys.name().as_deref() == Some(KEYS)) - .expect("favorite key handler"); - keys.emit_by_name::("key-pressed", &[&key, &0u32, &modifiers]) - } - - fn target(menu: &impl IsA, position: i32) -> glib::Variant { - menu.as_ref() - .item_attribute_value(position, "target", None) - .expect("menu target") - } - - fn requested(actions: &Actions) -> Vec<(&'static str, i64, String)> { - actions - .borrow() - .iter() - .filter_map(|action| match action { - FavoriteAction::Rename(saved) => Some(("rename", saved.id, saved.name.clone())), - FavoriteAction::Delete(saved) => Some(("delete", saved.id, saved.name.clone())), - FavoriteAction::Open(_) => None, - }) - .collect() - } - - #[gtk4::test] - fn a_favorite_has_a_named_menu_button_that_acts_on_its_row() { - let (pane, _window, actions) = shown(); - let row = find_row(&list(&pane), 2).expect("second row"); - let button = row - .last_child() - .and_downcast::() - .expect("row menu button"); - assert_eq!(crate::test_support::assert_labelled(&button), Ok(())); - assert_eq!(button.tooltip_text().as_deref(), Some("Options for “Two”")); - button.popup(); - assert!(button.popover().expect("row popover").is_visible()); - let menu = button.menu_model().expect("row menu"); - assert_eq!(menu.n_items(), 2); - crate::test_support::assert_access_keys(&menu); - let action = menu - .item_attribute_value(0, "action", None) - .and_then(|value| value.get::()) - .expect("rename action"); - button - .activate_action(&action, Some(&target(&menu, 0))) - .expect("rename from menu"); - assert_eq!(requested(&actions), [("rename", 2, "Two".to_owned())]); - } - - #[gtk4::test] - fn favorite_shortcuts_use_selection_and_ignore_modifiers() { - use gtk::gdk::{Key, ModifierType}; - let (pane, _window, actions) = shown(); - pane.selection.set_selected(1); - for modifier in [ - ModifierType::SHIFT_MASK, - ModifierType::CONTROL_MASK, - ModifierType::ALT_MASK, - ModifierType::SUPER_MASK, - ] { - for key in [Key::F2, Key::Delete, Key::KP_Delete] { - assert!(!press(&pane, key, modifier)); - } + fn observe(self: &Rc, tree: >k::TreeListModel) { + if self.updating.replace(true) { + return; } - assert!(actions.borrow().is_empty()); - assert!(press(&pane, Key::F2, ModifierType::empty())); - assert!(press(&pane, Key::Delete, ModifierType::empty())); - assert!(press(&pane, Key::KP_Delete, ModifierType::empty())); - assert_eq!( - requested(&actions), - [ - ("rename", 2, "Two".to_owned()), - ("delete", 2, "Two".to_owned()), - ("delete", 2, "Two".to_owned()), - ] - ); - pane.selection.set_selected(gtk::INVALID_LIST_POSITION); - assert!(!press(&pane, Key::F2, ModifierType::empty())); - } - - #[gtk4::test] - fn the_keyboard_opens_the_selected_favorites_context_menu() { - use gtk::gdk::{Key, ModifierType}; - let (pane, _window, actions) = shown(); - pane.selection.set_selected(1); - for (key, modifiers) in [(Key::F10, ModifierType::SHIFT_MASK), (Key::Menu, ModifierType::empty())] { - assert!(press(&pane, key, modifiers)); - assert!(pane.menu.is_visible()); - let model = pane.menu.menu_model().expect("context menu"); - let target = target(&model, 1); - assert_eq!(target.get::(), Some(2)); - pane.menu.popdown(); + let mut position = 0; + while position < tree.n_items() { + let Some(row) = tree.row(position) else { + break; + }; + position += 1; + let Some(Key::Folder(id)) = key_of(&row) else { + continue; + }; + if self.watched.borrow().get(&id).is_some_and(|(held, _)| held == &row) { + continue; + } + if let Some((old, watch)) = self.watched.borrow_mut().remove(&id) { + old.disconnect(watch); + } + let weak = Rc::downgrade(self); + let watch = row.connect_expanded_notify(move |row| { + // Collapsing an ancestor detaches its rows and emits false without changing the user's choice. + if !row.is_expandable() { + return; + } + let Some(state) = weak.upgrade().filter(|state| !state.updating.get()) else { + return; + }; + if row.is_expanded() { + state.expanded.borrow_mut().insert(id); + } else { + state.expanded.borrow_mut().remove(&id); + } + }); + let expanded = self.expanded.borrow().contains(&id); + self.watched.borrow_mut().insert(id, (row.clone(), watch)); + row.set_expanded(expanded); } - assert!(actions.borrow().is_empty()); - assert!(!press( - &pane, - Key::F10, - ModifierType::CONTROL_MASK | ModifierType::SHIFT_MASK - )); - } - - #[gtk4::test] - fn a_secondary_click_targets_the_clicked_favorite() { - let (pane, _window, actions) = shown(); - let list = list(&pane); - pane.selection.set_selected(0); - let row = find_row(&list, 2).expect("second row"); - let bounds = row.compute_bounds(&list).expect("row bounds"); - let controllers = list.observe_controllers(); - let click = (0..controllers.n_items()) - .filter_map(|position| controllers.item(position).and_downcast::()) - .find(|click| click.button() == gtk::gdk::BUTTON_SECONDARY) - .expect("secondary click"); - click.emit_by_name::<()>( - "pressed", - &[&1i32, &f64::from(bounds.x() + 4.0), &f64::from(bounds.y() + 4.0)], - ); - assert!(pane.menu.is_visible()); - let model = pane.menu.menu_model().expect("context menu"); - list.activate_action("favorite.delete", Some(&target(&model, 1))) - .expect("delete"); - assert_eq!(requested(&actions), [("delete", 2, "Two".to_owned())]); + self.updating.set(false); } +} - #[gtk4::test] - fn reordered_menu_targets_keep_their_id_and_removed_targets_do_nothing() { - let (pane, _window, actions) = shown(); - let list = list(&pane); - let previous = target(&menu_of(2), 0); - pane.selection.set_selected(1); - pane.show(vec![saved(2, "Renamed"), saved(1, "One")]); - list.activate_action("favorite.rename", Some(&previous)) - .expect("old action routed"); - assert_eq!(requested(&actions), [("rename", 2, "Renamed".to_owned())]); - assert!(press(&pane, gtk::gdk::Key::F2, gtk::gdk::ModifierType::empty())); - assert_eq!( - requested(&actions), - [("rename", 2, "Renamed".to_owned()), ("rename", 2, "Renamed".to_owned()),] - ); - let before_switch = target(&menu_of(2), 1); - pane.clear(); - list.activate_action("favorite.delete", Some(&before_switch)) - .expect("stale target routed"); - assert_eq!(actions.borrow().len(), 2); - pane.show(vec![saved(3, "Different connection")]); - list.activate_action("favorite.delete", Some(&before_switch)) - .expect("stale target routed"); - assert_eq!(actions.borrow().len(), 2); - let current = target(&menu_of(3), 1); - pane.show(vec![]); - list.activate_action("favorite.delete", Some(¤t)) - .expect("removed target routed"); - assert_eq!(actions.borrow().len(), 2); +impl Drop for Expansion { + fn drop(&mut self) { + self.reset_rows(); } } diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs new file mode 100644 index 0000000000..69018fff0c --- /dev/null +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs @@ -0,0 +1,408 @@ +use super::rows::{find_row, menu_of}; +use super::*; +use std::time::SystemTime; +use uuid::Uuid; + +fn saved(id: i64, name: &str) -> SavedQuery { + SavedQuery { + id, + name: name.to_owned(), + query: "SELECT 1".to_owned(), + connection_id: Uuid::nil(), + connection_name: "Database".to_owned(), + keyword: None, + folder_id: None, + order: 0, + created_at: SystemTime::UNIX_EPOCH, + updated_at: SystemTime::UNIX_EPOCH, + } +} + +#[gtk4::test] +fn favorites_keep_selection_by_id_after_rename_and_reorder() { + let pane = FavoritesPane::new(|_| {}, || {}); + show(&pane, vec![saved(1, "One"), saved(2, "Two")]); + pane.selection.set_selected(1); + show(&pane, vec![saved(2, "Renamed"), saved(1, "One")]); + assert_eq!(pane.selection.selected(), 0); + show(&pane, vec![saved(1, "One")]); + assert_eq!(pane.selection.selected(), gtk::INVALID_LIST_POSITION); +} + +#[gtk4::test] +fn favorites_distinguish_loading_empty_unavailable_and_failed_refresh() { + let retried = Rc::new(std::cell::Cell::new(false)); + let retry = retried.clone(); + let pane = FavoritesPane::new(|_| {}, move || retry.set(true)); + pane.loading(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("loading")); + pane.failed(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("error")); + pane.retry.emit_clicked(); + assert!(retried.get()); + show(&pane, vec![]); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some(EMPTY)); + show(&pane, vec![saved(1, "One")]); + pane.failed(); + assert!(pane.stale.is_revealed()); + assert_eq!(pane.names(), ["One"]); + pane.unavailable(); + assert!(!pane.retry.is_visible()); + assert!(pane.names().is_empty()); + pane.no_connection(); + assert_eq!(pane.stack.visible_child_name().as_deref(), Some("disconnected")); +} + +type Actions = Rc>>; +const WAIT: std::time::Duration = std::time::Duration::from_secs(30); + +fn shown() -> (FavoritesPane, crate::test_support::OwnedWindow, Actions) { + adw::init().expect("libadwaita"); + let actions = Actions::default(); + let sink = actions.clone(); + let pane = FavoritesPane::new(move |action| sink.borrow_mut().push(action), || {}); + show(&pane, vec![saved(1, "One"), saved(2, "Two")]); + let window = gtk::Window::builder() + .default_width(360) + .default_height(360) + .child(&pane.widget()) + .build(); + let window = crate::test_support::OwnedWindow::presented(window); + crate::test_support::wait_until(WAIT, || { + find_row(&list(&pane), Key::Query(2)).is_some_and(|row| row.height() > 0) + }) + .expect("rows laid out"); + (pane, window, actions) +} + +fn list(pane: &FavoritesPane) -> gtk::ListView { + pane.menu + .parent() + .and_downcast::() + .expect("menu belongs to list") +} + +fn press(pane: &FavoritesPane, key: gtk::gdk::Key, modifiers: gtk::gdk::ModifierType) -> bool { + let controllers = list(pane).observe_controllers(); + let keys = (0..controllers.n_items()) + .filter_map(|position| controllers.item(position).and_downcast::()) + .find(|keys| keys.name().as_deref() == Some(KEYS)) + .expect("favorite key handler"); + keys.emit_by_name::("key-pressed", &[&key, &0u32, &modifiers]) +} + +fn target(menu: &impl IsA, position: i32) -> glib::Variant { + menu.as_ref() + .item_attribute_value(position, "target", None) + .expect("menu target") +} + +fn requested(actions: &Actions) -> Vec<(&'static str, i64, String)> { + actions + .borrow() + .iter() + .filter_map(|action| match action { + FavoriteAction::Rename(saved) => Some(("rename", saved.id, saved.name.clone())), + FavoriteAction::Delete(saved) => Some(("delete", saved.id, saved.name.clone())), + _ => None, + }) + .collect() +} + +#[gtk4::test] +fn a_favorite_has_a_named_menu_button_that_acts_on_its_row() { + let (pane, _window, actions) = shown(); + let row = find_row(&list(&pane), Key::Query(2)).expect("second row"); + let button = row + .last_child() + .and_downcast::() + .expect("row menu button"); + assert_eq!(crate::test_support::assert_labelled(&button), Ok(())); + assert_eq!(button.tooltip_text().as_deref(), Some("Options for “Two”")); + button.popup(); + assert!(button.popover().expect("row popover").is_visible()); + let menu = button.menu_model().expect("row menu"); + assert_eq!(menu.n_items(), 3); + crate::test_support::assert_access_keys(&menu); + let action = menu + .item_attribute_value(0, "action", None) + .and_then(|value| value.get::()) + .expect("rename action"); + button + .activate_action(&action, Some(&target(&menu, 0))) + .expect("rename from menu"); + assert_eq!(requested(&actions), [("rename", 2, "Two".to_owned())]); +} + +#[gtk4::test] +fn favorite_shortcuts_use_selection_and_ignore_modifiers() { + use gtk::gdk::{Key, ModifierType}; + let (pane, _window, actions) = shown(); + pane.selection.set_selected(1); + for modifier in [ + ModifierType::SHIFT_MASK, + ModifierType::CONTROL_MASK, + ModifierType::ALT_MASK, + ModifierType::SUPER_MASK, + ] { + for key in [Key::F2, Key::Delete, Key::KP_Delete] { + assert!(!press(&pane, key, modifier)); + } + } + assert!(actions.borrow().is_empty()); + assert!(press(&pane, Key::F2, ModifierType::empty())); + assert!(press(&pane, Key::Delete, ModifierType::empty())); + assert!(press(&pane, Key::KP_Delete, ModifierType::empty())); + assert_eq!( + requested(&actions), + [ + ("rename", 2, "Two".to_owned()), + ("delete", 2, "Two".to_owned()), + ("delete", 2, "Two".to_owned()), + ] + ); + pane.selection.set_selected(gtk::INVALID_LIST_POSITION); + assert!(!press(&pane, Key::F2, ModifierType::empty())); +} + +#[gtk4::test] +fn the_keyboard_opens_the_selected_favorites_context_menu() { + use gtk::gdk::{Key, ModifierType}; + let (pane, _window, actions) = shown(); + pane.selection.set_selected(1); + for (key, modifiers) in [(Key::F10, ModifierType::SHIFT_MASK), (Key::Menu, ModifierType::empty())] { + assert!(press(&pane, key, modifiers)); + assert!(pane.menu.is_visible()); + let model = pane.menu.menu_model().expect("context menu"); + let target = target(&model, 2); + assert_eq!(target.get::().as_deref(), Some("q2")); + pane.menu.popdown(); + } + assert!(actions.borrow().is_empty()); + assert!(!press( + &pane, + Key::F10, + ModifierType::CONTROL_MASK | ModifierType::SHIFT_MASK + )); +} + +#[gtk4::test] +fn a_secondary_click_targets_the_clicked_favorite() { + let (pane, _window, actions) = shown(); + let list = list(&pane); + pane.selection.set_selected(0); + let row = find_row(&list, Key::Query(2)).expect("second row"); + let bounds = row.compute_bounds(&list).expect("row bounds"); + let controllers = list.observe_controllers(); + let click = (0..controllers.n_items()) + .filter_map(|position| controllers.item(position).and_downcast::()) + .find(|click| click.button() == gtk::gdk::BUTTON_SECONDARY) + .expect("secondary click"); + click.emit_by_name::<()>( + "pressed", + &[&1i32, &f64::from(bounds.x() + 4.0), &f64::from(bounds.y() + 4.0)], + ); + assert!(pane.menu.is_visible()); + let model = pane.menu.menu_model().expect("context menu"); + list.activate_action("favorite.delete", Some(&target(&model, 2))) + .expect("delete"); + assert_eq!(requested(&actions), [("delete", 2, "Two".to_owned())]); +} + +#[gtk4::test] +fn reordered_menu_targets_keep_their_id_and_removed_targets_do_nothing() { + let (pane, _window, actions) = shown(); + let list = list(&pane); + let previous = target(&menu_of(Key::Query(2)), 0); + pane.selection.set_selected(1); + show(&pane, vec![saved(2, "Renamed"), saved(1, "One")]); + list.activate_action("favorite.rename", Some(&previous)) + .expect("old action routed"); + assert_eq!(requested(&actions), [("rename", 2, "Renamed".to_owned())]); + assert!(press(&pane, gtk::gdk::Key::F2, gtk::gdk::ModifierType::empty())); + assert_eq!( + requested(&actions), + [("rename", 2, "Renamed".to_owned()), ("rename", 2, "Renamed".to_owned()),] + ); + let before_switch = target(&menu_of(Key::Query(2)), 2); + pane.clear(); + list.activate_action("favorite.delete", Some(&before_switch)) + .expect("stale target routed"); + assert_eq!(actions.borrow().len(), 2); + show(&pane, vec![saved(3, "Different connection")]); + list.activate_action("favorite.delete", Some(&before_switch)) + .expect("stale target routed"); + assert_eq!(actions.borrow().len(), 2); + let current = target(&menu_of(Key::Query(3)), 2); + show(&pane, vec![]); + list.activate_action("favorite.delete", Some(¤t)) + .expect("removed target routed"); + assert_eq!(actions.borrow().len(), 2); +} + +fn show(pane: &FavoritesPane, mut queries: Vec) { + for (order, query) in queries.iter_mut().enumerate() { + query.order = order as i64; + } + pane.show(SavedQueriesSnapshot { + queries, + folders: vec![], + }); +} + +fn folder(id: i64, name: &str, parent_id: Option) -> SavedQueryFolder { + SavedQueryFolder { + id, + name: name.to_owned(), + parent_id, + connection_id: Uuid::nil(), + order: id, + created_at: SystemTime::UNIX_EPOCH, + updated_at: SystemTime::UNIX_EPOCH, + } +} + +fn nested_snapshot(name: &str) -> SavedQueriesSnapshot { + let mut query = saved(1, name); + query.folder_id = Some(3); + SavedQueriesSnapshot { + queries: vec![query], + folders: vec![ + folder(1, "Parent", None), + folder(2, "Child", Some(1)), + folder(3, "Nested", Some(2)), + ], + } +} + +fn tree_row(pane: &FavoritesPane, key: Key) -> gtk::TreeListRow { + pane.tree + .row(position_of(&pane.tree, key).expect("visible key")) + .expect("row") +} + +#[gtk4::test] +fn nested_expansion_and_selected_identity_survive_refresh_and_collapsed_ancestors() { + let pane = FavoritesPane::new(|_| {}, || {}); + pane.show(nested_snapshot("Before")); + assert_eq!(pane.tree.n_items(), 1); + tree_row(&pane, Key::Folder(1)).set_expanded(true); + tree_row(&pane, Key::Folder(2)).set_expanded(true); + tree_row(&pane, Key::Folder(3)).set_expanded(true); + pane.selection + .set_selected(position_of(&pane.tree, Key::Query(1)).expect("query")); + pane.show(nested_snapshot("After")); + assert_eq!(pane.tree.n_items(), 4); + assert_eq!( + pane.tree.row(pane.selection.selected()).as_ref().and_then(key_of), + Some(Key::Query(1)) + ); + assert_eq!(pane.names(), ["After"]); + tree_row(&pane, Key::Folder(1)).set_expanded(false); + pane.show(nested_snapshot("After again")); + assert_eq!(pane.tree.n_items(), 1); + tree_row(&pane, Key::Folder(1)).set_expanded(true); + assert!(tree_row(&pane, Key::Folder(2)).is_expanded()); + assert!(tree_row(&pane, Key::Folder(3)).is_expanded()); + assert_eq!(pane.tree.n_items(), 4); + pane.clear(); + pane.show(nested_snapshot("Different connection")); + assert_eq!(pane.tree.n_items(), 1); + assert_eq!(pane.selection.selected(), gtk::INVALID_LIST_POSITION); +} + +#[gtk4::test] +fn new_folder_requires_a_successful_read_and_an_invalid_graph_keeps_the_last_good_rows() { + let actions = Actions::default(); + let sink = actions.clone(); + let pane = FavoritesPane::new(move |action| sink.borrow_mut().push(action), || {}); + assert!(!pane.new_folder.is_sensitive()); + show(&pane, vec![]); + assert!(pane.new_folder.is_sensitive()); + pane.new_folder.emit_clicked(); + assert!(matches!(actions.borrow().as_slice(), [FavoriteAction::NewFolder(None)])); + pane.loading(); + assert!(!pane.new_folder.is_sensitive()); + pane.failed(); + assert!(!pane.new_folder.is_sensitive()); + pane.show(nested_snapshot("Kept")); + assert!(pane.new_folder.is_sensitive()); + let mut invalid = nested_snapshot("Lost"); + invalid.folders.clear(); + pane.show(invalid); + assert_eq!(pane.names(), ["Kept"]); + assert!(pane.stale.is_revealed()); + assert!(!pane.new_folder.is_sensitive()); + pane.no_connection(); + assert!(!pane.new_folder.is_sensitive()); +} + +#[gtk4::test] +fn folder_and_query_menus_use_distinct_ids_and_hidden_targets_do_nothing() { + let (pane, _window, actions) = shown(); + pane.show(nested_snapshot("Query")); + pane.selection.set_selected(0); + assert!(press(&pane, gtk::gdk::Key::F2, gtk::gdk::ModifierType::empty())); + assert!(matches!(actions.borrow().last(), Some(FavoriteAction::RenameFolder(folder)) if folder.id == 1)); + let list = list(&pane); + let menu = menu_of(Key::Folder(1)); + crate::test_support::assert_access_keys(&menu); + list.activate_action("favorite.new-folder", Some(&target(&menu, 0))) + .expect("new subfolder"); + assert!(matches!(actions.borrow().last(), Some(FavoriteAction::NewFolder(Some(folder))) if folder.id == 1)); + list.activate_action("favorite.delete", Some(&target(&menu, 2))) + .expect("delete folder"); + assert!(matches!(actions.borrow().last(), Some(FavoriteAction::DeleteFolder(folder)) if folder.id == 1)); + let query_menu = menu_of(Key::Query(1)); + let before = actions.borrow().len(); + list.activate_action("favorite.move", Some(&target(&query_menu, 1))) + .expect("hidden action routed"); + assert_eq!(actions.borrow().len(), before); + for id in [1, 2, 3] { + tree_row(&pane, Key::Folder(id)).set_expanded(true); + } + list.activate_action("favorite.move", Some(&target(&query_menu, 1))) + .expect("move query"); + assert!(matches!(actions.borrow().last(), Some(FavoriteAction::MoveTo(query)) if query.id == 1)); + crate::test_support::wait_until(WAIT, || { + find_row(&list, Key::Folder(1)).is_some_and(|row| row.height() > 0) + }) + .expect("folder visible"); + let row = find_row(&list, Key::Folder(1)).expect("folder row"); + let expander = row + .parent() + .and_downcast::() + .expect("native expander"); + assert_eq!(crate::test_support::assert_labelled(&expander), Ok(())); + let button = row + .last_child() + .and_downcast::() + .expect("folder menu button"); + assert_eq!(crate::test_support::assert_labelled(&button), Ok(())); +} + +#[gtk4::test] +fn reopening_an_expanded_subtree_keeps_a_selected_root_siblings_position() { + let pane = FavoritesPane::new(|_| {}, || {}); + let mut snapshot = nested_snapshot("Filed query"); + snapshot.queries.push(saved(2, "Root query")); + pane.show(snapshot); + tree_row(&pane, Key::Folder(1)).set_expanded(true); + tree_row(&pane, Key::Folder(2)).set_expanded(true); + let selected = Key::Query(2); + pane.selection + .set_selected(position_of(&pane.tree, selected).expect("root query")); + tree_row(&pane, Key::Folder(1)).set_expanded(false); + assert_eq!(pane.selection.selected(), 1); + tree_row(&pane, Key::Folder(1)).set_expanded(true); + assert!(tree_row(&pane, Key::Folder(2)).is_expanded()); + assert_eq!( + pane.selection.selected(), + position_of(&pane.tree, selected).expect("selected query") + ); + assert_eq!(pane.selection.selected(), 3); + assert_eq!( + pane.tree.row(pane.selection.selected()).as_ref().and_then(key_of), + Some(selected) + ); +} diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_rows.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_rows.rs new file mode 100644 index 0000000000..bd4701c540 --- /dev/null +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_rows.rs @@ -0,0 +1,340 @@ +use super::*; +use crate::i18n::gettext_f; + +pub(super) fn factory(index: SharedIndex) -> gtk::SignalListItemFactory { + let factory = gtk::SignalListItemFactory::new(); + factory.connect_setup(|_, item| setup(item)); + factory.connect_bind(move |_, item| bind(item, &index)); + factory.connect_unbind(|_, item| unbind(item)); + factory +} + +fn setup(item: &glib::Object) { + let Some(item) = item.downcast_ref::() else { + return; + }; + item.set_focusable(false); + let name = gtk::Label::builder() + .xalign(0.0) + .ellipsize(gtk::pango::EllipsizeMode::End) + .build(); + let summary = gtk::Label::builder() + .xalign(0.0) + .ellipsize(gtk::pango::EllipsizeMode::End) + .build(); + summary.add_css_class("caption"); + summary.add_css_class("dimmed"); + let labels = gtk::Box::builder() + .orientation(gtk::Orientation::Vertical) + .spacing(2) + .hexpand(true) + .valign(gtk::Align::Center) + .build(); + labels.append(&name); + labels.append(&summary); + let menu = gtk::MenuButton::builder() + .icon_name("view-more-symbolic") + .valign(gtk::Align::Center) + .build(); + menu.add_css_class("flat"); + let row = gtk::Box::builder().spacing(6).margin_top(6).margin_bottom(6).build(); + row.add_css_class(ROW); + row.append(>k::Image::from_icon_name("folder-symbolic")); + row.append(&labels); + row.append(&menu); + let expander = gtk::TreeExpander::new(); + expander.set_indent_for_icon(true); + expander.set_child(Some(&row)); + follow_expansion(&expander); + item.set_child(Some(&expander)); +} + +fn bind(item: &glib::Object, index: &SharedIndex) { + let Some(item) = item.downcast_ref::() else { + return; + }; + let (Some(tree_row), Some(expander)) = ( + item.item().and_downcast::(), + item.child().and_downcast::(), + ) else { + return; + }; + let index = index.borrow(); + let Some(node) = key_of(&tree_row).and_then(|key| index.nodes.get(&key)) else { + return; + }; + expander.set_list_row(Some(&tree_row)); + expander.set_hide_expander(matches!(node, Node::Folder(folder) if index.children(Some(folder.id)).is_empty())); + let Some(row) = expander.child() else { + return; + }; + row.set_widget_name(&node.key().target()); + if let Some(icon) = row.first_child().and_downcast::() { + icon.set_icon_name(Some(match node { + Node::Folder(_) => "folder-symbolic", + Node::Query(_) => "text-x-generic-symbolic", + })); + } + if let Some(labels) = row.first_child().and_then(|icon| icon.next_sibling()) { + if let Some(name) = labels.first_child().and_downcast::() { + name.set_label(node.name()); + } + if let Some(summary) = labels.last_child().and_downcast::() { + let text = match node { + Node::Folder(_) => "", + Node::Query(query) => query.summary(), + }; + summary.set_label(text); + summary.set_visible(!text.is_empty()); + } + } + if let Some(menu) = row.last_child().and_downcast::() { + let label = gettext_f("Options for “{name}”", &[("name", node.name())]); + menu.set_tooltip_text(Some(&label)); + menu.update_property(&[gtk::accessible::Property::Label(&label)]); + menu.set_menu_model(Some(&menu_of(node.key()))); + } + let label = accessible_label(node, &index); + item.set_accessible_label(&label); + expander.update_property(&[gtk::accessible::Property::Label(&label)]); +} + +fn unbind(item: &glib::Object) { + let Some(expander) = item + .downcast_ref::() + .and_then(|item| item.child()) + .and_downcast::() + else { + return; + }; + if let Some(row) = expander.child() { + row.set_widget_name(""); + if let Some(menu) = row.last_child().and_downcast::() { + menu.popdown(); + menu.set_menu_model(None::<&gio::MenuModel>); + } + } + expander.set_list_row(None); + expander.update_property(&[gtk::accessible::Property::Label("")]); +} + +fn accessible_label(node: &Node, index: &Index) -> String { + let label = match node { + Node::Folder(_) => gettext_f("Folder “{name}”", &[("name", node.name())]), + Node::Query(_) => gettext_f("Saved query “{name}”", &[("name", node.name())]), + }; + match node.parent().and_then(|parent| index.path(parent)) { + Some(path) => gettext_f("{item} in {folder}", &[("item", &label), ("folder", path)]), + None => label, + } +} + +fn follow_expansion(expander: >k::TreeExpander) { + // GTK updates the arrow's expanded state; the row's accessible node needs it too. + let watched: Rc>> = Rc::default(); + expander.connect_list_row_notify({ + let watched = watched.clone(); + move |expander| { + if let Some((row, watch)) = watched.take() { + row.disconnect(watch); + } + let Some(row) = expander.list_row().filter(|row| row.is_expandable()) else { + expander.update_state(&[gtk::accessible::State::Expanded(None)]); + return; + }; + expander.update_state(&[gtk::accessible::State::Expanded(Some(row.is_expanded()))]); + let weak = expander.downgrade(); + let watch = row.connect_expanded_notify(move |row| { + if let Some(expander) = weak.upgrade() { + expander.update_state(&[gtk::accessible::State::Expanded(Some(row.is_expanded()))]); + } + }); + watched.replace(Some((row, watch))); + } + }); + expander.connect_destroy(move |_| { + if let Some((row, watch)) = watched.take() { + row.disconnect(watch); + } + }); +} + +pub(super) fn install_menu( + list: >k::ListView, + tree: >k::TreeListModel, + index: &SharedIndex, + selection: >k::SingleSelection, + asked: &Asked, +) -> gtk::PopoverMenu { + let actions = gio::SimpleActionGroup::new(); + for name in [RENAME, DELETE, MOVE, NEW_FOLDER] { + let action = gio::SimpleAction::new(name, Some(glib::VariantTy::STRING)); + let (tree, index, asked) = (tree.clone(), index.clone(), asked.clone()); + action.connect_activate(move |_, target| { + let Some(key) = target + .and_then(|target| target.get::()) + .as_deref() + .and_then(Key::parse) + else { + return; + }; + if position_of(&tree, key).is_none() { + return; + } + if let Some(node) = index.borrow().nodes.get(&key).cloned() { + request(&asked, name, node); + } + }); + actions.add_action(&action); + } + list.insert_action_group("favorite", Some(&actions)); + let menu = gtk::PopoverMenu::from_model(None::<&gio::MenuModel>); + menu.set_has_arrow(false); + menu.set_parent(list); + let click = gtk::GestureClick::builder().button(gtk::gdk::BUTTON_SECONDARY).build(); + click.connect_pressed({ + let (list, index, menu) = (list.downgrade(), index.clone(), menu.clone()); + move |gesture, _, x, y| { + let Some(list) = list.upgrade() else { + return; + }; + let Some(key) = row_at(&list, &index, x, y) else { + return; + }; + gesture.set_state(gtk::EventSequenceState::Claimed); + menu.set_menu_model(Some(&menu_of(key))); + menu.set_pointing_to(Some(>k::gdk::Rectangle::new(x as i32, y as i32, 1, 1))); + menu.popup(); + } + }); + list.add_controller(click); + // A manually parented popover must leave before its parent is finalized. + list.connect_destroy({ + let menu = menu.clone(); + move |_| menu.unparent() + }); + install_keys(list, tree, index, selection, asked, &menu); + menu +} + +fn request(asked: &Asked, name: &str, node: Node) { + let action = match (name, node) { + (RENAME, Node::Query(query)) => FavoriteAction::Rename(query), + (DELETE, Node::Query(query)) => FavoriteAction::Delete(query), + (MOVE, Node::Query(query)) => FavoriteAction::MoveTo(query), + (RENAME, Node::Folder(folder)) => FavoriteAction::RenameFolder(folder), + (DELETE, Node::Folder(folder)) => FavoriteAction::DeleteFolder(folder), + (NEW_FOLDER, Node::Folder(folder)) => FavoriteAction::NewFolder(Some(folder)), + _ => return, + }; + asked(action); +} + +fn install_keys( + list: >k::ListView, + tree: >k::TreeListModel, + index: &SharedIndex, + selection: >k::SingleSelection, + asked: &Asked, + menu: >k::PopoverMenu, +) { + let keys = gtk::EventControllerKey::new(); + keys.set_name(Some(KEYS)); + let (selection, tree, index, asked, menu, list_weak) = ( + selection.clone(), + tree.clone(), + index.clone(), + asked.clone(), + menu.clone(), + list.downgrade(), + ); + keys.connect_key_pressed(move |_, key, _, modifiers| { + let modifiers = modifiers.intersection(gtk::accelerator_get_default_mod_mask()); + let Some(row_key) = tree.row(selection.selected()).as_ref().and_then(key_of) else { + return glib::Propagation::Proceed; + }; + let Some(node) = index.borrow().nodes.get(&row_key).cloned() else { + return glib::Propagation::Proceed; + }; + if (key == gtk::gdk::Key::Menu && modifiers.is_empty()) + || (key == gtk::gdk::Key::F10 && modifiers == gtk::gdk::ModifierType::SHIFT_MASK) + { + let Some(list) = list_weak.upgrade() else { + return glib::Propagation::Proceed; + }; + let anchor = find_row(&list, row_key) + .and_then(|row| row.compute_bounds(&list)) + .map(|bounds| { + gtk::gdk::Rectangle::new( + bounds.x() as i32, + bounds.y() as i32, + bounds.width() as i32, + bounds.height() as i32, + ) + }); + menu.set_menu_model(Some(&menu_of(row_key))); + menu.set_pointing_to(anchor.as_ref()); + menu.popup(); + return glib::Propagation::Stop; + } + if !modifiers.is_empty() { + return glib::Propagation::Proceed; + } + match key { + gtk::gdk::Key::F2 => request(&asked, RENAME, node), + gtk::gdk::Key::Delete | gtk::gdk::Key::KP_Delete => request(&asked, DELETE, node), + _ => return glib::Propagation::Proceed, + } + glib::Propagation::Stop + }); + list.add_controller(keys); +} + +pub(super) fn menu_of(key: Key) -> gio::Menu { + let menu = gio::Menu::new(); + let entries = match key { + Key::Query(_) => [ + (gettext("_Rename…"), RENAME), + (gettext("_Move to Folder…"), MOVE), + (gettext("_Delete…"), DELETE), + ], + Key::Folder(_) => [ + (gettext("New _Subfolder…"), NEW_FOLDER), + (gettext("_Rename…"), RENAME), + (gettext("_Delete…"), DELETE), + ], + }; + for (label, action) in entries { + let item = gio::MenuItem::new(Some(&label), None); + item.set_action_and_target_value(Some(&format!("favorite.{action}")), Some(&key.target().to_variant())); + menu.append_item(&item); + } + menu +} + +fn row_at(list: >k::ListView, index: &SharedIndex, x: f64, y: f64) -> Option { + let mut widget = list.pick(x, y, gtk::PickFlags::DEFAULT); + while let Some(candidate) = widget { + if candidate.has_css_class(ROW) { + let key = Key::parse(&candidate.widget_name())?; + return index.borrow().nodes.contains_key(&key).then_some(key); + } + widget = candidate.parent(); + } + None +} + +pub(super) fn find_row(widget: &impl IsA, key: Key) -> Option { + let widget = widget.as_ref(); + if widget.has_css_class(ROW) && widget.widget_name() == key.target() { + return Some(widget.clone()); + } + let mut child = widget.first_child(); + while let Some(current) = child { + if let Some(row) = find_row(¤t, key) { + return Some(row); + } + child = current.next_sibling(); + } + None +} diff --git a/linux/crates/app/src/ui/workspace/status_pages.rs b/linux/crates/app/src/ui/workspace/status_pages.rs index 54726a264f..3a154c6688 100644 --- a/linux/crates/app/src/ui/workspace/status_pages.rs +++ b/linux/crates/app/src/ui/workspace/status_pages.rs @@ -381,6 +381,48 @@ mod tests { wait_until(WAIT, || favorites.names().is_empty()).expect("the favorite to go"); } + #[gtk4::test] + fn favorites_are_filed_in_folders_and_a_deleted_folder_leaves_its_queries() { + use gtk4::subclass::prelude::ObjectSubclassIsExt; + + let test = TestWindow::connected("FavoritesFolders"); + let availability = test.services.history().availability(); + wait_until(WAIT, || availability.borrow().is_ready()).expect("the query database to open"); + let shell = test.window.shell().expect("the shell"); + let favorites = shell.imp().favorites.get().cloned().expect("the favorites pane"); + shell.imp().scope_toggle.set_active_name(Some("favorites")); + test.workspace() + .with_model(|model| model.on_save_query_named("Orders".to_owned(), "SELECT 1".to_owned())); + wait_until(WAIT, || favorites.names() == ["Orders"]).expect("the saved query to be listed"); + + shell.create_folder("Reports".to_owned(), None); + wait_until(WAIT, || favorites.folder_destinations().len() == 1).expect("the folder to be listed"); + let folder = favorites.folder_destinations()[0].0; + let store = test.services.history().store().expect("history").saved_query_folders(); + let owner = test.workspace().connection_id().expect("connection"); + let work = test + .services + .tasks + .spawn_task(async move { store.create(owner, "Monthly", Some(folder)).await }); + let child = finish_on_main(WAIT, work) + .expect("created") + .expect("task") + .expect("folder"); + wait_until(WAIT, || favorites.folder_destinations().len() == 2).expect("external folder listed"); + assert!( + favorites + .folder_destinations() + .contains(&(child, "/Reports/Monthly".to_owned())) + ); + shell.move_favorite(favorites.ids()[0], Some(child)); + wait_until(WAIT, || favorites.folder_of_first_query() == Some(child)).expect("the query filed in it"); + + shell.delete_folder(folder); + wait_until(WAIT, || favorites.folder_destinations().is_empty()).expect("the folder to go"); + assert_eq!(favorites.names(), ["Orders"], "the query went with its folder"); + assert_eq!(favorites.folder_of_first_query(), None); + } + #[gtk4::test] fn a_history_dialog_closed_by_hand_is_not_closed_again_on_disconnect() { use gtk4::glib; diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 0ae70b528f..ad4a0f2b3b 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -11,8 +11,8 @@ use gtk4::subclass::prelude::*; use libadwaita as adw; use libadwaita::prelude::{AdwDialogExt, AlertDialogExt, BinExt, PreferencesGroupExt}; use tablepro_core::DataModel; -use tablepro_storage::SavedQueries; use tablepro_storage::saved_queries::SavedQuery; +use tablepro_storage::{QueryHistory, SavedQueriesSnapshot}; use uuid::Uuid; use super::health_banner::REVIEW_HOST_KEY; @@ -37,7 +37,7 @@ const FAVORITES: &str = "favorites"; pub(super) const SHOW_ASSISTANT: &str = "show-assistant"; type FavoritesRead = Result< - Option, tablepro_storage::StorageError>>, + Option>, tablepro_session::runtime::TaskFailure, >; @@ -658,7 +658,7 @@ impl WorkspaceShell { tasks, async move { let history = ready.await?; - Some(history.saved_queries().list(Some(connection)).await) + Some(history.saved_queries().snapshot(connection).await) }, glib::clone!( #[weak(rename_to = shell)] @@ -697,6 +697,10 @@ impl WorkspaceShell { } FavoriteAction::Rename(favorite) => self.ask_favorite_name(favorite), FavoriteAction::Delete(favorite) => self.ask_favorite_deletion(favorite), + FavoriteAction::MoveTo(favorite) => self.ask_folder_for(favorite), + FavoriteAction::NewFolder(parent) => self.ask_folder_name(parent, None), + FavoriteAction::RenameFolder(folder) => self.ask_folder_name(None, Some(folder)), + FavoriteAction::DeleteFolder(folder) => self.ask_folder_deletion(folder), } } @@ -751,21 +755,32 @@ impl WorkspaceShell { pub(crate) fn rename_favorite(&self, id: i64, name: String) { self.change_favorites( - async move |store| store.rename(id, &name).await, + async move |history| history.saved_queries().rename(id, &name).await, gettext("Could not rename that saved query."), ); } pub(crate) fn delete_favorite(&self, id: i64) { self.change_favorites( - async move |store| store.delete(id).await, + async move |history| history.saved_queries().delete(id).await, gettext("Could not delete that saved query."), ); } - fn change_favorites(&self, change: impl FnOnce(SavedQueries) -> W + Send + 'static, failure: String) + pub(super) fn change_favorites(&self, change: impl FnOnce(QueryHistory) -> W + Send + 'static, failure: String) where W: std::future::Future> + Send + 'static, + { + self.change_favorites_with(change, failure, favorite_failure_text); + } + + pub(super) fn change_favorites_with( + &self, + change: impl FnOnce(QueryHistory) -> W + Send + 'static, + failure: String, + describe: fn(&tablepro_storage::StorageError, &str) -> String, + ) where + W: std::future::Future> + Send + 'static, { let imp = self.imp(); let Some((history, tasks)) = imp.favorites_source.get() else { @@ -778,7 +793,7 @@ impl WorkspaceShell { let (send, received) = tokio::sync::oneshot::channel(); crate::runtime::spawn_held(tasks, hold.as_ref(), async move { let result = match ready.await { - Some(history) => change(history.saved_queries()).await, + Some(history) => change(history).await, None => Err(tablepro_storage::StorageError::NotInitialised), }; let _ = send.send(result); @@ -793,7 +808,7 @@ impl WorkspaceShell { Ok(Ok(())) => return, Ok(Err(error)) => { tracing::warn!(%error, "could not change a favorite"); - favorite_failure_text(&error, &failure) + describe(&error, &failure) } Err(error) => { tracing::warn!(%error, "favorite change did not finish"); @@ -1106,7 +1121,7 @@ mod tests { shell.change_favorites( move |store| async move { released.await.expect("release write"); - store.rename(id, "After close").await + store.saved_queries().rename(id, "After close").await }, "Rename failed".to_owned(), ); @@ -1223,15 +1238,43 @@ mod tests { created_at: std::time::SystemTime::UNIX_EPOCH, updated_at: std::time::SystemTime::UNIX_EPOCH, }; - shell.favorites_arrived(current, connection, Ok(Some(Ok(vec![saved.clone()])))); + shell.favorites_arrived( + current, + connection, + Ok(Some(Ok(SavedQueriesSnapshot { + queries: vec![saved.clone()], + folders: vec![], + }))), + ); let pane = shell.imp().favorites.get().expect("pane"); - shell.favorites_arrived(old, connection, Ok(Some(Ok(vec![])))); + shell.favorites_arrived( + old, + connection, + Ok(Some(Ok(SavedQueriesSnapshot { + queries: vec![], + folders: vec![], + }))), + ); assert_eq!(pane.names(), ["Current"]); - shell.favorites_arrived(current, Uuid::new_v4(), Ok(Some(Ok(vec![])))); + shell.favorites_arrived( + current, + Uuid::new_v4(), + Ok(Some(Ok(SavedQueriesSnapshot { + queries: vec![], + folders: vec![], + }))), + ); assert_eq!(pane.names(), ["Current"]); shell.set_front(None); assert!(pane.names().is_empty()); - shell.favorites_arrived(current, connection, Ok(Some(Ok(vec![saved])))); + shell.favorites_arrived( + current, + connection, + Ok(Some(Ok(SavedQueriesSnapshot { + queries: vec![saved], + folders: vec![], + }))), + ); assert!(pane.names().is_empty()); } diff --git a/linux/docs/storage.md b/linux/docs/storage.md index d70a66a716..05fc9ebc9f 100644 --- a/linux/docs/storage.md +++ b/linux/docs/storage.md @@ -269,14 +269,13 @@ can tell whether a re-pinned entry falls in the pages already read. ### Following the saved queries -`SavedQueries::changes` is a watch of a revision that every handle of one -database shares. A save, a save of a new name, a rename, a delete and a -connection's queries going move it on once they landed; a read, and a write -that changed nothing, leave it. The sidebar's Favorites and the Saved Queries -dialog read again on each revision, so a write from any window, an import or -a deleted connection reaches every list. Each list rejects replies from an -older read and keeps selection by saved-query id. Confirmed saves, renames -and deletions hold the process until the write finishes. +The Favorites sidebar and Saved Queries dialog follow the shared revision +feed from one `QueryHistory` ([core ADR 0017](../../core/docs/decisions/0017-favourites.md)). +A write from any window, an import or a deleted connection refreshes every list. +The sidebar reads queries and folders as one snapshot. Each list rejects replies +from an older read. Selection and folder expansion stay with their record IDs +during a refresh and clear when the front connection changes. Confirmed saves, +renames, moves and deletions hold the process until the write finishes. The editor first inserts without replacement and asks for confirmation if the name is taken. Confirmed replacement updates the same row id. The existence check diff --git a/linux/po/POTFILES.in b/linux/po/POTFILES.in index 879e1aa5b7..e31d26cf8d 100644 --- a/linux/po/POTFILES.in +++ b/linux/po/POTFILES.in @@ -613,6 +613,7 @@ crates/app/src/ui/workspace/database_transfer.rs crates/app/src/ui/workspace/definitions.rs crates/app/src/ui/workspace/diagram.rs crates/app/src/ui/workspace/editor_label.rs +crates/app/src/ui/workspace/favorite_folders.rs crates/app/src/ui/workspace/finished_work.rs crates/app/src/ui/workspace/health_banner.rs crates/app/src/ui/workspace/imp.rs @@ -625,7 +626,10 @@ crates/app/src/ui/workspace/saves.rs crates/app/src/ui/workspace/session_watches.rs crates/app/src/ui/workspace/sidebar/catalog_watch.rs crates/app/src/ui/workspace/sidebar/connection_tree.rs +crates/app/src/ui/workspace/sidebar/favorites_index.rs crates/app/src/ui/workspace/sidebar/favorites_pane.rs +crates/app/src/ui/workspace/sidebar/favorites_pane_tests.rs +crates/app/src/ui/workspace/sidebar/favorites_rows.rs crates/app/src/ui/workspace/sidebar/key_listing.rs crates/app/src/ui/workspace/sidebar/mod.rs crates/app/src/ui/workspace/sidebar/object_key.rs