diff --git a/linux/changelog.d/4109.fixed.md b/linux/changelog.d/4109.fixed.md new file mode 100644 index 0000000000..8ea86f62f5 --- /dev/null +++ b/linux/changelog.d/4109.fixed.md @@ -0,0 +1 @@ +Picked editor schemes could differ from their previews and make code blocks and value placeholders hard to read. diff --git a/linux/crates/app/src/ui/assistant/code_block.rs b/linux/crates/app/src/ui/assistant/code_block.rs index 18755ba16a..da76a10681 100644 --- a/linux/crates/app/src/ui/assistant/code_block.rs +++ b/linux/crates/app/src/ui/assistant/code_block.rs @@ -8,19 +8,15 @@ use sourceview5::prelude::*; use crate::ui::handler_guard::HandlerGuard; -/// What a code block's buttons reach beyond it. #[derive(Clone)] pub(crate) struct BlockHooks { pub settings: Rc, - /// Put the code in the editor. pub insert: Rc, pub toast: Rc, } -/// One code block of a reply: highlighted as the editor is, with Copy -/// and Insert. A label rather than a text view: a text view lays its -/// text out in an idle that a running spinner can hold off, and until -/// then asks for the height of no text. +// A label measures streaming text synchronously; a text view waits for an idle +// that the running spinner can hold off. pub(crate) struct CodeBlock { root: gtk::Box, shown: Rc, @@ -28,11 +24,12 @@ pub(crate) struct CodeBlock { _theme: [HandlerGuard; 2], } -/// The code and the label that shows it, with the buffer that colours it. struct Shown { code: RefCell, label: gtk::Label, buffer: sourceview5::Buffer, + colors: gtk::CssProvider, + color_class: String, } impl CodeBlock { @@ -50,16 +47,22 @@ impl CodeBlock { .wrap(true) .wrap_mode(gtk::pango::WrapMode::WordChar) .selectable(true) - .margin_top(8) - .margin_bottom(8) - .margin_start(10) - .margin_end(10) .build(); label.add_css_class("monospace"); + let color_class = format!("code-{}", gtk::glib::uuid_string_random()); + label.add_css_class(&color_class); + let colors = gtk::CssProvider::new(); + gtk::style_context_add_provider_for_display( + &label.display(), + &colors, + gtk::STYLE_PROVIDER_PRIORITY_APPLICATION, + ); let shown = Rc::new(Shown { code: RefCell::new(code.to_owned()), label, buffer, + colors, + color_class, }); shown.paint(&hooks.settings.style_scheme()); @@ -116,7 +119,6 @@ impl CodeBlock { &self.root } - /// Show `code` in place of what the block shows, as a reply streams. pub(crate) fn set_code(&self, code: &str) { if *self.shown.code.borrow() == code { return; @@ -127,12 +129,23 @@ impl CodeBlock { } impl Shown { - /// Lay the code out in the label, coloured by the `scheme` the user - /// picked for the editor. fn paint(&self, scheme: &str) { let code = self.code.borrow(); - self.buffer - .set_style_scheme(crate::ui::style_scheme_resolver::scheme(scheme).as_ref()); + let scheme = crate::ui::style_scheme_resolver::scheme(scheme); + self.buffer.set_style_scheme(scheme.as_ref()); + let text = gtk::TextTag::new(None); + if let Some(style) = scheme.as_ref().and_then(|scheme| scheme.style("text")) { + style.apply(&text); + } + // Only parsed colors enter CSS; a scheme file cannot supply declarations. + let foreground = text.foreground_rgba().filter(|_| text.is_foreground_set()); + let background = text.background_rgba().filter(|_| text.is_background_set()); + self.colors.load_from_string(&format!( + ".{} {{ padding: 8px 10px; color: {}; background-color: {}; }}", + self.color_class, + foreground.map_or_else(|| "inherit".to_owned(), |color| color.to_string()), + background.map_or_else(|| "transparent".to_owned(), |color| color.to_string()), + )); self.buffer.set_text(&code); let (start, end) = self.buffer.bounds(); self.buffer.ensure_highlight(&start, &end); @@ -162,7 +175,12 @@ impl Shown { } } -/// What a highlighting tag sets, as text attributes. +impl Drop for Shown { + fn drop(&mut self) { + gtk::style_context_remove_provider_for_display(&self.label.display(), &self.colors); + } +} + fn tag_attributes(tag: >k::TextTag) -> Vec { let mut attributes = Vec::new(); let channels = |rgba: gtk::gdk::RGBA| { @@ -219,6 +237,82 @@ mod tests { use super::*; + fn background_pixel(label: >k::Label) -> [u8; 4] { + use gtk::gsk::prelude::*; + + crate::test_support::after_next_frame(label); + let snapshot = gtk::Snapshot::new(); + gtk::WidgetPaintable::new(Some(label)).snapshot(&snapshot, f64::from(label.width()), f64::from(label.height())); + let node = snapshot.to_node().expect("painted label"); + let renderer = gtk::gsk::CairoRenderer::new(); + renderer.realize(None::<>k::gdk::Surface>).expect("Cairo renderer"); + let texture = renderer.render_texture(&node, None); + let mut download = gtk::gdk::TextureDownloader::new(&texture); + download.set_format(gtk::gdk::MemoryFormat::R8g8b8a8); + let (bytes, _) = download.download_bytes(); + let pixel = bytes[..4].try_into().expect("one pixel"); + renderer.unrealize(); + pixel + } + + #[gtk4::test] + fn style_scheme_colors_paint_the_code_foreground_and_background_together() { + adw::init().expect("libadwaita"); + let settings = crate::test_support::MemorySettings::new(); + let block = CodeBlock::new("SELECT name FROM users;", Some("sql"), &hooks(&settings)); + let window = crate::test_support::OwnedWindow::presented( + gtk::Window::builder().child(block.widget()).default_width(400).build(), + ); + let style = adw::StyleManager::default(); + let previous = style.color_scheme(); + for id in ["Adwaita-dark", "Adwaita"] { + settings.get().set_style_scheme(id).expect("a scheme"); + for desktop in [adw::ColorScheme::ForceLight, adw::ColorScheme::ForceDark] { + style.set_color_scheme(desktop); + let scheme = block.shown.buffer.style_scheme().expect("a scheme"); + assert_eq!(scheme.id(), id); + let text = gtk::TextTag::new(None); + scheme.style("text").expect("text style").apply(&text); + let foreground = text.foreground_rgba().expect("foreground"); + let background = text.background_rgba().expect("background"); + let pixel = background_pixel(&block.shown.label); + assert_eq!(block.shown.label.color(), foreground); + let byte = |value: f32| (value * 255.0).round() as u8; + assert_eq!( + pixel, + [ + byte(background.red()), + byte(background.green()), + byte(background.blue()), + 255 + ] + ); + block.set_code("SELECT name FROM users WHERE id = 1;"); + assert_eq!(block.shown.label.text(), "SELECT name FROM users WHERE id = 1;"); + } + } + settings.get().set_style_scheme("").expect("automatic"); + style.set_color_scheme(adw::ColorScheme::ForceLight); + assert_eq!(block.shown.buffer.style_scheme().expect("scheme").id(), "Adwaita"); + style.set_color_scheme(adw::ColorScheme::ForceDark); + assert_eq!(block.shown.buffer.style_scheme().expect("scheme").id(), "Adwaita-dark"); + drop(window); + style.set_color_scheme(previous); + } + + #[gtk4::test] + fn dropping_a_code_block_releases_its_paint_and_theme_handlers() { + let settings = crate::test_support::MemorySettings::new(); + let references = Rc::weak_count(settings.get()); + let block = CodeBlock::new("plain code", Some("text"), &hooks(&settings)); + let shown = Rc::downgrade(&block.shown); + let provider = block.shown.colors.downgrade(); + drop(block); + assert!(shown.upgrade().is_none()); + assert!(provider.upgrade().is_none()); + assert_eq!(Rc::weak_count(settings.get()), references); + } + #[gtk4::test] fn insert_hands_over_the_code_as_it_now_reads() { let settings = crate::test_support::MemorySettings::new(); diff --git a/linux/crates/app/src/ui/data_grid/row_detail/tests.rs b/linux/crates/app/src/ui/data_grid/row_detail/tests.rs index 831c4f96df..f9ff679db5 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/tests.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/tests.rs @@ -6,6 +6,7 @@ use chrono::{NaiveDate, NaiveTime}; use gtk4::prelude::*; use gtk4::subclass::prelude::*; use gtk4::{self as gtk, gdk}; +use sourceview5::prelude::*; use tablepro_core::column::{TemporalZone, TimeRange}; use tablepro_core::edit::CellInput; use tablepro_core::value::{JsonText, SqlTime, Temporal}; @@ -144,6 +145,122 @@ fn column_of(info: ColumnInfo) -> GridColumn { grid_columns(&[info.result_column()], std::slice::from_ref(&info), |_| true)[0].clone() } +fn assert_value_scheme(pane: &RowDetailPane, id: &str) { + let scheme = pane.imp().value_buffer.style_scheme().expect("the value's scheme"); + assert_eq!(scheme.id(), id); + let expected = scheme.style("text").expect("the scheme text style"); + let expected = gdk::RGBA::parse(expected.foreground().expect("the scheme foreground")).expect("a scheme color"); + let attributes = pane + .imp() + .placeholder_label + .attributes() + .expect("placeholder attributes"); + let attributes = attributes.attributes(); + let color = attributes + .iter() + .find(|attribute| attribute.type_() == gtk::pango::AttrType::Foreground) + .and_then(|attribute| attribute.downcast_ref::()) + .expect("the placeholder uses the scheme foreground") + .color(); + let channel = |value: f32| (value * 65535.0).round() as u16; + assert_eq!( + (color.red(), color.green(), color.blue()), + ( + channel(expected.red()), + channel(expected.green()), + channel(expected.blue()) + ) + ); + assert!( + attributes + .iter() + .any(|attribute| { attribute == gtk::pango::AttrInt::new_style(gtk::pango::Style::Italic).upcast_ref() }) + ); + assert!(pane.imp().placeholder_label.has_css_class("dimmed")); +} + +#[gtk4::test] +fn value_scheme_and_placeholders_keep_the_exact_pick_across_desktop_changes() { + let (grid, pane) = opened( + vec![named("id", "integer", true), named("quantity", "integer", false)], + vec![vec![Value::Int(1), Value::Null], vec![Value::Int(2), Value::Int(7)]], + ); + let settings = &grid.grid.config().expect("grid settings").settings; + let style = libadwaita::StyleManager::default(); + let previous = style.color_scheme(); + for id in ["Adwaita-dark", "Adwaita"] { + settings.set_style_scheme(id).expect("a writable preference"); + for desktop in [libadwaita::ColorScheme::ForceLight, libadwaita::ColorScheme::ForceDark] { + style.set_color_scheme(desktop); + grid.focus(0, 1); + assert!(pane.imp().placeholder_label.is_visible()); + assert_eq!(pane.imp().placeholder_label.text(), "NULL"); + assert_value_scheme(&pane, id); + grid.focus(1, 1); + assert_eq!(pane.typed_text(), "7"); + assert!(!pane.imp().placeholder_label.is_visible()); + assert_value_scheme(&pane, id); + type_value(&pane, ""); + assert!(pane.imp().placeholder_label.is_visible()); + assert_value_scheme(&pane, id); + type_value(&pane, "7"); + } + } + style.set_color_scheme(previous); +} + +#[gtk4::test] +fn automatic_value_scheme_recolors_the_placeholder_with_the_desktop() { + let (grid, pane) = opened(two_text_columns(), vec![vec![Value::Int(1), Value::Null]]); + grid.grid + .config() + .expect("grid settings") + .settings + .set_style_scheme("") + .expect("the automatic preference"); + grid.focus(0, 1); + let style = libadwaita::StyleManager::default(); + let previous = style.color_scheme(); + for (desktop, expected) in [ + (libadwaita::ColorScheme::ForceLight, "Adwaita"), + (libadwaita::ColorScheme::ForceDark, "Adwaita-dark"), + ] { + style.set_color_scheme(desktop); + assert!(pane.imp().placeholder_label.is_visible()); + assert_value_scheme(&pane, expected); + } + style.set_color_scheme(previous); +} + +#[gtk4::test] +fn closed_value_editor_disconnects_scheme_and_placeholder_updates() { + let (grid, pane) = opened(two_text_columns(), vec![vec![Value::Int(1), Value::Null]]); + let settings = grid.grid.config().expect("grid settings").settings.clone(); + settings + .set_style_scheme("Adwaita-dark") + .expect("a writable preference"); + let buffer = pane.imp().value_buffer.get(); + let placeholder = pane.imp().placeholder_label.get(); + let attributes = placeholder.attributes().expect("placeholder attributes"); + let weak_pane = pane.downgrade(); + drop(pane); + drop(grid); + drain_main_context(); + assert!(weak_pane.upgrade().is_none(), "the value editor outlived its grid"); + + settings.set_style_scheme("Adwaita").expect("a writable preference"); + let style = libadwaita::StyleManager::default(); + let previous = style.color_scheme(); + style.set_color_scheme(libadwaita::ColorScheme::ForceLight); + style.set_color_scheme(libadwaita::ColorScheme::ForceDark); + assert_eq!( + buffer.style_scheme().expect("the retained buffer's scheme").id(), + "Adwaita-dark" + ); + assert_eq!(placeholder.attributes().expect("retained attributes"), attributes); + style.set_color_scheme(previous); +} + #[gtk4::test] fn the_pane_follows_the_focused_cell() { let (grid, pane) = opened(two_text_columns(), two_text_values()); diff --git a/linux/crates/app/src/ui/data_grid/row_detail/value_editor.rs b/linux/crates/app/src/ui/data_grid/row_detail/value_editor.rs index 326e4dea53..9f88684e78 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/value_editor.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/value_editor.rs @@ -22,9 +22,7 @@ use crate::ui::data_grid::{DataGrid, GridRow, PinnedRow}; use crate::ui::error_text::edit_parse_message; use crate::ui::handler_guard::HandlerGuard; -/// The scheme a grid without settings paints with, as the multi-line -/// editor did. The resolver follows it to its dark variant. -const FALLBACK_SCHEME: &str = "Adwaita"; +const FALLBACK_SCHEME: &str = ""; /// The value editor's own key handler, named so it can be told from the /// view's. @@ -501,12 +499,12 @@ impl RowDetailPane { grid.refresh_actions(); } - /// The SQL editor's scheme where the grid has the settings, in the - /// variant for the current style, following a switch of either. fn follow_style_scheme(&self, grid: &DataGrid) { let settings = grid.config().map(|config| config.settings.clone()); let paint = { let buffer = self.imp().value_buffer.get().downgrade(); + let placeholder = self.imp().placeholder_label.get().downgrade(); + let placeholder_attributes = self.imp().placeholder_label.attributes(); let settings = settings.as_ref().map(Rc::downgrade); Rc::new(move || { let Some(buffer) = buffer.upgrade() else { @@ -516,7 +514,30 @@ impl RowDetailPane { .as_ref() .and_then(Weak::upgrade) .map_or_else(|| FALLBACK_SCHEME.to_owned(), |settings| settings.style_scheme()); - buffer.set_style_scheme(crate::ui::style_scheme_resolver::scheme(&preferred).as_ref()); + let scheme = crate::ui::style_scheme_resolver::scheme(&preferred); + buffer.set_style_scheme(scheme.as_ref()); + if let Some(placeholder) = placeholder.upgrade() { + // The placeholder sits over the source view's background, so + // its text must use that scheme too, even without a value. + let attributes = placeholder_attributes + .as_ref() + .and_then(gtk::pango::AttrList::copy) + .unwrap_or_default(); + let tag = gtk::TextTag::new(None); + if let Some(text) = scheme.and_then(|scheme| scheme.style("text")) { + text.apply(&tag); + } + if let Some(rgba) = tag.foreground_rgba().filter(|_| tag.is_foreground_set()) { + let channel = |value: f32| (value.clamp(0.0, 1.0) * 65535.0).round() as u16; + attributes.insert(gtk::pango::AttrColor::new_foreground( + channel(rgba.red()), + channel(rgba.green()), + channel(rgba.blue()), + )); + attributes.insert(gtk::pango::AttrInt::new_foreground_alpha(channel(rgba.alpha()))); + } + placeholder.set_attributes(Some(&attributes)); + } }) }; paint(); diff --git a/linux/crates/app/src/ui/editor/tests.rs b/linux/crates/app/src/ui/editor/tests.rs index ce7c335ef7..7ad31d0a0f 100644 --- a/linux/crates/app/src/ui/editor/tests.rs +++ b/linux/crates/app/src/ui/editor/tests.rs @@ -1027,6 +1027,28 @@ fn scheme_id(view: &sourceview5::View) -> Option { buffer.style_scheme().map(|scheme| scheme.id().to_string()) } +#[gtk4::test] +fn style_scheme_choices_stay_exact_across_desktop_changes() { + adw::init().expect("libadwaita"); + let runtime = crate::test_support::test_runtime(); + let settings = MemorySettings::new(); + let editor = unconnected_editor(&settings, runtime.tasks()); + let view = editor.imp().source_view.get(); + let style = adw::StyleManager::default(); + for id in ["Adwaita", "Adwaita-dark", "classic", "cobalt"] { + settings.get().set_style_scheme(id).expect("a scheme"); + for appearance in [adw::ColorScheme::ForceLight, adw::ColorScheme::ForceDark] { + style.set_color_scheme(appearance); + assert_eq!(scheme_id(view.upcast_ref()).as_deref(), Some(id)); + } + } + settings.get().set_style_scheme("").expect("automatic"); + assert_eq!(scheme_id(view.upcast_ref()).as_deref(), Some("Adwaita-dark")); + style.set_color_scheme(adw::ColorScheme::ForceLight); + assert_eq!(scheme_id(view.upcast_ref()).as_deref(), Some("Adwaita")); + style.set_color_scheme(adw::ColorScheme::Default); +} + #[gtk4::test] fn closed_editor_frees_source_view() { let runtime = crate::test_support::test_runtime(); diff --git a/linux/crates/app/src/ui/preferences_dialog/editor_page.rs b/linux/crates/app/src/ui/preferences_dialog/editor_page.rs index f94bb20c18..0200533392 100644 --- a/linux/crates/app/src/ui/preferences_dialog/editor_page.rs +++ b/linux/crates/app/src/ui/preferences_dialog/editor_page.rs @@ -1,3 +1,4 @@ +use std::cell::RefCell; use std::path::PathBuf; use std::rc::Rc; use std::sync::OnceLock; @@ -15,6 +16,7 @@ use tablepro_session::runtime::Tasks; use crate::i18n::gettext; use crate::ui::file_reveal::FileRevealer; +use crate::ui::handler_guard::HandlerGuard; use crate::ui::style_scheme_grid; mod imp { @@ -34,6 +36,9 @@ mod imp { #[template_child] pub style_scheme_box: TemplateChild, #[template_child] + pub system_style_row: TemplateChild, + pub(super) scheme_handler: RefCell>, + #[template_child] pub vim_row: TemplateChild, #[template_child] pub snippets_row: TemplateChild, @@ -59,6 +64,10 @@ mod imp { } impl ObjectImpl for EditorPage { + fn dispose(&self) { + self.scheme_handler.borrow_mut().take(); + } + fn signals() -> &'static [Signal] { static SIGNALS: OnceLock> = OnceLock::new(); SIGNALS.get_or_init(|| { @@ -75,8 +84,6 @@ mod imp { } glib::wrapper! { - /// The Editor page: the font, the style scheme, Vim keybindings, the - /// snippets folder and the query timeout. pub struct EditorPage(ObjectSubclass) @extends adw::PreferencesPage, gtk4::Widget, @implements gtk4::Accessible, gtk4::Buildable, gtk4::ConstraintTarget; @@ -88,7 +95,6 @@ impl Default for EditorPage { } } -/// What the Snippets row opens, and what it opens it with. pub(super) struct SnippetsFolder { pub folder: PathBuf, pub tasks: Tasks, @@ -129,12 +135,28 @@ impl EditorPage { }) .build(); - style_scheme_grid::populate(&imp.style_scheme_box.get(), settings); + gio_settings + .bind(keys::STYLE_SCHEME, &imp.system_style_row.get(), "active") + .mapping(|variant, _| Some(variant.get::()?.is_empty().to_value())) + .set_mapping(|value, _| { + let automatic = value.get::().ok()?; + let id = if automatic { + "" + } else if adw::StyleManager::default().is_dark() { + "Adwaita-dark" + } else { + "Adwaita" + }; + Some(id.to_variant()) + }) + .build(); + imp.scheme_handler + .replace(Some(style_scheme_grid::populate(&imp.style_scheme_box.get(), settings))); self.bind_snippets(snippets); } - /// AdwPreferencesDialog owns the toast overlay, so the page hands its - /// toasts up rather than looking for one. + // AdwPreferencesDialog owns the toast overlay, so the page hands its + // toasts up rather than looking for one. pub(super) fn connect_toast(&self, f: F) -> glib::SignalHandlerId { self.connect_closure( "toast", @@ -159,7 +181,7 @@ impl EditorPage { }); } - /// The folder does not exist until the user first opens it. + // The folder does not exist until the user first opens it. fn open_snippets_folder(&self, snippets: &SnippetsFolder) { let folder = snippets.folder.clone(); let making = snippets @@ -277,6 +299,7 @@ mod tests { [ "Use the System Monospace Font", "Editor font", + "Follow System Style", "Vim Keybindings", "Snippets folder", "Query timeout (seconds)" @@ -288,6 +311,108 @@ mod tests { ); } + fn scheme_preview(page: &EditorPage, id: &str) -> sourceview5::StyleSchemePreview { + descendants(&page.imp().style_scheme_box.get()) + .into_iter() + .filter_map(|widget| widget.downcast::().ok()) + .find(|preview| preview.scheme().id() == id) + .expect("the scheme preview") + } + + fn selected_schemes(page: &EditorPage) -> Vec { + descendants(&page.imp().style_scheme_box.get()) + .into_iter() + .filter_map(|widget| widget.downcast::().ok()) + .filter(|preview| preview.is_selected()) + .map(|preview| preview.scheme().id().to_string()) + .collect() + } + + #[gtk4::test] + fn scheme_previews_save_exact_ids_on_either_desktop_style() { + adw::init().expect("libadwaita initialises"); + let style = adw::StyleManager::default(); + let previous = style.color_scheme(); + let settings = MemorySettings::new(); + let page = bound_page(&settings); + let other_page = bound_page(&settings); + assert!(page.imp().system_style_row.is_active()); + assert!(selected_schemes(&page).is_empty()); + + for (desktop, id) in [ + (adw::ColorScheme::ForceDark, "Adwaita"), + (adw::ColorScheme::ForceLight, "Adwaita-dark"), + ] { + style.set_color_scheme(desktop); + let preview = scheme_preview(&page, id); + preview.emit_by_name::<()>("activate", &[]); + assert_eq!(settings.get().style_scheme(), id); + assert!(!page.imp().system_style_row.is_active()); + assert!(!other_page.imp().system_style_row.is_active()); + assert_eq!(selected_schemes(&page), [id]); + assert_eq!(selected_schemes(&other_page), [id]); + assert_eq!( + crate::ui::style_scheme_resolver::scheme(id) + .expect("the picked scheme") + .id(), + preview.scheme().id() + ); + } + style.set_color_scheme(previous); + } + + #[gtk4::test] + fn system_style_switch_restores_automatic_and_can_keep_the_current_style() { + adw::init().expect("libadwaita initialises"); + let style = adw::StyleManager::default(); + let previous = style.color_scheme(); + let settings = MemorySettings::new(); + let page = bound_page(&settings); + let row = page.imp().system_style_row.get(); + + for (desktop, id) in [ + (adw::ColorScheme::ForceLight, "Adwaita"), + (adw::ColorScheme::ForceDark, "Adwaita-dark"), + ] { + style.set_color_scheme(desktop); + row.set_active(false); + assert_eq!(settings.get().style_scheme(), id); + assert_eq!(selected_schemes(&page), [id]); + row.set_active(true); + assert_eq!(settings.get().style_scheme(), ""); + assert!(selected_schemes(&page).is_empty()); + assert_eq!( + crate::ui::style_scheme_resolver::scheme("") + .expect("the automatic scheme") + .id(), + id + ); + } + style.set_color_scheme(previous); + } + + #[gtk4::test] + fn dropping_the_editor_page_releases_its_scheme_previews_and_handler() { + let settings = MemorySettings::new(); + let references = Rc::strong_count(settings.get()); + let page = bound_page(&settings); + let preview = scheme_preview(&page, "Adwaita"); + let weak_preview = preview.downgrade(); + let weak_page = page.downgrade(); + let retained = scheme_preview(&page, "Adwaita-dark"); + + drop(preview); + drop(page); + crate::test_support::drain_main_context(); + + assert!(weak_page.upgrade().is_none()); + assert!(weak_preview.upgrade().is_none()); + settings.get().set_style_scheme("Adwaita-dark").expect("store a scheme"); + assert!(!retained.is_selected(), "a closed page still follows settings"); + drop(retained); + assert_eq!(Rc::strong_count(settings.get()), references); + } + #[gtk4::test] fn the_font_row_is_insensitive_while_the_system_font_is_on() { let settings = MemorySettings::new(); diff --git a/linux/crates/app/src/ui/source_dialog.rs b/linux/crates/app/src/ui/source_dialog.rs index 66e2d442ab..7128e3392b 100644 --- a/linux/crates/app/src/ui/source_dialog.rs +++ b/linux/crates/app/src/ui/source_dialog.rs @@ -12,7 +12,7 @@ use crate::ui::clipboard::ClipboardPayload; use crate::ui::format::format_thousands; use crate::ui::handler_guard::HandlerGuard; -const FALLBACK_SCHEME: &str = "Adwaita"; +const FALLBACK_SCHEME: &str = ""; /// Read-only text in a source view, with Copy. What it shows may be cut /// short, since the view lays out every character it holds; Copy always @@ -37,8 +37,6 @@ pub(crate) struct SourceDialog { pub(crate) header: adw::HeaderBar, } -/// With `settings`, the text takes the SQL editor's scheme, following a -/// change of it or of the light or dark style while the dialog is open. pub(crate) fn source_dialog(text: SourceText, settings: Option<&Rc>) -> SourceDialog { let buffer = sourceview5::Buffer::new(None); if let Some(language) = sourceview5::LanguageManager::default().language(text.language) { @@ -205,8 +203,15 @@ mod tests { shown.dialog.present(Some(&*window)); assert_eq!(scheme_of(&shown.dialog).as_deref(), Some("classic")); - settings.get().gio().set_string(key, "Adwaita").expect("a writable key"); - assert_eq!(scheme_of(&shown.dialog).as_deref(), Some("Adwaita")); + let style = adw::StyleManager::default(); + for (id, appearance) in [ + ("Adwaita-dark", adw::ColorScheme::ForceLight), + ("Adwaita", adw::ColorScheme::ForceDark), + ] { + settings.get().gio().set_string(key, id).expect("a writable key"); + style.set_color_scheme(appearance); + assert_eq!(scheme_of(&shown.dialog).as_deref(), Some(id)); + } shown.dialog.force_close(); adw::StyleManager::default().set_color_scheme(adw::ColorScheme::Default); diff --git a/linux/crates/app/src/ui/structure_tab/mod.rs b/linux/crates/app/src/ui/structure_tab/mod.rs index 64ce0d586f..8b51903e37 100644 --- a/linux/crates/app/src/ui/structure_tab/mod.rs +++ b/linux/crates/app/src/ui/structure_tab/mod.rs @@ -624,13 +624,7 @@ fn replace_items>(store: &gio::ListStore, items: impl IntoI store.splice(0, store.n_items(), &items); } +// SQL in structure forms and write reviews follows the surrounding desktop controls. fn apply_sql_scheme(buffer: &sourceview5::Buffer) { - let scheme_name = if adw::StyleManager::default().is_dark() { - "Adwaita-dark" - } else { - "Adwaita" - }; - if let Some(scheme) = sourceview5::StyleSchemeManager::default().scheme(scheme_name) { - buffer.set_style_scheme(Some(&scheme)); - } + buffer.set_style_scheme(crate::ui::style_scheme_resolver::scheme("").as_ref()); } diff --git a/linux/crates/app/src/ui/structure_tab/tests.rs b/linux/crates/app/src/ui/structure_tab/tests.rs index f4779531f3..0d2ac935f8 100644 --- a/linux/crates/app/src/ui/structure_tab/tests.rs +++ b/linux/crates/app/src/ui/structure_tab/tests.rs @@ -199,6 +199,27 @@ fn sql_buffer(tab: &StructureTab) -> sourceview5::Buffer { .expect("a sourceview buffer") } +#[gtk4::test] +fn style_scheme_in_structure_and_write_reviews_follows_the_desktop() { + adw::init().expect("libadwaita"); + let style = adw::StyleManager::default(); + let harness = Harness::open(StructureMode::New, ConnectionScript::default(), []); + let dialog = adw::AlertDialog::new(None, None); + let review = super::review_dialog::sql_view("SELECT 1", &dialog); + let view = review.child().and_downcast::().expect("SQL view"); + let review_buffer = view.buffer().downcast::().expect("source buffer"); + for (appearance, id) in [ + (adw::ColorScheme::ForceLight, "Adwaita"), + (adw::ColorScheme::ForceDark, "Adwaita-dark"), + ] { + style.set_color_scheme(appearance); + assert_eq!(scheme_id(&sql_buffer(harness.tab())).as_deref(), Some(id)); + assert_eq!(scheme_id(&review_buffer).as_deref(), Some(id)); + } + crate::ui::text_view_teardown::release(&view); + style.set_color_scheme(adw::ColorScheme::Default); +} + #[gtk4::test] fn style_handler_disconnected_on_shutdown() { let style = adw::StyleManager::default(); diff --git a/linux/crates/app/src/ui/style_scheme_grid.rs b/linux/crates/app/src/ui/style_scheme_grid.rs index 06a70ec8de..d6641ae47a 100644 --- a/linux/crates/app/src/ui/style_scheme_grid.rs +++ b/linux/crates/app/src/ui/style_scheme_grid.rs @@ -4,45 +4,33 @@ use gtk4::prelude::*; use tablepro_linux_platform::AppSettings; use tablepro_linux_platform::settings::keys; -/// One preview per installed scheme. `StyleSchemePreview` is a toggle, -/// so the group behaves like a radio set: picking one writes the id and -/// clears the rest. -pub(crate) fn populate(container: >k4::FlowBox, settings: &Rc) { +use crate::ui::handler_guard::HandlerGuard; + +pub(crate) fn populate(container: >k4::FlowBox, settings: &Rc) -> HandlerGuard { let manager = sourceview5::StyleSchemeManager::default(); let selected = settings.style_scheme(); - let previews: Rc> = Rc::new( - manager - .scheme_ids() - .iter() - .filter_map(|id| manager.scheme(id)) - .map(|scheme| sourceview5::StyleSchemePreview::new(&scheme)) - .collect(), - ); - - for preview in previews.iter() { - preview.set_selected(preview.scheme().id() == selected); + let mut previews = Vec::new(); + for scheme in manager.scheme_ids().iter().filter_map(|id| manager.scheme(id)) { + let preview = sourceview5::StyleSchemePreview::new(&scheme); + preview.set_selected(scheme.id() == selected); let settings = settings.clone(); - let previews = previews.clone(); preview.connect_activate(move |activated| { - let id = activated.scheme().id(); - if let Err(error) = settings.set_style_scheme(&id) { + if let Err(error) = settings.set_style_scheme(&activated.scheme().id()) { tracing::warn!(%error, "could not save the editor style scheme"); - return; - } - for preview in previews.iter() { - preview.set_selected(preview.scheme().id() == id); } }); - container.append(preview); + previews.push(preview.downgrade()); + container.append(&preview); } - let previews_for_settings = previews.clone(); - settings + // Settings outlive Preferences; they must not keep the previews alive. + let changed = settings .gio() .connect_changed(Some(keys::STYLE_SCHEME), move |settings, key| { let id = settings.string(key); - for preview in previews_for_settings.iter() { + for preview in previews.iter().filter_map(gtk4::glib::WeakRef::upgrade) { preview.set_selected(preview.scheme().id() == id); } }); + HandlerGuard::new(settings.gio(), changed) } diff --git a/linux/crates/app/src/ui/style_scheme_resolver.rs b/linux/crates/app/src/ui/style_scheme_resolver.rs index f439779caf..64dc01a1c3 100644 --- a/linux/crates/app/src/ui/style_scheme_resolver.rs +++ b/linux/crates/app/src/ui/style_scheme_resolver.rs @@ -4,19 +4,14 @@ use sourceview5::prelude::*; const LIGHT_FALLBACK: &str = "Adwaita"; const DARK_FALLBACK: &str = "Adwaita-dark"; -/// GtkSourceView ships light and dark schemes as separate ids linked by -/// `dark-variant` and `light-variant` metadata. The user picks one id; -/// this follows the link so the editor tracks the desktop theme instead -/// of staying light on a dark desktop. +// An empty preference follows the desktop; every installed id is an exact choice. pub(crate) fn resolve_id(manager: &sourceview5::StyleSchemeManager, preferred: &str, dark: bool) -> String { - let fallback = if dark { DARK_FALLBACK } else { LIGHT_FALLBACK }; - let Some(scheme) = manager.scheme(preferred) else { - return fallback.to_owned(); - }; - let key = if dark { "dark-variant" } else { "light-variant" }; - match scheme.metadata(key) { - Some(variant) if manager.scheme(&variant).is_some() => variant.into(), - _ => preferred.to_owned(), + if manager.scheme(preferred).is_some() { + preferred.to_owned() + } else if dark { + DARK_FALLBACK.to_owned() + } else { + LIGHT_FALLBACK.to_owned() } } @@ -29,7 +24,6 @@ pub(crate) fn apply(view: &sourceview5::View, preferred: &str) { } } -/// The scheme `preferred` names, in the variant for the current style. pub(crate) fn scheme(preferred: &str) -> Option { let manager = sourceview5::StyleSchemeManager::default(); let dark = libadwaita::StyleManager::default().is_dark(); @@ -41,16 +35,27 @@ mod tests { use super::*; #[gtk4::test] - fn resolve_dark_variant() { + fn automatic_scheme_follows_the_desktop() { let manager = sourceview5::StyleSchemeManager::default(); - let dark = resolve_id(&manager, LIGHT_FALLBACK, true); - let light = resolve_id(&manager, LIGHT_FALLBACK, false); + let dark = resolve_id(&manager, "", true); + let light = resolve_id(&manager, "", false); assert_eq!(dark, DARK_FALLBACK); assert_eq!(light, LIGHT_FALLBACK); } + #[gtk4::test] + fn a_picked_scheme_is_drawn_as_picked_whatever_the_desktop() { + let manager = sourceview5::StyleSchemeManager::default(); + + for id in manager.scheme_ids() { + for dark in [false, true] { + assert_eq!(resolve_id(&manager, &id, dark), id, "desktop dark: {dark}"); + } + } + } + #[gtk4::test] fn unknown_scheme_falls_back_to_the_adwaita_pair() { let manager = sourceview5::StyleSchemeManager::default(); diff --git a/linux/crates/platform/tests/settings.rs b/linux/crates/platform/tests/settings.rs index 5e50a60ee0..b33f9f7d99 100644 --- a/linux/crates/platform/tests/settings.rs +++ b/linux/crates/platform/tests/settings.rs @@ -48,7 +48,7 @@ fn defaults_match_schema() -> TestResult { assert!(fixture.settings.show_alternate_rows()); assert_eq!(fixture.settings.history_retention_days(), 30); assert_eq!(fixture.settings.query_timeout(), Some(Duration::from_secs(60))); - assert_eq!(fixture.settings.style_scheme(), "Adwaita"); + assert_eq!(fixture.settings.style_scheme(), ""); assert_eq!(fixture.settings.csv_options(), CsvOptions::default()); assert!(fixture.settings.restore_session()); assert!(fixture.settings.save_query_history()); @@ -330,3 +330,15 @@ fn nonexistent_dir_is_schema_directory() -> TestResult { assert!(matches!(error, SettingsError::SchemaDirectory { path, .. } if path == missing)); Ok(()) } + +#[test] +fn an_explicit_adwaita_choice_is_distinct_from_the_system_default() -> TestResult { + use gio::prelude::SettingsExt; + + let fixture = Fixture::new()?; + fixture.settings.set_style_scheme("Adwaita")?; + assert_eq!(fixture.settings.style_scheme(), "Adwaita"); + fixture.settings.gio().reset(keys::STYLE_SCHEME); + assert_eq!(fixture.settings.style_scheme(), ""); + Ok(()) +} diff --git a/linux/data/app.tablepro.TablePro.gschema.xml.in b/linux/data/app.tablepro.TablePro.gschema.xml.in index 5e82ecfe29..61223f041e 100644 --- a/linux/data/app.tablepro.TablePro.gschema.xml.in +++ b/linux/data/app.tablepro.TablePro.gschema.xml.in @@ -104,9 +104,9 @@ - 'Adwaita' + '' Editor style scheme - GtkSourceView style scheme id for the SQL editor. + GtkSourceView style scheme id for the SQL editor. Empty follows the system light or dark style. diff --git a/linux/data/resources/ui/preferences-editor-page.ui b/linux/data/resources/ui/preferences-editor-page.ui index ca112c998f..e08e0b56db 100644 --- a/linux/data/resources/ui/preferences-editor-page.ui +++ b/linux/data/resources/ui/preferences-editor-page.ui @@ -32,6 +32,12 @@ Style Scheme + + + Follow System Style + Use Adwaita in the desktop’s light or dark style + + none