diff --git a/linux/changelog.d/4122.added.md b/linux/changelog.d/4122.added.md new file mode 100644 index 0000000000..c8eead9b1a --- /dev/null +++ b/linux/changelog.d/4122.added.md @@ -0,0 +1 @@ +A table tab's bottom bar has a JSON view of the rows on screen. diff --git a/linux/crates/app/src/ui/browse_tab/browse_actions.rs b/linux/crates/app/src/ui/browse_tab/browse_actions.rs index ade139c22c..c07f6b2568 100644 --- a/linux/crates/app/src/ui/browse_tab/browse_actions.rs +++ b/linux/crates/app/src/ui/browse_tab/browse_actions.rs @@ -81,6 +81,31 @@ pub(super) fn install_browse_actions(tab: &BrowseTab, page_size: u64) -> BrowseA } tab.imp().pending_bar.announce_save_keys("table", &actions.save); tab.insert_action_group(ACTION_GROUP, Some(&group)); + let json_group = gio::SimpleActionGroup::new(); + for name in [ + "refresh", + "previous-page", + "next-page", + "first-page", + "last-page", + "page-size", + "count-rows", + "export", + ] { + if let Some(action) = group.lookup_action(name) { + json_group.add_action(&action); + } + } + let filter = gio::SimpleAction::new("filter", None); + let weak = tab.downgrade(); + filter.connect_activate(move |_, _| { + if let Some(tab) = weak.upgrade() { + tab.imp().view_stack.set_visible_child_name("data"); + tab.send(PagingInput::ShowFilterStrip); + } + }); + json_group.add_action(&filter); + let _ = tab.imp().json_browse_actions.set(json_group); let _ = tab.imp().browse_actions.set(group); install_view_actions(tab); tab.add_controller(local_shortcut_controller(ShortcutOwner::BrowseTab)); 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 cd4362927a..ee152b5644 100644 --- a/linux/crates/app/src/ui/browse_tab/data_handlers.rs +++ b/linux/crates/app/src/ui/browse_tab/data_handlers.rs @@ -135,7 +135,7 @@ impl BrowseModel { /// on screen: rows behind the loading or the error page are not what /// the table holds under the tab's filter. pub(super) fn show_grid_actions(&mut self) { - let shown = self.load.has_content() && self.this.upgrade().is_some_and(|tab| !tab.shows_structure()); + let shown = self.load.has_content() && self.this.upgrade().is_some_and(|tab| tab.shows_data()); if self.grid_actions_shown == shown { return; } diff --git a/linux/crates/app/src/ui/browse_tab/imp.rs b/linux/crates/app/src/ui/browse_tab/imp.rs index bccfe04630..f97ee577ed 100644 --- a/linux/crates/app/src/ui/browse_tab/imp.rs +++ b/linux/crates/app/src/ui/browse_tab/imp.rs @@ -32,6 +32,17 @@ pub struct BrowseTab { #[template_child] pub structure_host: TemplateChild, #[template_child] + pub json_host: TemplateChild, + pub(super) json_view: RefCell>, + pub(super) json_actions: OnceCell, + pub(super) json_browse_actions: OnceCell, + #[template_child] + pub rows_start: TemplateChild, + #[template_child] + pub json_end: TemplateChild, + #[template_child] + pub json_more: TemplateChild, + #[template_child] pub view_toggle: TemplateChild, #[template_child] pub structure_start: TemplateChild, @@ -156,6 +167,9 @@ impl ObjectImpl for BrowseTab { /// finish it for nobody. fn dispose(&self) { self.link_watch.take(); + if let Some(view) = self.json_view.borrow_mut().take() { + view.shutdown(); + } if let Ok(mut model) = self.model.try_borrow_mut() && let Some(mut model) = model.take() { diff --git a/linux/crates/app/src/ui/browse_tab/json_view.rs b/linux/crates/app/src/ui/browse_tab/json_view.rs new file mode 100644 index 0000000000..b5bb7bfeab --- /dev/null +++ b/linux/crates/app/src/ui/browse_tab/json_view.rs @@ -0,0 +1,368 @@ +use std::cell::{Cell, RefCell}; +use std::rc::Rc; + +use gtk4 as gtk; +use gtk4::{gio, glib}; +use libadwaita as adw; +use libadwaita::prelude::*; +use sourceview5::prelude::*; +use tablepro_core::export::EncodeError; +use tablepro_session::runtime::Tasks; + +use crate::i18n::{gettext, gettext_f, ngettext_f}; +use crate::ui::clipboard::{ClipboardFormat, ClipboardPayload, copy_payload}; +use crate::ui::data_grid::{DataGrid, JsonPreview, JsonPreviewRequest, json_preview}; +use crate::ui::handler_guard::HandlerGuard; +use crate::ui::tab_load::{ContentPage, LoadPresentation, StaleBanner}; + +pub(super) struct JsonView { + state: Rc, +} + +struct State { + root: adw::ToolbarView, + stack: gtk::Stack, + view: sourceview5::View, + error: adw::StatusPage, + stale: StaleBanner, + notice: adw::Banner, + toasts: adw::ToastOverlay, + copy: gio::SimpleAction, + tasks: Option, + pending: RefCell>, + rendered: RefCell>, + guards: RefCell>, + generation: Cell, + running: Cell, + closed: Cell, +} + +impl JsonView { + pub(super) fn new(grid: &DataGrid, retry: impl Fn() + 'static) -> Self { + let retry = Rc::new(retry); + let buffer = sourceview5::Buffer::new(None); + buffer.set_language(sourceview5::LanguageManager::default().language("json").as_ref()); + let config = grid.config(); + let guards = crate::ui::source_dialog::follow_scheme(&buffer, config.as_ref().map(|config| &config.settings)); + let view = sourceview5::View::with_buffer(&buffer); + view.set_editable(false); + view.set_cursor_visible(true); + view.set_monospace(true); + view.set_show_line_numbers(true); + view.set_top_margin(8); + view.set_bottom_margin(8); + view.set_left_margin(8); + view.update_property(&[gtk::accessible::Property::Label(&gettext("Rows as JSON"))]); + let stack = gtk::Stack::new(); + stack.add_named(>k::ScrolledWindow::builder().child(&view).build(), Some("content")); + stack.add_named(&loading_page(), Some("loading")); + let error = error_page(retry.clone()); + stack.add_named(&error, Some("error")); + stack.set_visible_child_name("loading"); + let toasts = adw::ToastOverlay::new(); + toasts.set_child(Some(&stack)); + let root = adw::ToolbarView::builder().content(&toasts).build(); + let stale = adw::Banner::new(&gettext("Couldn't refresh rows. Showing the last loaded page.")); + root.add_top_bar(&stale); + let notice = adw::Banner::new(""); + notice.set_use_markup(false); + root.add_top_bar(¬ice); + let copy = gio::SimpleAction::new("copy", None); + copy.set_enabled(false); + let state = Rc::new(State { + root, + stack, + view, + error, + stale: StaleBanner::new(stale, move || retry()), + notice, + toasts, + copy, + tasks: config.as_ref().map(|config| config.tasks.clone()), + pending: RefCell::new(None), + rendered: RefCell::new(None), + guards: RefCell::new(guards), + generation: Cell::new(0), + running: Cell::new(false), + closed: Cell::new(false), + }); + let weak = Rc::downgrade(&state); + state.copy.connect_activate(move |_, _| { + if let Some(state) = weak.upgrade() { + state.copy(); + } + }); + Self { state } + } + + pub(super) fn widget(&self) -> >k::Widget { + self.state.root.upcast_ref() + } + + pub(super) fn copy_action(&self) -> &gio::SimpleAction { + &self.state.copy + } + + #[cfg(test)] + pub(super) fn view(&self) -> &sourceview5::View { + &self.state.view + } + + pub(super) fn refresh(&self, grid: &DataGrid, presentation: LoadPresentation) { + let state = &self.state; + if state.closed.get() { + return; + } + let generation = state.generation.get().wrapping_add(1); + state.generation.set(generation); + state.copy.set_enabled(false); + state.pending.take(); + state.stale.show(presentation.stale.as_ref()); + match presentation.page { + ContentPage::Spinner => { + state.clear(); + state.stack.set_visible_child_name("loading"); + } + ContentPage::Error(failure) => state.show_error(&gettext("Couldn't Load Rows"), &failure.message()), + ContentPage::Content => { + state.pending.replace(Some((generation, json_preview(grid)))); + state.start_next(); + } + } + } + + pub(super) fn shutdown(&self) { + self.state.shutdown(); + } +} + +impl State { + fn start_next(self: &Rc) { + if self.running.get() || self.closed.get() { + return; + } + let Some((generation, request)) = self.pending.take() else { + return; + }; + let Some(tasks) = self.tasks.as_ref() else { + self.show_error( + &gettext("Can't Show Rows as JSON"), + &gettext("Connect to a database first."), + ); + return; + }; + self.running.set(true); + let rendered = tasks.spawn_blocking_task(move || request.render()); + let weak = Rc::downgrade(self); + glib::spawn_future_local(async move { + let result = rendered.await; + let Some(state) = weak.upgrade().filter(|state| !state.closed.get()) else { + return; + }; + state.running.set(false); + // A replaced page or failed read must not be overwritten by its earlier preview. + if generation == state.generation.get() { + match result { + Ok(Ok(preview)) => state.show(preview), + Ok(Err(error)) => state.show_encode_error(error), + Err(failure) => { + tracing::warn!(%failure, "JSON preview rendering failed"); + state.show_error( + &gettext("Can't Show Rows as JSON"), + &gettext("The JSON preview could not be created. Try refreshing the rows."), + ); + } + } + } + state.start_next(); + }); + } + + fn show(&self, preview: JsonPreview) { + let buffer = self.view.buffer(); + let current = buffer.text(&buffer.start_iter(), &buffer.end_iter(), false); + if current.as_str() != preview.text { + buffer.set_text(&preview.text); + } + let notice = preview_notice(&preview); + self.notice.set_title(¬ice); + self.notice.set_revealed(!notice.is_empty()); + self.rendered.replace(Some(preview)); + self.stack.set_visible_child_name("content"); + self.copy.set_enabled(true); + } + + fn show_encode_error(&self, error: EncodeError) { + let (EncodeError::Undecodable { column } | EncodeError::NotXmlText { column }) = error; + self.show_error( + &gettext("Can't Show Rows as JSON"), + &gettext_f( + "The column “{column}” holds a value TablePro couldn't read, so these rows have no JSON to show.", + &[("column", &column)], + ), + ); + } + + fn show_error(&self, title: &str, description: &str) { + let had_focus = crate::ui::a11y::holds_focus(&self.root); + let escaped = glib::markup_escape_text(description); + let changed = self.stack.visible_child_name().as_deref() != Some("error") + || self.error.description().as_deref() != Some(escaped.as_str()); + self.clear(); + self.error.set_title(title); + self.error.set_description(Some(&escaped)); + self.stack.set_visible_child_name("error"); + if had_focus && let Some(retry) = self.error.child() { + retry.grab_focus(); + } + if changed { + crate::ui::a11y::announce( + &self.error, + &format!("{title}. {description}"), + gtk::AccessibleAnnouncementPriority::High, + ); + } + } + + fn clear(&self) { + self.rendered.take(); + self.copy.set_enabled(false); + self.notice.set_revealed(false); + self.view.buffer().set_text(""); + } + + fn copy(&self) { + if !self.copy.is_enabled() { + return; + } + let rendered = self.rendered.borrow(); + let Some(preview) = rendered.as_ref() else { + return; + }; + let payload = ClipboardPayload { + text: preview.text.clone(), + format: ClipboardFormat::Json, + rows: preview.shown, + skipped: 0, + cells: None, + }; + copy_payload(&self.view, payload, |message| { + self.toasts.add_toast(crate::ui::plain_toast(message)) + }); + } + + fn shutdown(&self) { + if self.closed.replace(true) { + return; + } + self.pending.take(); + self.rendered.take(); + self.copy.set_enabled(false); + self.guards.borrow_mut().clear(); + crate::ui::text_view_teardown::release(&self.view); + } +} + +impl Drop for State { + fn drop(&mut self) { + self.shutdown(); + } +} + +fn loading_page() -> adw::StatusPage { + adw::StatusPage::builder() + .title(gettext("Loading…")) + .child(&adw::Spinner::builder().width_request(32).height_request(32).build()) + .build() +} + +fn error_page(retry: Rc) -> adw::StatusPage { + let button = gtk::Button::with_label(&gettext("Try Again")); + button.add_css_class("suggested-action"); + button.set_halign(gtk::Align::Center); + button.connect_clicked(move |_| retry()); + adw::StatusPage::builder() + .title(gettext("Couldn't Load Rows")) + .child(&button) + .build() +} + +fn preview_notice(preview: &JsonPreview) -> String { + let mut notices = Vec::new(); + if preview.shown < preview.total { + notices.push(gettext_f( + "{shown} of {total} rows shown. This is a limited preview. Export Rows includes the full page.", + &[ + ("shown", &preview.shown.to_string()), + ("total", &preview.total.to_string()), + ], + )); + } + if preview.deleted > 0 { + notices.push(ngettext_f( + "{count} row marked for deletion is not shown.", + "{count} rows marked for deletion are not shown.", + preview.deleted as u64, + &[("count", &preview.deleted.to_string())], + )); + } + notices.join(" ") +} + +#[cfg(test)] +mod tests { + use std::sync::Arc; + + use super::*; + use crate::test_support::wait_until; + use crate::ui::data_grid::test_grid::{Grid, WAIT, page, two_text_columns, two_text_values}; + use crate::ui::tab_load::{ContentLoad, LoadFailure}; + + fn text(view: &JsonView) -> String { + let buffer = view.view().buffer(); + buffer.text(&buffer.start_iter(), &buffer.end_iter(), false).to_string() + } + + #[gtk4::test] + fn only_the_latest_preview_lands_and_unchanged_text_keeps_selection() { + let grid = Grid::open(two_text_columns(), two_text_values()); + let view = JsonView::new(&grid.grid, || {}); + view.refresh(&grid.grid, ContentLoad::Loaded.presentation()); + grid.grid.replace_rows(page(3..5), 0); + view.refresh(&grid.grid, ContentLoad::Loaded.presentation()); + assert!(!view.copy_action().is_enabled()); + wait_until(WAIT, || view.copy_action().is_enabled()).expect("the latest preview"); + assert!(text(&view).contains("row 3")); + assert!(!text(&view).contains("\"A\"")); + + let buffer = view.view().buffer(); + buffer.select_range(&buffer.iter_at_offset(1), &buffer.iter_at_offset(4)); + view.refresh(&grid.grid, ContentLoad::Loaded.presentation()); + wait_until(WAIT, || view.copy_action().is_enabled()).expect("the unchanged preview"); + let (start, end) = buffer.selection_bounds().expect("selection survived"); + assert_eq!((start.offset(), end.offset()), (1, 4)); + view.shutdown(); + } + + #[gtk4::test] + fn a_render_cannot_replace_a_read_error_or_keep_a_closed_view_alive() { + let grid = Grid::open(two_text_columns(), two_text_values()); + let view = JsonView::new(&grid.grid, || {}); + view.refresh(&grid.grid, ContentLoad::Loaded.presentation()); + let failed = ContentLoad::Failed(LoadFailure::Page(Arc::new(tablepro_session::OperationError::Closed))); + view.refresh(&grid.grid, failed.presentation()); + wait_until(WAIT, || !view.state.running.get()).expect("the obsolete render finished"); + assert_eq!(view.state.stack.visible_child_name().as_deref(), Some("error")); + assert!(!view.copy_action().is_enabled()); + assert!(text(&view).is_empty()); + + view.refresh(&grid.grid, ContentLoad::Loaded.presentation()); + let weak = view.view().downgrade(); + view.shutdown(); + drop(view); + assert!( + weak.upgrade().is_none(), + "a background render retained the closed editor" + ); + } +} diff --git a/linux/crates/app/src/ui/browse_tab/layout.rs b/linux/crates/app/src/ui/browse_tab/layout.rs index ebd8c986d1..d687b0b700 100644 --- a/linux/crates/app/src/ui/browse_tab/layout.rs +++ b/linux/crates/app/src/ui/browse_tab/layout.rs @@ -35,6 +35,12 @@ pub(super) struct LayoutInit<'a> { /// its input. Gives back the widgets the handlers drive. pub(super) fn build(tab: &BrowseTab, init: &LayoutInit<'_>) -> BrowseTabWidgets { let imp = tab.imp(); + let weak = tab.downgrade(); + imp.view_stack.connect_visible_child_name_notify(move |_| { + if let Some(tab) = weak.upgrade() { + tab.follow_selected_view(); + } + }); imp.loading_page .set_description(Some(&loading_description(init.table_label))); imp.inner_stack.set_visible_child_name("loading"); @@ -42,6 +48,7 @@ pub(super) fn build(tab: &BrowseTab, init: &LayoutInit<'_>) -> BrowseTabWidgets let page_sizes = page_size_choices(&imp.page_size_dropdown, init.page_size); imp.overflow_button.set_menu_model(Some(&overflow_menu(&page_sizes))); imp.more_button.set_menu_model(Some(&more_menu(&page_sizes))); + imp.json_more.set_menu_model(Some(&json_menu(&page_sizes))); connect_controls(tab, page_sizes.clone()); BrowseTabWidgets { inner_stack: imp.inner_stack.get(), @@ -95,6 +102,17 @@ fn overflow_menu(page_sizes: &[u64]) -> gio::Menu { menu } +fn json_menu(page_sizes: &[u64]) -> gio::Menu { + let actions = gio::Menu::new(); + actions.append(Some(&gettext("_Filter Rows…")), Some("browse.filter")); + actions.append(Some(&gettext("_Export Rows…")), Some("browse.export")); + actions.append(Some(&gettext("_Count Rows")), Some("browse.count-rows")); + let menu = gio::Menu::new(); + menu.append_section(None, &actions); + menu.append_section(Some(&gettext("Rows per Page")), &page_size_menu(page_sizes)); + menu +} + fn export_item() -> gio::MenuItem { let export = gio::MenuItem::new(Some(&gettext("_Export Rows…")), Some("browse.export")); // The window's Export Results key reaches this tab's Export. diff --git a/linux/crates/app/src/ui/browse_tab/mod.rs b/linux/crates/app/src/ui/browse_tab/mod.rs index bf262b3d9a..f658986a21 100644 --- a/linux/crates/app/src/ui/browse_tab/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/mod.rs @@ -27,6 +27,7 @@ mod fetch; mod grid_handlers; mod grid_input; mod imp; +mod json_view; mod layout; mod page_label; mod page_reply; @@ -225,6 +226,10 @@ impl BrowseTab { if self.shows_structure() { return self.structure_tab()?.save_action(); } + // The JSON preview edits nothing, so Save stays with the grid's own view. + if self.shows_json() { + return None; + } self.imp().save_action.get().cloned() } @@ -283,6 +288,7 @@ impl BrowseTab { } } imp.dispatching.set(false); + self.refresh_json(); } /// Stop every read the tab has running and stop following @@ -291,6 +297,9 @@ impl BrowseTab { pub fn shutdown(&self) { let imp = self.imp(); imp.link_watch.take(); + if let Some(view) = imp.json_view.borrow().as_ref() { + view.shutdown(); + } if let Ok(mut model) = imp.model.try_borrow_mut() && let Some(model) = model.as_mut() { @@ -429,13 +438,7 @@ impl BrowseTab { pub fn offer_structure(&self) { let imp = self.imp(); - imp.view_toggle.set_visible(true); - let tab = self.downgrade(); - imp.view_stack.connect_visible_child_name_notify(move |_| { - if let Some(tab) = tab.upgrade() { - tab.follow_selected_view(); - } - }); + imp.view_stack.page(&*imp.structure_host).set_visible(true); } pub fn set_structure(&self, structure: &crate::ui::structure_tab::StructureTab) { @@ -456,26 +459,44 @@ impl BrowseTab { self.imp().view_stack.visible_child_name().as_deref() == Some("structure") } + pub(super) fn shows_data(&self) -> bool { + self.imp().view_stack.visible_child_name().as_deref() == Some("data") + } + + pub(super) fn shows_json(&self) -> bool { + self.imp().view_stack.visible_child_name().as_deref() == Some("json") + } + fn follow_selected_view(&self) { let imp = self.imp(); let structure = self.shows_structure(); // Finish an open cell before hiding its editor, so close and Save see the draft. - if structure { + if !self.shows_data() { self.commit_cell_edit(); } if structure && !imp.structure_requested.replace(true) { self.emit_by_name::<()>("structure-requested", &[]); } - imp.data_start.set_visible(!structure); - imp.data_end.set_visible(!structure); + imp.data_start.set_visible(self.shows_data()); + imp.data_end.set_visible(self.shows_data()); + imp.rows_start.set_visible(!structure); + imp.json_end.set_visible(self.shows_json()); imp.structure_start.set_visible(structure); imp.structure_end.set_visible(structure); self.sync_structure_actions(); - let actions = imp.browse_actions.get().filter(|_| !structure); + let actions = if self.shows_data() { + imp.browse_actions.get() + } else if self.shows_json() { + imp.json_browse_actions.get() + } else { + None + }; self.insert_action_group("browse", actions); + self.insert_action_group("json", imp.json_actions.get().filter(|_| self.shows_json())); if let Some(model) = imp.model.borrow_mut().as_mut() { model.show_grid_actions(); } + self.refresh_json(); self.emit_by_name::<()>("save-action-changed", &[]); } @@ -500,6 +521,36 @@ impl BrowseTab { } } + fn refresh_json(&self) { + if !self.shows_json() { + return; + } + let imp = self.imp(); + let Some(grid) = imp.grid.get() else { + return; + }; + if imp.json_view.borrow().is_none() { + let weak = self.downgrade(); + let view = json_view::JsonView::new(grid, move || { + if let Some(tab) = weak.upgrade() { + tab.send(PagingInput::RequestRefresh); + } + }); + libadwaita::prelude::BinExt::set_child(&*imp.json_host, Some(view.widget())); + let group = gtk::gio::SimpleActionGroup::new(); + group.add_action(view.copy_action()); + let _ = imp.json_actions.set(group); + imp.json_view.replace(Some(view)); + } + self.insert_action_group("json", imp.json_actions.get()); + if let (Some(view), Some(presentation)) = ( + imp.json_view.borrow().as_ref(), + self.read(|model| model.load.presentation()), + ) { + view.refresh(grid, presentation); + } + } + /// F5 asked the window to read the tab again. pub fn connect_refresh_requested(&self, f: F) -> glib::SignalHandlerId { self.connect_closure( diff --git a/linux/crates/app/src/ui/browse_tab/tests/json.rs b/linux/crates/app/src/ui/browse_tab/tests/json.rs new file mode 100644 index 0000000000..9cff456fd6 --- /dev/null +++ b/linux/crates/app/src/ui/browse_tab/tests/json.rs @@ -0,0 +1,249 @@ +use gtk4::prelude::*; +use gtk4::subclass::prelude::ObjectSubclassIsExt; +use libadwaita as adw; +use tablepro_core::DriverError; +use tablepro_test_support::FakeReply; + +use super::{ + BrowseTab, Harness, PagingInput, Shown, WAIT, full_page, grid_cell_of, not_null_name, rows, serving_table, text, + type_into, +}; +use crate::test_support::{SignalLog, descendants, wait_until}; + +fn json_text(tab: &BrowseTab) -> Option { + let state = tab.imp().json_view.borrow(); + let view = state.as_ref()?; + if !view.copy_action().is_enabled() { + return None; + } + let buffer = view.view().buffer(); + Some(buffer.text(&buffer.start_iter(), &buffer.end_iter(), false).to_string()) +} + +fn json_rows(tab: &BrowseTab) -> Option { + serde_json::from_str(&json_text(tab)?).ok() +} + +fn json_widgets(tab: &BrowseTab) -> Vec { + let state = tab.imp().json_view.borrow(); + descendants(state.as_ref().expect("the JSON view").widget()) +} + +#[gtk4::test] +fn the_bottom_bar_shows_the_rows_as_json_without_structure_support() { + let mut script = serving_table(); + script.query_bound.always(FakeReply::ok(rows(&["Ada", "Grace"]))); + let harness = Harness::open(script, []); + let tab = harness.tab(); + let _shown = Shown::new(tab); + wait_until(WAIT, || harness.shown() == text(&["Ada", "Grace"])).expect("the page"); + let imp = tab.imp(); + assert!(imp.view_toggle.is_visible()); + assert!(!imp.view_stack.page(&imp.structure_host.get()).is_visible()); + assert!(imp.view_stack.page(&imp.json_host.get()).is_visible()); + imp.view_stack.set_visible_child_name("json"); + wait_until(WAIT, || json_rows(tab).is_some()).expect("the JSON preview"); + let json = json_rows(tab).unwrap(); + assert_eq!(json[0]["name"], "Ada"); + assert_eq!(json[1]["name"], "Grace"); + let view = imp.json_view.borrow().as_ref().unwrap().view().clone(); + assert!(!view.is_editable()); + assert!(view.is_cursor_visible(), "keyboard selection needs a cursor"); + assert!(!imp.data_start.is_visible() && !imp.data_end.is_visible()); + assert!(imp.rows_start.is_visible() && imp.json_end.is_visible()); + assert!(tab.activate_action("grid.insert-row", None).is_err()); + assert!(tab.activate_action("grid.delete-rows", None).is_err()); + assert!( + tab.shown_save_action().is_none(), + "the header's Save has nothing to save in JSON" + ); + imp.view_stack.set_visible_child_name("data"); + assert!(tab.shown_save_action().is_some()); + // At 600 px the narrow layout hides the row actions, so Insert's own flag is what Data restores. + assert!(imp.data_start.get_visible() && imp.data_end.get_visible()); + assert!(imp.insert_button.get_visible()); + assert!(!imp.json_end.get_visible()); +} + +#[gtk4::test] +fn json_follows_equal_length_pages_and_refreshes() { + let mut script = serving_table(); + script.count_rows.always(FakeReply::ok(1_000)); + script + .query_bound + .once(FakeReply::ok(full_page(0))) + .once(FakeReply::ok(full_page(100))) + .always(FakeReply::ok(full_page(200))); + let harness = Harness::open(script, []); + let tab = harness.tab(); + tab.imp().view_stack.set_visible_child_name("json"); + wait_until(WAIT, || json_rows(tab).is_some_and(|rows| rows[0]["id"] == 0)).expect("the first JSON page"); + tab.activate_action("browse.next-page", None).unwrap(); + wait_until(WAIT, || json_rows(tab).is_some_and(|rows| rows[0]["id"] == 100)).expect("the next JSON page"); + tab.send(PagingInput::Refresh); + wait_until(WAIT, || json_rows(tab).is_some_and(|rows| rows[0]["id"] == 200)).expect("the refreshed JSON page"); + assert_eq!(json_rows(tab).unwrap().as_array().unwrap().len(), 100); + assert!(tab.activate_action("grid.insert-row", None).is_err()); + assert!(!tab.imp().data_start.is_visible()); +} + +#[gtk4::test] +fn json_replaces_failed_filter_results_with_error_and_retry() { + let mut script = serving_table(); + script + .query_bound + .once(FakeReply::ok(rows(&["old"]))) + .once(FakeReply::err(DriverError::server("relation is gone"))) + .always(FakeReply::ok(rows(&["fresh"]))); + let harness = Harness::open(script, []); + let tab = harness.tab(); + let _shown = Shown::new(tab); + tab.imp().view_stack.set_visible_child_name("json"); + wait_until(WAIT, || json_rows(tab).is_some()).expect("the JSON preview"); + tab.send(PagingInput::FilterApplied(not_null_name())); + wait_until(WAIT, || { + json_widgets(tab).iter().any(|widget| { + widget + .downcast_ref::() + .is_some_and(|page| page.is_mapped() && page.title() == "Couldn't Load Rows") + }) + }) + .expect("the JSON error page"); + assert!( + json_text(tab).is_none(), + "old rows could still be copied as current results" + ); + let error = json_widgets(tab) + .into_iter() + .filter_map(|widget| widget.downcast::().ok()) + .find(|page| page.is_mapped()) + .unwrap(); + assert!(error.description().unwrap().contains("relation <users> is gone")); + let retry = error.child().unwrap().downcast::().unwrap(); + let refreshes = SignalLog::connect(tab, "refresh-requested", |_| ()); + retry.emit_clicked(); + assert_eq!(refreshes.count(), 1); + // This harness has no workspace to approve the request for its clean draft. + tab.send(PagingInput::Refresh); + wait_until(WAIT, || json_rows(tab).is_some_and(|rows| rows[0]["name"] == "fresh")).expect("retry refreshed JSON"); +} + +#[gtk4::test] +fn json_keeps_failed_refresh_visible_under_its_stale_banner() { + let mut script = serving_table(); + script + .query_bound + .once(FakeReply::ok(rows(&["kept"]))) + .once(FakeReply::err(DriverError::server("denied"))) + .always(FakeReply::ok(rows(&["fresh"]))); + let harness = Harness::open(script, []); + let tab = harness.tab(); + let _shown = Shown::new(tab); + tab.imp().view_stack.set_visible_child_name("json"); + wait_until(WAIT, || json_rows(tab).is_some()).expect("the JSON preview"); + tab.send(PagingInput::Refresh); + let stale = || { + json_widgets(tab) + .into_iter() + .filter_map(|widget| widget.downcast::().ok()) + .find(|banner| banner.is_revealed() && banner.title().starts_with("Couldn't refresh rows.")) + }; + wait_until(WAIT, || stale().is_some()).expect("the JSON stale banner"); + wait_until(WAIT, || json_rows(tab).is_some_and(|rows| rows[0]["name"] == "kept")).expect("last good rows remain"); + let refreshes = SignalLog::connect(tab, "refresh-requested", |_| ()); + stale().unwrap().emit_by_name::<()>("button-clicked", &[]); + assert_eq!(refreshes.count(), 1); + // This harness has no workspace to approve the request for its clean draft. + tab.send(PagingInput::Refresh); + wait_until(WAIT, || json_rows(tab).is_some_and(|rows| rows[0]["name"] == "fresh")).expect("Retry updates JSON"); + assert!(stale().is_none()); +} + +#[gtk4::test] +fn selecting_json_commits_the_open_cell_without_exposing_row_write_commands() { + let mut script = serving_table(); + script.query_bound.always(FakeReply::ok(rows(&["Ada"]))); + let harness = Harness::open(script, []); + let tab = harness.tab(); + let _shown = Shown::new(tab); + wait_until(WAIT, || harness.shown().len() == 1).expect("the row"); + let cell = grid_cell_of(tab, 0, 1); + let _editor = type_into(&harness, &cell, "Edited"); + let saves = SignalLog::connect(tab, "save-requested", |_| ()); + tab.imp().view_stack.set_visible_child_name("json"); + wait_until(WAIT, || json_rows(tab).is_some_and(|rows| rows[0]["name"] == "Edited")) + .expect("the pending edit in JSON"); + assert!(!harness.grid().is_editing()); + assert_eq!(harness.tracker.pending_count(), 1); + let view = tab.imp().json_view.borrow().as_ref().unwrap().view().clone(); + wait_until(WAIT, || view.is_mapped()).expect("the JSON text is mapped"); + assert!(view.grab_focus()); + use crate::application::ShortcutOwner; + use crate::test_support::shortcut_keys::{keystroke, owner_controller, shortcuts, trigger_keys}; + let ctrl_s = shortcuts(&owner_controller(tab, ShortcutOwner::BrowseTab).unwrap()) + .into_iter() + .find(|shortcut| { + shortcut + .trigger() + .is_some_and(|trigger| trigger_keys(&trigger).contains(&keystroke("s"))) + }) + .and_then(|shortcut| shortcut.action()) + .expect("Ctrl+S is bound"); + assert!(ctrl_s.activate(gtk4::ShortcutActionFlags::empty(), &view, None)); + for action in [ + "browse.save", + "browse.undo", + "browse.redo", + "grid.insert-row", + "grid.delete-rows", + ] { + assert!( + tab.activate_action(action, None).is_err(), + "{action} reached hidden rows" + ); + } + assert_eq!(saves.count(), 0); + assert_eq!(harness.tracker.pending_count(), 1); + tab.activate_action("browse.filter", None).unwrap(); + assert!(tab.shows_data()); + assert!(tab.read(|model| model.filter_strip.revealed()).unwrap()); +} + +#[gtk4::test] +fn json_keeps_read_only_insert_policy_and_fits_the_window_floor() { + let mut script = serving_table(); + script.query_bound.always(FakeReply::ok(rows(&["Ada"]))); + let harness = Harness::open_read_only(script); + let tab = harness.tab(); + tab.offer_structure(); + let window = crate::test_support::OwnedWindow::presented( + adw::Window::builder() + .default_width(360) + .default_height(400) + .content(tab) + .build(), + ); + let imp = tab.imp(); + wait_until(WAIT, || harness.shown().len() == 1 && imp.more_button.is_mapped()).expect("the compact Data bar"); + assert!(!imp.insert_button.is_visible()); + let (data_width, ..) = imp.action_bar.measure(gtk4::Orientation::Horizontal, -1); + assert!(data_width <= 360, "the three-view Data bar needs {data_width}px"); + imp.view_stack.set_visible_child_name("json"); + wait_until(WAIT, || json_rows(tab).is_some() && imp.json_more.is_mapped()).expect("the compact JSON bar"); + let (json_width, ..) = imp.action_bar.measure(gtk4::Orientation::Horizontal, -1); + assert!(json_width <= 360, "the JSON bar needs {json_width}px"); + tab.send(PagingInput::Refresh); + wait_until(WAIT, || !tab.is_loading() && json_rows(tab).is_some()).expect("the refreshed preview"); + assert!(!imp.insert_button.is_visible()); + imp.view_stack.set_visible_child_name("data"); + assert!( + !imp.insert_button.is_visible(), + "returning from JSON exposed Insert on a read-only table" + ); + window.set_size_request(1_000, 400); + wait_until(WAIT, || !imp.more_button.is_mapped()).expect("the wide bar"); + assert_eq!( + imp.view_toggle.display_mode(), + adw::InlineViewSwitcherDisplayMode::Labels + ); +} 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 a18735d900..d38c38730c 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/mod.rs @@ -1,4 +1,5 @@ mod default_sort; +mod json; mod load; mod references; mod rows; @@ -1700,7 +1701,7 @@ fn the_bottom_bar_switches_between_data_and_structure() { .into_iter() .filter(|widget| widget.accessible_role() == gtk4::AccessibleRole::Tab) .collect(); - assert_eq!(tabs.len(), 2); + assert_eq!(tabs.len(), 3); assert!(tabs[1].activate()); wait_until(WAIT, || tab.shows_structure()).expect("keyboard activation selects Structure"); assert_eq!(asked.get(), 1); @@ -2019,7 +2020,7 @@ fn the_view_switch_keeps_its_names_in_a_1200_px_window() { .iter() .map(|label| label.label().to_string()) .collect(); - assert_eq!(names, ["Data", "Structure"]); + assert_eq!(names, ["Data", "Structure", "JSON"]); assert!( wait_until(WAIT, || bar_shortfall(tab).is_none()).is_ok(), "{:?}", @@ -2039,6 +2040,10 @@ fn the_view_switch_keeps_its_names_in_a_1200_px_window() { "{:?}", bar_shortfall(tab) ); + assert_eq!( + imp.view_toggle.display_mode(), + libadwaita::InlineViewSwitcherDisplayMode::Labels + ); assert!(!columns.is_visible() && !imp.export_button.is_visible() && !imp.page_size_dropdown.is_mapped()); assert!(!imp.more_button.is_visible()); let moved = menu_actions(&imp.overflow_button.menu_model().expect("the overflow menu")); diff --git a/linux/crates/app/src/ui/data_grid/copy/json_preview.rs b/linux/crates/app/src/ui/data_grid/copy/json_preview.rs new file mode 100644 index 0000000000..d14a1a4dfc --- /dev/null +++ b/linux/crates/app/src/ui/data_grid/copy/json_preview.rs @@ -0,0 +1,222 @@ +use std::sync::Arc; + +use gtk4::prelude::*; +use tablepro_core::Value; +use tablepro_core::column::ResultColumn; +use tablepro_core::export::{EncodeError, JsonArrayEncoder, RowEncoder}; + +use super::{DataGrid, GridRow, ShownColumns}; +use crate::services::grid::RowSnapshot; + +const MAX_ROWS: usize = 1_000; +const MAX_BYTES: usize = 256 * 1024; +const MAX_DEPTH: usize = 64; + +pub(crate) struct JsonPreviewRequest { + columns: Arc<[ResultColumn]>, + indices: Vec, + rows: Vec, + total: usize, + deleted: usize, +} + +pub(crate) struct JsonPreview { + pub(crate) text: String, + pub(crate) shown: usize, + pub(crate) total: usize, + pub(crate) deleted: usize, +} + +pub(crate) fn json_preview(grid: &DataGrid) -> JsonPreviewRequest { + let columns = ShownColumns::of(grid); + let tracked = grid.tracked(); + let model = grid.selection(); + let mut rows = Vec::new(); + let mut total = 0; + let mut deleted = 0; + for position in 0..model.n_items() { + let Some(row) = model.item(position).and_downcast::() else { + continue; + }; + if tracked.mark(&row, 0).row_deleted { + deleted += 1; + continue; + } + total += 1; + if rows.len() < MAX_ROWS { + rows.push(tracked.snapshot(&row)); + } + } + JsonPreviewRequest { + columns: columns.columns, + indices: columns.indices, + rows, + total, + deleted, + } +} + +impl JsonPreviewRequest { + pub(crate) fn render(self) -> Result { + let mut name_budget = MAX_BYTES; + let names_fit = self + .columns + .iter() + .all(|column| spend(&mut name_budget, column.name.len().saturating_add(16))); + if !names_fit { + return Ok(self.empty()); + } + let mut encoder = JsonArrayEncoder::new(self.columns.clone()); + let mut bytes = Vec::new(); + let mut shown = 0; + encoder.begin(&mut bytes); + for row in &self.rows { + let mut budget = name_budget; + // Refuse huge values before the core serializer allocates their escaped representation. + if !self.indices.iter().all(|index| fits(row.value(*index), &mut budget, 0)) { + break; + } + for (column, index) in self.columns.iter().zip(&self.indices) { + if unreadable(row.value(*index)) { + return Err(EncodeError::Undecodable { + column: column.name.clone(), + }); + } + } + let start = bytes.len(); + let mut values = self.indices.iter().map(|index| row.value(*index)); + encoder.row(&mut bytes, &mut values)?; + if bytes.len().saturating_add(2) > MAX_BYTES { + bytes.truncate(start); + break; + } + shown += 1; + } + encoder.finish(&mut bytes); + Ok(JsonPreview { + text: String::from_utf8_lossy(&bytes).into_owned(), + shown, + total: self.total, + deleted: self.deleted, + }) + } + + fn empty(&self) -> JsonPreview { + JsonPreview { + text: "[]".into(), + shown: 0, + total: self.total, + deleted: self.deleted, + } + } +} + +fn unreadable(value: &Value) -> bool { + match value { + Value::Undecodable(_) => true, + Value::Array(values) => values.iter().any(unreadable), + _ => false, + } +} + +fn spend(budget: &mut usize, bytes: usize) -> bool { + match budget.checked_sub(bytes) { + Some(left) => { + *budget = left; + true + } + None => false, + } +} + +fn fits(value: &Value, budget: &mut usize, depth: usize) -> bool { + let bytes = match value { + Value::Text(text) => text.len(), + Value::Json(json) => json.as_str().len(), + Value::Other(other) => other.text.len(), + Value::Bytes(bytes) => bytes.len().saturating_mul(2), + Value::Bits(bits) => bits.bit_len() as usize, + Value::Decimal(decimal) => decimal.precision().unwrap_or(8) as usize + 3, + Value::Array(values) => { + return depth < MAX_DEPTH + && spend(budget, values.len().saturating_add(2)) + && values.iter().all(|value| fits(value, budget, depth + 1)); + } + _ => 80, + }; + spend(budget, bytes.saturating_add(2)) +} + +#[cfg(test)] +mod tests { + use tablepro_core::column::ColumnType; + use tablepro_core::value::{UndecodableReason, UndecodedValue}; + + use super::*; + + fn request(values: Vec) -> JsonPreviewRequest { + let total = values.len(); + JsonPreviewRequest { + columns: vec![ResultColumn::new("value", ColumnType::untyped_text("text"))].into(), + indices: vec![0], + rows: values + .into_iter() + .take(MAX_ROWS) + .map(|value| RowSnapshot::new(vec![value].into(), Vec::new())) + .collect(), + total, + deleted: 0, + } + } + + #[test] + fn preview_reports_rows_beyond_the_limit_and_stays_a_complete_array() { + let preview = request((0..1_005).map(Value::Int).collect()).render().unwrap(); + assert_eq!((preview.shown, preview.total), (1_000, 1_005)); + let json: serde_json::Value = serde_json::from_str(&preview.text).unwrap(); + assert_eq!(json.as_array().unwrap().len(), 1_000); + assert_eq!(json[999]["value"], 999); + } + + #[test] + fn preview_bounds_escaped_text_at_a_whole_row() { + let preview = request(vec![ + Value::Text("kept".into()), + Value::Text("\u{0001}".repeat(100_000)), + Value::Text("later".into()), + ]) + .render() + .unwrap(); + assert!(preview.text.len() <= MAX_BYTES); + assert_eq!((preview.shown, preview.total), (1, 3)); + assert_eq!(preview.text, "[\n{\"value\":\"kept\"}\n]"); + } + + #[test] + fn preview_refuses_a_huge_value_before_encoding_it() { + let preview = request(vec![Value::Bytes(vec![0; MAX_BYTES])]).render().unwrap(); + assert_eq!((preview.shown, preview.total), (0, 1)); + assert_eq!(preview.text, "[]"); + } + + #[test] + fn preview_refuses_unreadable_values_instead_of_inventing_null() { + let value = Value::Undecodable(Box::new(UndecodedValue { + type_name: "custom".into(), + reason: UndecodableReason::UnsupportedType, + })); + for value in [value.clone(), Value::Array(vec![value])] { + assert_eq!( + request(vec![value]).render().err(), + Some(EncodeError::Undecodable { column: "value".into() }) + ); + } + } + + #[test] + fn preview_snapshot_can_leave_the_gtk_thread() { + fn sendable() {} + sendable::(); + sendable::(); + } +} 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 decb23cc3f..83e432fc9d 100644 --- a/linux/crates/app/src/ui/data_grid/copy/mod.rs +++ b/linux/crates/app/src/ui/data_grid/copy/mod.rs @@ -16,6 +16,10 @@ use crate::ui::clipboard::{CopyKind, CopyRequest, InClauseRows, InsertCopy, Inse use crate::ui::export::ExportSource; use crate::ui::filter_strip::FilterVocabulary; +mod json_preview; + +pub(crate) use json_preview::{JsonPreview, JsonPreviewRequest, json_preview}; + #[cfg(test)] mod tests; 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 afab86f749..c130f37d75 100644 --- a/linux/crates/app/src/ui/data_grid/copy/tests.rs +++ b/linux/crates/app/src/ui/data_grid/copy/tests.rs @@ -217,8 +217,6 @@ fn copy_is_off_once_a_page_takes_the_selection_away() { assert!(!grid.is_enabled("copy-rows")); } -/// The rows leave as the user arranged them: a dragged column where it -/// was dropped, a hidden one left out, pending edits in. #[gtk4::test] fn copies_and_exports_follow_a_moved_and_a_hidden_column() { let grid = Grid::open(people(), people_rows()); @@ -243,6 +241,13 @@ fn copies_and_exports_follow_a_moved_and_a_hidden_column() { _ => None, }); + let preview = super::json_preview(&grid.grid).render().unwrap(); + assert_eq!((preview.shown, preview.total, preview.deleted), (2, 2, 0)); + assert_eq!( + preview.text, + "[\n{\"name\":\"Ada\",\"id\":1},\n{\"name\":\"Grace Hopper\",\"id\":2}\n]" + ); + assert_eq!(grid.grid.shown_columns(), [1, 0]); assert_eq!(rows, "name\tid\nAda\t1\nGrace Hopper\t2\n"); let (columns, rows) = exported.expect("an export of the rows"); @@ -301,6 +306,11 @@ fn copy_after_a_sort_takes_the_row_on_screen() { }); assert_eq!(text, "a"); + let preview = super::json_preview(&grid.grid).render().unwrap(); + let json: serde_json::Value = serde_json::from_str(&preview.text).unwrap(); + assert_eq!(json[0]["id"], 1); + assert_eq!(json[1]["id"], 2); + assert_eq!(json[2]["id"], 3); } /// The rule names the value the cell holds, never the text it draws: a @@ -749,6 +759,22 @@ fn the_text_copies_take_the_columns_on_screen() { assert_eq!(one_row, "1, 'Ada', 2, 'Grace'"); } +#[gtk4::test] +fn json_preview_names_rows_held_back_for_deletion() { + let values = people_rows(); + let grid = Grid::open(people(), values.clone()); + let delta = grid.tracker.apply(TrackerEdit::DeleteRows { + persisted: vec![(key(1), values[0].clone().into())], + drafts: Vec::new(), + }); + grid.grid.apply_delta(&delta); + let preview = super::json_preview(&grid.grid).render().unwrap(); + assert_eq!((preview.shown, preview.total, preview.deleted), (1, 1, 1)); + let json: serde_json::Value = serde_json::from_str(&preview.text).unwrap(); + assert_eq!(json[0]["name"], "Grace"); + assert_eq!(json.as_array().unwrap().len(), 1); +} + #[gtk4::test] fn copy_writes_several_rows_in_the_preferred_format() { use tablepro_linux_platform::settings::RowCopyFormat; diff --git a/linux/crates/app/src/ui/data_grid/mod.rs b/linux/crates/app/src/ui/data_grid/mod.rs index 09913154f6..849e5f37a9 100644 --- a/linux/crates/app/src/ui/data_grid/mod.rs +++ b/linux/crates/app/src/ui/data_grid/mod.rs @@ -51,6 +51,7 @@ use tablepro_core::dialect::SqlDialect; #[cfg(test)] pub(crate) use self::column_chooser::ColumnChooser; +pub(crate) use self::copy::{JsonPreview, JsonPreviewRequest, json_preview}; pub(crate) use self::edit::BULK_DELETE_CONFIRM_THRESHOLD; pub(crate) use self::grid_cell::GridCell; pub(crate) use self::grid_config::{DialectSource, EditRules, GridConfig, GridSorting}; diff --git a/linux/crates/app/src/ui/source_dialog.rs b/linux/crates/app/src/ui/source_dialog.rs index 7128e3392b..199c949143 100644 --- a/linux/crates/app/src/ui/source_dialog.rs +++ b/linux/crates/app/src/ui/source_dialog.rs @@ -96,7 +96,7 @@ pub(crate) fn source_dialog(text: SourceText, settings: Option<&Rc> SourceDialog { dialog, header } } -fn follow_scheme(buffer: &sourceview5::Buffer, settings: Option<&Rc>) -> Vec { +pub(crate) fn follow_scheme(buffer: &sourceview5::Buffer, settings: Option<&Rc>) -> Vec { let paint = { let buffer = buffer.downgrade(); let settings = settings.map(Rc::downgrade); diff --git a/linux/data/resources/ui/browse-tab.ui b/linux/data/resources/ui/browse-tab.ui index 15c77a89ab..2565d34386 100644 --- a/linux/data/resources/ui/browse-tab.ui +++ b/linux/data/resources/ui/browse-tab.ui @@ -28,7 +28,7 @@ - max-width: 1050sp + max-width: 1120sp false false false @@ -47,6 +47,7 @@ false true true + icons false false true @@ -59,6 +60,7 @@ data + view-grid-symbolic flat @@ -143,19 +145,30 @@ structure + false + view-list-symbolic Structure + + + json + text-x-generic-symbolic + JSON + + + + + - false view_stack labels @@ -198,9 +211,6 @@ - - - false @@ -215,6 +225,40 @@ + + + + + + + + + + false + 6 + + + edit-copy-symbolic + Copy JSON Preview + json.copy + + Copy JSON Preview + + + + + + + view-more-symbolic + More JSON Actions + + More JSON Actions + + + + + + false diff --git a/linux/docs/state-management.md b/linux/docs/state-management.md index 034fc70808..daaf8ead53 100644 --- a/linux/docs/state-management.md +++ b/linux/docs/state-management.md @@ -79,7 +79,9 @@ The closure holds only the sender, so a window that closed before the read ends A browse or structure tab is a subclass whose model sits in its `imp` struct. `send` hands the model one input and handles it at once; an input a widget signal sets off while another is being handled waits in the tab's queue until that one finishes. The model's update returns effects: more inputs for the queue, and outputs the tab emits as signals. The workspace connects those signals, tags them with the tab's id and queues them as `WorkspaceInput`, so the tabs never call each other. -A table tab owns Data and Structure pages in one `AdwViewStack`, selected by an `AdwInlineViewSwitcher` in its bottom bar. Structure is built on first selection. Data banners, filters and pending edits stay inside the Data page. Save and Refresh route from the selected page, including when focus is on the switch. Row actions are unavailable while Structure is selected. Structure lends its controls to the shared bottom bar; their model and action group stay owned by Structure. The shared bar exposes that group only on the Structure page. Compact tabs put secondary Structure commands in More. Standalone Structure tabs keep their own bar. +A table tab owns Data, Structure and JSON pages in one `AdwViewStack`, selected by an `AdwInlineViewSwitcher` in its bottom bar. Structure is built on first selection. Data banners, filters and pending edits stay inside the Data page. Save and Refresh route from the selected page, including when focus is on the switch. JSON is read-only: Refresh reads its rows, while Save and row editing actions are unavailable. JSON shares the pager and offers Filter Rows by returning to Data. Row actions are available only on Data. Structure lends its controls to the shared bottom bar; their model and action group stay owned by Structure. The shared bar exposes that group only on the Structure page. Compact tabs put secondary Structure commands in More. Standalone Structure tabs keep their own bar. + +JSON uses the row model's load presentation and refreshes after model updates, including equal-length page replacements. Its preview takes displayed row order, visible columns and pending values, excludes rows marked for deletion, and reports preview limits. Serialization runs off the GTK thread with one active render and only the latest pending snapshot. The workspace registers both trackers under the same tab id. A close considers both, with an unknown save outcome taking precedence over pending changes. A row save and a structure save cannot run together on that tab. Rename keeps the tab, its row drafts and its selection, and updates the grid and persistence keys to the new table name. diff --git a/linux/po/POTFILES.in b/linux/po/POTFILES.in index fc4d7a404a..b66eca2c65 100644 --- a/linux/po/POTFILES.in +++ b/linux/po/POTFILES.in @@ -205,6 +205,7 @@ 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 crates/app/src/ui/browse_tab/imp.rs +crates/app/src/ui/browse_tab/json_view.rs crates/app/src/ui/browse_tab/layout.rs crates/app/src/ui/browse_tab/mod.rs crates/app/src/ui/browse_tab/page_label.rs @@ -220,6 +221,7 @@ 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/json.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 @@ -259,6 +261,7 @@ crates/app/src/ui/data_grid/cell_font.rs crates/app/src/ui/data_grid/client_sorter.rs crates/app/src/ui/data_grid/column_chooser.rs crates/app/src/ui/data_grid/columns.rs +crates/app/src/ui/data_grid/copy/json_preview.rs crates/app/src/ui/data_grid/copy/mod.rs crates/app/src/ui/data_grid/copy/tests.rs crates/app/src/ui/data_grid/display_settings.rs