From e11c8cd198117196fe1ab39e6aa2782c6187e214 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:44:38 +0100 Subject: [PATCH 01/14] fix(linux-editor): draw the style scheme the user picked, not its light or dark twin --- .../app/src/ui/style_scheme_resolver.rs | 24 ++++++++++++++----- 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/linux/crates/app/src/ui/style_scheme_resolver.rs b/linux/crates/app/src/ui/style_scheme_resolver.rs index f439779caf..8f51b22f43 100644 --- a/linux/crates/app/src/ui/style_scheme_resolver.rs +++ b/linux/crates/app/src/ui/style_scheme_resolver.rs @@ -4,17 +4,21 @@ 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. +/// The scheme the editor draws. What the user picked is drawn as it is, +/// dark or light, as the macOS theme picker does. Only the default, +/// Adwaita, follows the desktop's style through its `dark-variant` link, +/// so an install that never chose still tracks it. Following the link +/// for every pick replaced a dark scheme chosen on a light desktop with +/// its light twin. 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) { + if preferred != LIGHT_FALLBACK { + return preferred.to_owned(); + } + match scheme.metadata("dark-variant").filter(|_| dark) { Some(variant) if manager.scheme(&variant).is_some() => variant.into(), _ => preferred.to_owned(), } @@ -51,6 +55,14 @@ mod tests { assert_eq!(light, LIGHT_FALLBACK); } + #[gtk4::test] + fn a_picked_scheme_is_drawn_as_picked_whatever_the_desktop() { + let manager = sourceview5::StyleSchemeManager::default(); + + assert_eq!(resolve_id(&manager, DARK_FALLBACK, false), DARK_FALLBACK); + assert_eq!(resolve_id(&manager, DARK_FALLBACK, true), DARK_FALLBACK); + } + #[gtk4::test] fn unknown_scheme_falls_back_to_the_adwaita_pair() { let manager = sourceview5::StyleSchemeManager::default(); From a7dd9765f8057754334a05ed6f0013c9b98c1400 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:50:45 +0100 Subject: [PATCH 02/14] docs(linux-editor): add the changelog entry --- linux/changelog.d/4109.fixed.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 linux/changelog.d/4109.fixed.md diff --git a/linux/changelog.d/4109.fixed.md b/linux/changelog.d/4109.fixed.md new file mode 100644 index 0000000000..20f8c3c533 --- /dev/null +++ b/linux/changelog.d/4109.fixed.md @@ -0,0 +1 @@ +The editor draws the style scheme picked in Preferences, not its light or dark twin. From 293e2133fb09d3e0755b713fd4bdcc23c3b2ecd4 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:15:59 +0100 Subject: [PATCH 03/14] feat(linux-grid): draw the data grid in the editor scheme's colours --- linux/crates/app/src/ui/data_grid/mod.rs | 4 + .../app/src/ui/data_grid/scheme_colors.rs | 152 ++++++++++++++++++ linux/po/POTFILES.in | 1 + 3 files changed, 157 insertions(+) create mode 100644 linux/crates/app/src/ui/data_grid/scheme_colors.rs diff --git a/linux/crates/app/src/ui/data_grid/mod.rs b/linux/crates/app/src/ui/data_grid/mod.rs index f1b2db8c4b..18183b2f0a 100644 --- a/linux/crates/app/src/ui/data_grid/mod.rs +++ b/linux/crates/app/src/ui/data_grid/mod.rs @@ -23,6 +23,7 @@ mod reversed_list; mod row_detail; mod row_json_dialog; mod row_number_column; +mod scheme_colors; mod selection; mod selection_summary; mod server_sorter; @@ -89,6 +90,9 @@ impl DataGrid { find_bar::install(&grid); imp.detail_pane.attach(&grid); grid.set_columns(columns, sorting, rules); + if let Some(settings) = grid.config().map(|config| config.settings.clone()) { + scheme_colors::follow(&settings); + } grid.watch_fonts(); grid.watch_stripes(); grid diff --git a/linux/crates/app/src/ui/data_grid/scheme_colors.rs b/linux/crates/app/src/ui/data_grid/scheme_colors.rs new file mode 100644 index 0000000000..2ca32d422b --- /dev/null +++ b/linux/crates/app/src/ui/data_grid/scheme_colors.rs @@ -0,0 +1,152 @@ +//! The data grid draws in the colours of the editor's style scheme, as the +//! macOS grid takes its theme's colours: the scheme's background and text, +//! and its selection. The default scheme, Adwaita, leaves the grid in the +//! window's own colours, which it already matches. + +use std::cell::RefCell; +use std::rc::Rc; + +use gtk4::gdk; +use gtk4::prelude::*; +use tablepro_linux_platform::AppSettings; +use tablepro_linux_platform::settings::keys; + +/// The colours a scheme gives the grid. Each is a CSS colour the scheme +/// names, or none where it says nothing. +#[derive(Debug, Default, Clone, PartialEq, Eq)] +pub(super) struct SchemeColors { + pub background: Option, + pub text: Option, + pub selection_background: Option, + pub selection_text: Option, +} + +/// The rules for `colors`, empty when the scheme says nothing. +pub(super) fn css(colors: &SchemeColors) -> String { + let mut rules = String::new(); + if colors.background.is_some() || colors.text.is_some() { + rules.push_str("columnview.data-table, columnview.data-table > listview {\n"); + if let Some(background) = &colors.background { + rules.push_str(&format!(" background-color: {background};\n")); + } + if let Some(text) = &colors.text { + rules.push_str(&format!(" color: {text};\n")); + } + rules.push_str("}\n"); + } + if colors.selection_background.is_some() || colors.selection_text.is_some() { + rules.push_str("columnview.data-table > listview > row:selected {\n"); + if let Some(background) = &colors.selection_background { + rules.push_str(&format!(" background-color: {background};\n")); + } + if let Some(text) = &colors.selection_text { + rules.push_str(&format!(" color: {text};\n")); + } + rules.push_str("}\n"); + } + rules +} + +fn colors_of(scheme: &sourceview5::StyleScheme) -> SchemeColors { + let style = |name: &str| scheme.style(name); + let background = |name: &str| { + style(name) + .filter(|style| style.is_background_set()) + .and_then(|style| style.background()) + .map(|color| color.to_string()) + }; + let foreground = |name: &str| { + style(name) + .filter(|style| style.is_foreground_set()) + .and_then(|style| style.foreground()) + .map(|color| color.to_string()) + }; + SchemeColors { + background: background("text"), + text: foreground("text"), + selection_background: background("selection"), + selection_text: foreground("selection"), + } +} + +/// The CSS for the scheme `preferred` names in the desktop's style. +fn css_for(preferred: &str) -> String { + if preferred == "Adwaita" { + return String::new(); + } + crate::ui::style_scheme_resolver::scheme(preferred) + .map(|scheme| css(&colors_of(&scheme))) + .unwrap_or_default() +} + +thread_local! { + static PROVIDER: RefCell> = const { RefCell::new(None) }; +} + +/// Make the grids follow the scheme `settings` names, now and when it or +/// the desktop's light or dark style changes. Once per process. +pub(super) fn follow(settings: &Rc) { + if PROVIDER.with(|provider| provider.borrow().is_some()) { + return; + } + let Some(display) = gdk::Display::default() else { + return; + }; + let provider = gtk4::CssProvider::new(); + // Above the app's own sheet, which sets the same selectors' colours. + gtk4::style_context_add_provider_for_display(&display, &provider, gtk4::STYLE_PROVIDER_PRIORITY_APPLICATION + 1); + PROVIDER.with(|slot| slot.replace(Some(provider.clone()))); + let refresh = { + let (settings, provider) = (settings.clone(), provider.clone()); + move || provider.load_from_string(&css_for(&settings.style_scheme())) + }; + refresh(); + // Connected before any read, so GSettings reports the key's changes. + let again = refresh.clone(); + settings + .gio() + .connect_changed(Some(keys::STYLE_SCHEME), move |_, _| again()); + let style = libadwaita::StyleManager::default(); + let again = refresh; + style.connect_dark_notify(move |_| again()); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn a_scheme_gives_the_grid_its_background_text_and_selection() { + let colors = SchemeColors { + background: Some("#1e1e1e".to_owned()), + text: Some("#d4d4d4".to_owned()), + selection_background: Some("#264f78".to_owned()), + selection_text: None, + }; + + let rules = css(&colors); + + assert!(rules.contains("background-color: #1e1e1e;")); + assert!(rules.contains("color: #d4d4d4;")); + assert!(rules.contains("row:selected {\n background-color: #264f78;")); + assert!(!rules.contains("row:selected {\n background-color: #264f78;\n color")); + } + + #[test] + fn a_scheme_that_says_nothing_leaves_the_grid_as_it_is() { + assert_eq!(css(&SchemeColors::default()), ""); + } + + #[gtk4::test] + fn the_default_scheme_changes_nothing_and_another_takes_the_grid() { + libadwaita::init().expect("libadwaita initialises under the test backend"); + assert_eq!(css_for("Adwaita"), ""); + + let rules = css_for("Adwaita-dark"); + + assert!( + rules.contains("columnview.data-table"), + "no rules for a dark scheme: {rules:?}" + ); + } +} diff --git a/linux/po/POTFILES.in b/linux/po/POTFILES.in index 23a2291ef9..4f11ee9033 100644 --- a/linux/po/POTFILES.in +++ b/linux/po/POTFILES.in @@ -289,6 +289,7 @@ crates/app/src/ui/data_grid/row_detail/tests.rs crates/app/src/ui/data_grid/row_detail/value_editor.rs crates/app/src/ui/data_grid/row_json_dialog.rs crates/app/src/ui/data_grid/row_number_column.rs +crates/app/src/ui/data_grid/scheme_colors.rs crates/app/src/ui/data_grid/selection.rs crates/app/src/ui/data_grid/selection_summary.rs crates/app/src/ui/data_grid/server_sorter.rs From d25a532c99842a868f9b66f4db93ec6737ec872c Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 20:21:45 +0700 Subject: [PATCH 04/14] fix(linux-editor): keep scheme choices and content colors consistent --- linux/changelog.d/4109.fixed.md | 2 +- .../crates/app/src/ui/assistant/code_block.rs | 128 +++++++++++++--- .../app/src/ui/data_grid/row_detail/tests.rs | 120 +++++++++++++++ .../ui/data_grid/row_detail/value_editor.rs | 33 ++++- linux/crates/app/src/ui/editor/tests.rs | 22 +++ .../src/ui/preferences_dialog/editor_page.rs | 139 +++++++++++++++++- linux/crates/app/src/ui/source_dialog.rs | 15 +- linux/crates/app/src/ui/structure_tab/mod.rs | 10 +- .../crates/app/src/ui/structure_tab/tests.rs | 21 +++ linux/crates/app/src/ui/style_scheme_grid.rs | 40 ++--- .../app/src/ui/style_scheme_resolver.rs | 37 ++--- linux/crates/platform/tests/settings.rs | 14 +- .../data/app.tablepro.TablePro.gschema.xml.in | 4 +- .../resources/ui/preferences-editor-page.ui | 6 + 14 files changed, 496 insertions(+), 95 deletions(-) diff --git a/linux/changelog.d/4109.fixed.md b/linux/changelog.d/4109.fixed.md index 20f8c3c533..8ea86f62f5 100644 --- a/linux/changelog.d/4109.fixed.md +++ b/linux/changelog.d/4109.fixed.md @@ -1 +1 @@ -The editor draws the style scheme picked in Preferences, not its light or dark twin. +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..490a947fc7 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,125 @@ 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( + two_text_columns(), + vec![ + vec![Value::Int(1), Value::Null], + vec![Value::Int(2), Value::Text("value".into())], + ], + ); + 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(), "value"); + 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, "value"); + } + } + 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..a771092a12 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 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 8f51b22f43..64dc01a1c3 100644 --- a/linux/crates/app/src/ui/style_scheme_resolver.rs +++ b/linux/crates/app/src/ui/style_scheme_resolver.rs @@ -4,23 +4,14 @@ use sourceview5::prelude::*; const LIGHT_FALLBACK: &str = "Adwaita"; const DARK_FALLBACK: &str = "Adwaita-dark"; -/// The scheme the editor draws. What the user picked is drawn as it is, -/// dark or light, as the macOS theme picker does. Only the default, -/// Adwaita, follows the desktop's style through its `dark-variant` link, -/// so an install that never chose still tracks it. Following the link -/// for every pick replaced a dark scheme chosen on a light desktop with -/// its light twin. +// 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(); - }; - if preferred != LIGHT_FALLBACK { - return preferred.to_owned(); - } - match scheme.metadata("dark-variant").filter(|_| dark) { - 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() } } @@ -33,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(); @@ -45,11 +35,11 @@ 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); @@ -59,8 +49,11 @@ mod tests { fn a_picked_scheme_is_drawn_as_picked_whatever_the_desktop() { let manager = sourceview5::StyleSchemeManager::default(); - assert_eq!(resolve_id(&manager, DARK_FALLBACK, false), DARK_FALLBACK); - assert_eq!(resolve_id(&manager, DARK_FALLBACK, true), DARK_FALLBACK); + for id in manager.scheme_ids() { + for dark in [false, true] { + assert_eq!(resolve_id(&manager, &id, dark), id, "desktop dark: {dark}"); + } + } } #[gtk4::test] 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 From a6b07ea0e4288fd428e0abbb2959f8f6b27c4370 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:22:45 +0100 Subject: [PATCH 05/14] docs(linux-grid): add the changelog entry --- linux/changelog.d/4128.added.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 linux/changelog.d/4128.added.md diff --git a/linux/changelog.d/4128.added.md b/linux/changelog.d/4128.added.md new file mode 100644 index 0000000000..8aea371700 --- /dev/null +++ b/linux/changelog.d/4128.added.md @@ -0,0 +1 @@ +The data grid draws in the colours of the editor's style scheme. From 93bd165f0e2600b3f17dace35d14e610afe7f06f Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 20:38:36 +0700 Subject: [PATCH 06/14] fix(linux-editor): scope the scheme handler and exercise numeric placeholders --- linux/crates/app/src/ui/data_grid/row_detail/tests.rs | 11 ++++------- .../app/src/ui/preferences_dialog/editor_page.rs | 2 +- 2 files changed, 5 insertions(+), 8 deletions(-) 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 490a947fc7..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 @@ -182,11 +182,8 @@ fn assert_value_scheme(pane: &RowDetailPane, id: &str) { #[gtk4::test] fn value_scheme_and_placeholders_keep_the_exact_pick_across_desktop_changes() { let (grid, pane) = opened( - two_text_columns(), - vec![ - vec![Value::Int(1), Value::Null], - vec![Value::Int(2), Value::Text("value".into())], - ], + 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(); @@ -200,13 +197,13 @@ fn value_scheme_and_placeholders_keep_the_exact_pick_across_desktop_changes() { assert_eq!(pane.imp().placeholder_label.text(), "NULL"); assert_value_scheme(&pane, id); grid.focus(1, 1); - assert_eq!(pane.typed_text(), "value"); + 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, "value"); + type_value(&pane, "7"); } } style.set_color_scheme(previous); 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 a771092a12..0200533392 100644 --- a/linux/crates/app/src/ui/preferences_dialog/editor_page.rs +++ b/linux/crates/app/src/ui/preferences_dialog/editor_page.rs @@ -37,7 +37,7 @@ mod imp { pub style_scheme_box: TemplateChild, #[template_child] pub system_style_row: TemplateChild, - pub scheme_handler: RefCell>, + pub(super) scheme_handler: RefCell>, #[template_child] pub vim_row: TemplateChild, #[template_child] From cf1d384bd9c09fa4aca8e79534a6165d85fc5bb4 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 00:09:41 +0700 Subject: [PATCH 07/14] fix(linux-grid): keep scheme colors readable and scoped to each grid --- linux/crates/app/src/ui/data_grid/imp.rs | 2 + linux/crates/app/src/ui/data_grid/mod.rs | 4 +- .../app/src/ui/data_grid/scheme_colors.rs | 309 ++++++++------ .../src/ui/data_grid/scheme_colors/tests.rs | 394 ++++++++++++++++++ linux/po/POTFILES.in | 1 + 5 files changed, 580 insertions(+), 130 deletions(-) create mode 100644 linux/crates/app/src/ui/data_grid/scheme_colors/tests.rs diff --git a/linux/crates/app/src/ui/data_grid/imp.rs b/linux/crates/app/src/ui/data_grid/imp.rs index 1b043907fd..17411e77a3 100644 --- a/linux/crates/app/src/ui/data_grid/imp.rs +++ b/linux/crates/app/src/ui/data_grid/imp.rs @@ -88,6 +88,7 @@ pub struct DataGrid { pub focus_watch: RefCell, glib::SignalHandlerId)>>, pub(super) font_watch: RefCell>, pub(super) stripes_watch: RefCell>, + pub(super) scheme_style: RefCell>, } #[glib::object_subclass] @@ -126,6 +127,7 @@ impl ObjectImpl for DataGrid { self.summary.stop(); self.obj().stop_watching_focus(); drop(self.font_watch.take()); + drop(self.scheme_style.take()); if let Some(menus) = self.menus.get() { menus.unparent(); } diff --git a/linux/crates/app/src/ui/data_grid/mod.rs b/linux/crates/app/src/ui/data_grid/mod.rs index 18183b2f0a..03a7d32705 100644 --- a/linux/crates/app/src/ui/data_grid/mod.rs +++ b/linux/crates/app/src/ui/data_grid/mod.rs @@ -90,9 +90,7 @@ impl DataGrid { find_bar::install(&grid); imp.detail_pane.attach(&grid); grid.set_columns(columns, sorting, rules); - if let Some(settings) = grid.config().map(|config| config.settings.clone()) { - scheme_colors::follow(&settings); - } + scheme_colors::follow(&grid); grid.watch_fonts(); grid.watch_stripes(); grid diff --git a/linux/crates/app/src/ui/data_grid/scheme_colors.rs b/linux/crates/app/src/ui/data_grid/scheme_colors.rs index 2ca32d422b..ffeaaa7aba 100644 --- a/linux/crates/app/src/ui/data_grid/scheme_colors.rs +++ b/linux/crates/app/src/ui/data_grid/scheme_colors.rs @@ -1,152 +1,207 @@ -//! The data grid draws in the colours of the editor's style scheme, as the -//! macOS grid takes its theme's colours: the scheme's background and text, -//! and its selection. The default scheme, Adwaita, leaves the grid in the -//! window's own colours, which it already matches. - -use std::cell::RefCell; -use std::rc::Rc; - -use gtk4::gdk; use gtk4::prelude::*; -use tablepro_linux_platform::AppSettings; +use gtk4::subclass::prelude::*; +use gtk4::{self as gtk, gdk, glib}; +use libadwaita as adw; use tablepro_linux_platform::settings::keys; -/// The colours a scheme gives the grid. Each is a CSS colour the scheme -/// names, or none where it says nothing. -#[derive(Debug, Default, Clone, PartialEq, Eq)] -pub(super) struct SchemeColors { - pub background: Option, - pub text: Option, - pub selection_background: Option, - pub selection_text: Option, +use super::DataGrid; +use crate::ui::handler_guard::HandlerGuard; +use crate::ui::style_scheme_resolver; + +#[derive(Debug, Clone)] +struct SelectionColors { + background: gdk::RGBA, + foreground: gdk::RGBA, } -/// The rules for `colors`, empty when the scheme says nothing. -pub(super) fn css(colors: &SchemeColors) -> String { - let mut rules = String::new(); - if colors.background.is_some() || colors.text.is_some() { - rules.push_str("columnview.data-table, columnview.data-table > listview {\n"); - if let Some(background) = &colors.background { - rules.push_str(&format!(" background-color: {background};\n")); - } - if let Some(text) = &colors.text { - rules.push_str(&format!(" color: {text};\n")); - } - rules.push_str("}\n"); - } - if colors.selection_background.is_some() || colors.selection_text.is_some() { - rules.push_str("columnview.data-table > listview > row:selected {\n"); - if let Some(background) = &colors.selection_background { - rules.push_str(&format!(" background-color: {background};\n")); +impl SelectionColors { + fn from_style(style: Option, background: gdk::RGBA, foreground: gdk::RGBA) -> Self { + let (selected_background, selected_foreground) = colors(style); + let Some(mut selected_background) = selected_background else { + return Self { + background: foreground, + foreground: background, + }; + }; + // GtkSourceView's fix_broken_selection keeps unchanged text readable + // over a selection that supplies only an opaque background. + if selected_foreground.is_none() && selected_background.alpha() >= 1.0 { + selected_background.set_alpha(0.3); } - if let Some(text) = &colors.selection_text { - rules.push_str(&format!(" color: {text};\n")); + Self { + background: selected_background, + foreground: selected_foreground.unwrap_or(foreground), } - rules.push_str("}\n"); } - rules } -fn colors_of(scheme: &sourceview5::StyleScheme) -> SchemeColors { - let style = |name: &str| scheme.style(name); - let background = |name: &str| { - style(name) - .filter(|style| style.is_background_set()) - .and_then(|style| style.background()) - .map(|color| color.to_string()) - }; - let foreground = |name: &str| { - style(name) - .filter(|style| style.is_foreground_set()) - .and_then(|style| style.foreground()) - .map(|color| color.to_string()) - }; - SchemeColors { - background: background("text"), - text: foreground("text"), - selection_background: background("selection"), - selection_text: foreground("selection"), +#[derive(Debug, Clone)] +struct Palette { + background: gdk::RGBA, + foreground: gdk::RGBA, + selection: SelectionColors, + unfocused_selection: SelectionColors, +} + +impl Palette { + fn from_scheme(scheme: &sourceview5::StyleScheme) -> Option { + let (background, foreground) = colors(scheme.style("text")); + // A partial pair could put scheme text on the opposite desktop color. + let (background, foreground) = (background?, foreground?); + let selection = scheme.style("selection"); + let unfocused = scheme.style("selection-unfocused").or_else(|| selection.clone()); + Some(Self { + background, + foreground, + selection: SelectionColors::from_style(selection, background, foreground), + unfocused_selection: SelectionColors::from_style(unfocused, background, foreground), + }) + } + + fn css(&self, class: &str) -> String { + let Self { + background, + foreground, + selection, + unfocused_selection, + } = self; + let (selected_background, selected_foreground) = (&selection.background, &selection.foreground); + let (unfocused_background, unfocused_foreground) = + (&unfocused_selection.background, &unfocused_selection.foreground); + // Native high-contrast styling takes precedence over a saved palette. + format!( + "@media (prefers-contrast: no-preference) {{ + .{class} {{ + --view-bg-color: {background}; + --view-fg-color: {foreground}; + --accent-color: currentColor; + color: var(--view-fg-color); + }} + columnview.{class} {{ background-color: var(--view-bg-color); }} + columnview.{class} > listview > row:selected {{ + background-color: {selected_background}; + color: {selected_foreground}; + }} + columnview.{class}:not(:focus-within) > listview > row:selected {{ + background-color: {unfocused_background}; + color: {unfocused_foreground}; + }} + columnview.{class} inscription.warning {{ color: inherit; }} + columnview.{class} tp-grid-cell > text {{ + background-color: var(--view-bg-color); + color: var(--view-fg-color); + }} + columnview.{class} tp-grid-cell > text selection {{ + background-color: {selected_background}; + color: {selected_foreground}; + }} + columnview.{class} tp-grid-cell > text:not(:focus) selection {{ + background-color: {unfocused_background}; + color: {unfocused_foreground}; + }} + columnview.{class} tp-grid-cell > text.error {{ + background-color: var(--error-bg-color); + color: var(--error-fg-color); + }} + columnview.{class} tp-grid-cell > text.error selection {{ + background-color: var(--error-fg-color); + color: var(--error-bg-color); + }} + }}" + ) } } -/// The CSS for the scheme `preferred` names in the desktop's style. -fn css_for(preferred: &str) -> String { - if preferred == "Adwaita" { - return String::new(); +fn colors(style: Option) -> (Option, Option) { + let tag = gtk::TextTag::new(None); + if let Some(style) = style { + style.apply(&tag); } - crate::ui::style_scheme_resolver::scheme(preferred) - .map(|scheme| css(&colors_of(&scheme))) - .unwrap_or_default() + // Transparent selection foregrounds tell GtkSourceView to keep syntax + // colors; CSS text needs an actual foreground instead. + let visible = |color: &gdk::RGBA| color.alpha() > 0.0; + ( + tag.background_rgba().filter(visible), + tag.foreground_rgba().filter(visible), + ) } -thread_local! { - static PROVIDER: RefCell> = const { RefCell::new(None) }; +pub(super) struct SchemeStyle { + display: gdk::Display, + provider: gtk::CssProvider, + class: String, + _handlers: Vec, } -/// Make the grids follow the scheme `settings` names, now and when it or -/// the desktop's light or dark style changes. Once per process. -pub(super) fn follow(settings: &Rc) { - if PROVIDER.with(|provider| provider.borrow().is_some()) { - return; +impl Drop for SchemeStyle { + fn drop(&mut self) { + gtk::style_context_remove_provider_for_display(&self.display, &self.provider); } - let Some(display) = gdk::Display::default() else { +} + +pub(super) fn follow(grid: &DataGrid) { + let Some(settings) = grid.config().map(|config| config.settings.clone()) else { return; }; - let provider = gtk4::CssProvider::new(); - // Above the app's own sheet, which sets the same selectors' colours. - gtk4::style_context_add_provider_for_display(&display, &provider, gtk4::STYLE_PROVIDER_PRIORITY_APPLICATION + 1); - PROVIDER.with(|slot| slot.replace(Some(provider.clone()))); - let refresh = { - let (settings, provider) = (settings.clone(), provider.clone()); - move || provider.load_from_string(&css_for(&settings.style_scheme())) + let display = grid.display(); + let provider = gtk::CssProvider::new(); + let class = format!("tp-grid-scheme-{}", uuid::Uuid::new_v4().simple()); + grid.column_view().add_css_class(&class); + grid.imp().empty_page.add_css_class(&class); + gtk::style_context_add_provider_for_display(&display, &provider, gtk::STYLE_PROVIDER_PRIORITY_APPLICATION + 1); + + // GSettings emits changes only after a read while a handler is connected. + let setting_handler = settings.gio().connect_changed( + Some(keys::STYLE_SCHEME), + glib::clone!( + #[weak] + grid, + move |_, _| refresh(&grid) + ), + ); + let style = adw::StyleManager::default(); + let dark_handler = style.connect_dark_notify(glib::clone!( + #[weak] + grid, + move |_| refresh(&grid) + )); + let contrast_handler = style.connect_high_contrast_notify(glib::clone!( + #[weak] + grid, + move |_| refresh(&grid) + )); + grid.imp().scheme_style.replace(Some(SchemeStyle { + display, + provider, + class, + _handlers: vec![ + HandlerGuard::new(settings.gio(), setting_handler), + HandlerGuard::new(&style, dark_handler), + HandlerGuard::new(&style, contrast_handler), + ], + })); + refresh(grid); +} + +fn refresh(grid: &DataGrid) { + let binding = grid.imp().scheme_style.borrow(); + let (Some(binding), Some(config)) = (binding.as_ref(), grid.config()) else { + return; }; - refresh(); - // Connected before any read, so GSettings reports the key's changes. - let again = refresh.clone(); - settings - .gio() - .connect_changed(Some(keys::STYLE_SCHEME), move |_, _| again()); - let style = libadwaita::StyleManager::default(); - let again = refresh; - style.connect_dark_notify(move |_| again()); + binding + .provider + .set_prefers_contrast(if adw::StyleManager::default().is_high_contrast() { + gtk::InterfaceContrast::More + } else { + gtk::InterfaceContrast::NoPreference + }); + let css = style_scheme_resolver::scheme(&config.settings.style_scheme()) + .as_ref() + .and_then(Palette::from_scheme) + .map(|palette| palette.css(&binding.class)) + .unwrap_or_default(); + binding.provider.load_from_string(&css); } #[cfg(test)] -mod tests { - use super::*; - - #[test] - fn a_scheme_gives_the_grid_its_background_text_and_selection() { - let colors = SchemeColors { - background: Some("#1e1e1e".to_owned()), - text: Some("#d4d4d4".to_owned()), - selection_background: Some("#264f78".to_owned()), - selection_text: None, - }; - - let rules = css(&colors); - - assert!(rules.contains("background-color: #1e1e1e;")); - assert!(rules.contains("color: #d4d4d4;")); - assert!(rules.contains("row:selected {\n background-color: #264f78;")); - assert!(!rules.contains("row:selected {\n background-color: #264f78;\n color")); - } - - #[test] - fn a_scheme_that_says_nothing_leaves_the_grid_as_it_is() { - assert_eq!(css(&SchemeColors::default()), ""); - } - - #[gtk4::test] - fn the_default_scheme_changes_nothing_and_another_takes_the_grid() { - libadwaita::init().expect("libadwaita initialises under the test backend"); - assert_eq!(css_for("Adwaita"), ""); - - let rules = css_for("Adwaita-dark"); - - assert!( - rules.contains("columnview.data-table"), - "no rules for a dark scheme: {rules:?}" - ); - } -} +mod tests; diff --git a/linux/crates/app/src/ui/data_grid/scheme_colors/tests.rs b/linux/crates/app/src/ui/data_grid/scheme_colors/tests.rs new file mode 100644 index 0000000000..05522a71af --- /dev/null +++ b/linux/crates/app/src/ui/data_grid/scheme_colors/tests.rs @@ -0,0 +1,394 @@ +use std::cell::RefCell; +use std::rc::Rc; + +use gtk4::gsk::prelude::*; +use tablepro_core::Value; + +use super::*; +use crate::test_support::{OwnedWindow, after_next_frame, drain_main_context, drop_focus, wait_until}; +use crate::ui::data_grid::GridRequest; +use crate::ui::data_grid::test_grid::{Grid, GridSpec, WAIT, named, results, two_text_columns, two_text_values}; + +struct Desktop(adw::StyleManager, adw::ColorScheme); + +impl Desktop { + fn new() -> Self { + adw::init().expect("libadwaita"); + let style = adw::StyleManager::default(); + let previous = style.color_scheme(); + Self(style, previous) + } +} + +impl Drop for Desktop { + fn drop(&mut self) { + self.0.set_color_scheme(self.1); + } +} + +fn choose(grid: &Grid, id: &str) { + grid.grid + .config() + .expect("grid settings") + .settings + .set_style_scheme(id) + .expect("scheme saved"); + after_next_frame(&grid.grid); +} + +fn text_style(id: &str) -> (gdk::RGBA, gdk::RGBA) { + let scheme = sourceview5::StyleSchemeManager::default() + .scheme(id) + .expect("installed scheme"); + let tag = gtk::TextTag::new(None); + scheme.style("text").expect("text style").apply(&tag); + ( + tag.background_rgba().expect("background"), + tag.foreground_rgba().expect("foreground"), + ) +} + +fn pixel(widget: &impl IsA, x: i32, y: i32) -> [u8; 4] { + let widget = widget.as_ref(); + after_next_frame(widget); + let snapshot = gtk::Snapshot::new(); + gtk::WidgetPaintable::new(Some(widget)).snapshot(&snapshot, f64::from(widget.width()), f64::from(widget.height())); + let node = snapshot.to_node().expect("painted widget"); + let renderer = gtk::gsk::CairoRenderer::new(); + renderer.realize(None::<&gdk::Surface>).expect("Cairo renderer"); + let texture = renderer.render_texture(&node, None); + let mut download = gdk::TextureDownloader::new(&texture); + download.set_format(gdk::MemoryFormat::R8g8b8a8); + let (bytes, stride) = download.download_bytes(); + let offset = y as usize * stride + x as usize * 4; + let result = bytes[offset..offset + 4].try_into().expect("a pixel"); + renderer.unrealize(); + result +} + +fn assert_pixel(actual: [u8; 4], expected: gdk::RGBA) { + let channels = [expected.red(), expected.green(), expected.blue(), expected.alpha()]; + for (actual, expected) in actual.into_iter().zip(channels) { + assert!( + (f32::from(actual) - expected * 255.0).abs() <= 2.0, + "{actual} != {expected}" + ); + } +} + +fn base_pixel(grid: &Grid) -> [u8; 4] { + let view = grid.grid.column_view(); + pixel(&view, view.width() - 10, view.height() - 10) +} + +fn row_pixel(grid: &Grid, position: u32) -> [u8; 4] { + let view = grid.grid.column_view(); + let bounds = grid.cell_at(position, 1).compute_bounds(&view).expect("cell bounds"); + pixel(&view, view.width() - 10, bounds.y() as i32 + 4) +} + +fn custom_scheme(styles: &str) -> sourceview5::StyleScheme { + let dir = tempfile::tempdir().expect("scheme directory"); + std::fs::write( + dir.path().join("grid.xml"), + format!(r#"{styles}"#), + ).expect("scheme written"); + let manager = sourceview5::StyleSchemeManager::new(); + manager.set_search_path(&[dir.path().to_str().expect("path")]); + manager.scheme("grid-test").expect("custom scheme") +} + +fn install_palette(grid: &Grid, palette: &Palette) { + let binding = grid.grid.imp().scheme_style.borrow(); + let binding = binding.as_ref().expect("grid style"); + binding.provider.load_from_string(&palette.css(&binding.class)); +} + +#[gtk4::test] +fn picked_schemes_paint_the_same_grid_colors_on_both_desktops_and_reset_live() { + let desktop = Desktop::new(); + let grid = Grid::open(two_text_columns(), two_text_values()); + for id in ["Adwaita", "Adwaita-dark", "solarized-light"] { + choose(&grid, id); + let (background, foreground) = text_style(id); + for appearance in [adw::ColorScheme::ForceLight, adw::ColorScheme::ForceDark] { + desktop.0.set_color_scheme(appearance); + assert_pixel(base_pixel(&grid), background); + assert_eq!(grid.cell_at(0, 1).display().expect("text").color(), foreground); + assert_eq!( + grid.grid.column_view().first_child().expect("header").color(), + foreground + ); + } + } + choose(&grid, ""); + for (appearance, id) in [ + (adw::ColorScheme::ForceLight, "Adwaita"), + (adw::ColorScheme::ForceDark, "Adwaita-dark"), + ] { + desktop.0.set_color_scheme(appearance); + let (background, foreground) = text_style(id); + assert_pixel(base_pixel(&grid), background); + assert_eq!(grid.cell_at(0, 1).display().expect("text").color(), foreground); + } +} + +#[gtk4::test] +fn installed_schemes_with_transparent_selection_text_keep_selected_values_visible() { + let grid = Grid::open(two_text_columns(), two_text_values()); + for id in ["cobalt", "oblivion", "kate", "solarized-light", "solarized-dark"] { + let scheme = sourceview5::StyleSchemeManager::default() + .scheme(id) + .expect("installed scheme"); + let tag = gtk::TextTag::new(None); + scheme.style("selection").expect("selection").apply(&tag); + assert!( + tag.foreground_rgba().is_none_or(|color| color.alpha() == 0.0), + "{id} fixture changed" + ); + choose(&grid, id); + grid.focus(0, 1); + grid.grid.selection().select_item(0, true); + after_next_frame(&grid.grid); + let foreground = text_style(id).1; + assert_eq!(grid.cell_at(0, 1).display().expect("text").color(), foreground, "{id}"); + assert_ne!( + row_pixel(&grid, 0), + base_pixel(&grid), + "{id} lost its selection background" + ); + } +} + +#[gtk4::test] +fn independent_grids_follow_their_settings_and_release_their_styles() { + let first = Grid::open(two_text_columns(), two_text_values()); + let second = Grid::open(two_text_columns(), two_text_values()); + choose(&first, "Adwaita-dark"); + choose(&second, "Adwaita"); + assert_pixel(base_pixel(&first), text_style("Adwaita-dark").0); + assert_pixel(base_pixel(&second), text_style("Adwaita").0); + choose(&first, "solarized-light"); + assert_pixel(base_pixel(&first), text_style("solarized-light").0); + assert_pixel(base_pixel(&second), text_style("Adwaita").0); + let settings = first.grid.config().expect("settings").settings.clone(); + let grid = first.grid.downgrade(); + let provider = first + .grid + .imp() + .scheme_style + .borrow() + .as_ref() + .expect("style") + .provider + .downgrade(); + drop_focus(&first.window); + drop(first); + drain_main_context(); + assert!(grid.upgrade().is_none(), "settings retained the grid"); + assert!(provider.upgrade().is_none(), "display retained the scoped provider"); + settings + .set_style_scheme("Adwaita-dark") + .expect("old settings remain usable"); + assert_pixel(base_pixel(&second), text_style("Adwaita").0); +} + +#[gtk4::test] +fn empty_grid_text_and_stripes_follow_the_grid_foreground() { + let grid = Grid::open(two_text_columns(), two_text_values()); + choose(&grid, "Adwaita-dark"); + let settings = &grid.grid.config().expect("settings").settings; + settings.set_show_alternate_rows(false).expect("stripes off"); + let plain = row_pixel(&grid, 1); + settings.set_show_alternate_rows(true).expect("stripes on"); + let striped = row_pixel(&grid, 1); + assert!( + striped[0] > plain[0] && striped[1] > plain[1] && striped[2] > plain[2], + "dark rows need a light stripe" + ); + grid.grid.clear_rows(); + after_next_frame(&grid.grid); + assert!(grid.grid.imp().empty_page.is_visible()); + assert_eq!(grid.grid.imp().empty_page.color(), text_style("Adwaita-dark").1); +} + +#[gtk4::test] +fn an_opaque_selection_without_text_keeps_the_native_translucent_fallback() { + let scheme = custom_scheme( + r##"