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. diff --git a/linux/crates/app/src/ui/data_grid/imp.rs b/linux/crates/app/src/ui/data_grid/imp.rs index 05bd615a8d..4c5d99c420 100644 --- a/linux/crates/app/src/ui/data_grid/imp.rs +++ b/linux/crates/app/src/ui/data_grid/imp.rs @@ -96,6 +96,7 @@ pub struct DataGrid { pub(super) display_watch: RefCell>, pub(super) applied_marks: Cell>, pub(super) applied_null: RefCell>, + pub(super) scheme_style: RefCell>, pub(super) applied_date_format: Cell>, pub(super) cell_font: RefCell>, } @@ -139,6 +140,7 @@ impl ObjectImpl for DataGrid { drop(self.font_watch.take()); drop(self.cell_font.take()); drop(self.display_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 bc8dc3507d..39f23de9e5 100644 --- a/linux/crates/app/src/ui/data_grid/mod.rs +++ b/linux/crates/app/src/ui/data_grid/mod.rs @@ -26,6 +26,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; @@ -95,6 +96,7 @@ impl DataGrid { imp.detail_pane.attach(&grid); grid.watch_display_settings(); grid.set_columns(columns, sorting, rules); + scheme_colors::follow(&grid); grid.watch_fonts(); grid } diff --git a/linux/crates/app/src/ui/data_grid/scheme_colors/mod.rs b/linux/crates/app/src/ui/data_grid/scheme_colors/mod.rs new file mode 100644 index 0000000000..2814c78e5e --- /dev/null +++ b/linux/crates/app/src/ui/data_grid/scheme_colors/mod.rs @@ -0,0 +1,207 @@ +use gtk4::prelude::*; +use gtk4::subclass::prelude::*; +use gtk4::{self as gtk, gdk, glib}; +use libadwaita as adw; +use tablepro_linux_platform::settings::keys; + +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, +} + +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); + } + Self { + background: selected_background, + foreground: selected_foreground.unwrap_or(foreground), + } + } +} + +#[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} tp-grid-cell > label.warning {{ color: inherit; }} + columnview.{class} tp-grid-cell > viewport > text {{ + background-color: var(--view-bg-color); + color: var(--view-fg-color); + }} + columnview.{class} tp-grid-cell > viewport > text selection {{ + background-color: {selected_background}; + color: {selected_foreground}; + }} + columnview.{class} tp-grid-cell > viewport > text:not(:focus) selection {{ + background-color: {unfocused_background}; + color: {unfocused_foreground}; + }} + columnview.{class} tp-grid-cell > viewport > text.error {{ + background-color: var(--error-bg-color); + color: var(--error-fg-color); + }} + columnview.{class} tp-grid-cell > viewport > text.error selection {{ + background-color: var(--error-fg-color); + color: var(--error-bg-color); + }} + }}" + ) + } +} + +fn colors(style: Option) -> (Option, Option) { + let tag = gtk::TextTag::new(None); + if let Some(style) = style { + style.apply(&tag); + } + // 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), + ) +} + +pub(super) struct SchemeStyle { + display: gdk::Display, + provider: gtk::CssProvider, + class: String, + _handlers: Vec, +} + +impl Drop for SchemeStyle { + fn drop(&mut self) { + gtk::style_context_remove_provider_for_display(&self.display, &self.provider); + } +} + +pub(super) fn follow(grid: &DataGrid) { + let Some(settings) = grid.config().map(|config| config.settings.clone()) else { + return; + }; + 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; + }; + 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; 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..20ff2e9257 --- /dev/null +++ b/linux/crates/app/src/ui/data_grid/scheme_colors/tests.rs @@ -0,0 +1,452 @@ +use std::cell::RefCell; +use std::rc::Rc; + +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"); + // Widget coordinates must not move with the render node's painted bounds. + let viewport = gtk::graphene::Rect::new(0.0, 0.0, widget.width() as f32, widget.height() as f32); + let texture = renderer.render_texture(&node, Some(&viewport)); + 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(); + after_next_frame(&view); + let row = grid + .cell_at(position, 1) + .parent() + .and_then(|cell| cell.parent()) + .expect("row"); + let filler = row.last_child().and_then(|cell| cell.first_child()).expect("filler"); + let bounds = filler.compute_bounds(&view).expect("painted filler bounds"); + assert!(bounds.width() > 0.0 && bounds.height() > 0.0); + pixel( + &view, + (bounds.x() + bounds.width() / 2.0) as i32, + (bounds.y() + bounds.height() / 2.0) as i32, + ) +} + +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 desktop = Desktop::new(); + let grid = Grid::open(two_text_columns(), two_text_values()); + let settings = &grid.grid.config().expect("settings").settings; + for appearance in [adw::ColorScheme::ForceLight, adw::ColorScheme::ForceDark] { + desktop.0.set_color_scheme(appearance); + for id in ["Adwaita-dark", "Adwaita"] { + choose(&grid, id); + let (background, foreground) = text_style(id); + settings.set_show_alternate_rows(false).expect("stripes off"); + wait_until(WAIT, || !grid.grid.column_view().has_css_class("tp-striped")).expect("stripes disabled"); + let plain = row_pixel(&grid, 1); + assert_pixel(plain, background); + settings.set_show_alternate_rows(true).expect("stripes on"); + wait_until(WAIT, || grid.grid.column_view().has_css_class("tp-striped")).expect("stripes enabled"); + let striped = row_pixel(&grid, 1); + let blend = |foreground, background| foreground * 0.04 + background * 0.96; + assert_pixel( + striped, + gdk::RGBA::new( + blend(foreground.red(), background.red()), + blend(foreground.green(), background.green()), + blend(foreground.blue(), background.blue()), + 1.0, + ), + ); + if id == "Adwaita-dark" { + assert!( + striped[0] > plain[0] && striped[1] > plain[1] && striped[2] > plain[2], + "dark rows need a light stripe: plain={plain:?}, striped={striped:?}" + ); + } + } + } + choose(&grid, "Adwaita-dark"); + 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##"