use ashpd::desktop::Color;
use ashpd::desktop::settings::{ColorScheme, Contrast, ReducedMotion};
use crate::model::{DialogButtonOrder, FontSpec};
const WEIGHT_MODIFIERS: &[(&str, u16)] = &[
("Ultra-Bold", 800),
("UltraBold", 800),
("Extra-Bold", 800),
("ExtraBold", 800),
("Semi-Bold", 600),
("SemiBold", 600),
("Demi-Bold", 600),
("DemiBold", 600),
("Ultra-Light", 200),
("UltraLight", 200),
("Extra-Light", 200),
("ExtraLight", 200),
("Thin", 100),
("Light", 300),
("Regular", 400),
("Normal", 400),
("Medium", 500),
("Bold", 700),
("Black", 900),
("Heavy", 900),
];
#[cfg(any(feature = "kde", test))]
pub(crate) fn portal_color_to_rgba(color: &Color) -> Option<crate::Rgba> {
let r = color.red();
let g = color.green();
let b = color.blue();
if !(0.0..=1.0).contains(&r) || !(0.0..=1.0).contains(&g) || !(0.0..=1.0).contains(&b) {
return None;
}
Some(crate::Rgba::from_f32(r as f32, g as f32, b as f32, 1.0))
}
fn apply_accent(variant: &mut crate::ThemeMode, accent: &crate::Rgba) {
variant.defaults.accent_color = Some(*accent);
variant.defaults.selection_background = Some(*accent);
variant.defaults.focus_ring_color = Some(*accent);
variant.tab.active_indicator_color = Some(*accent);
}
pub(crate) fn parse_gnome_font_to_fontspec(s: &str) -> Option<FontSpec> {
let trimmed = s.trim().trim_matches('\'');
if trimmed.is_empty() {
return None;
}
let (before_size, size_str) = trimmed.rsplit_once(' ')?;
let before_size = before_size.trim();
let size: f32 = size_str.parse().ok()?;
if before_size.is_empty() || size <= 0.0 {
return None;
}
let (family, weight) = extract_weight_from_family(before_size);
if family.is_empty() {
return None;
}
Some(FontSpec {
family: Some(family.into()),
size: Some(crate::model::font::FontSize::Pt(size)),
weight: Some(weight),
..Default::default()
})
}
fn extract_weight_from_family(s: &str) -> (&str, u16) {
for &(modifier, weight) in WEIGHT_MODIFIERS {
if let Some(prefix) = s.strip_suffix(modifier) {
let family = prefix.trim_end();
if !family.is_empty() {
return (family, weight);
}
}
}
(s, 400)
}
fn read_gsetting(schema: &str, key: &str) -> Option<String> {
let raw = crate::detect::gsettings_get(schema, key)?;
let trimmed = raw.trim_matches('\'').to_string();
if trimmed.is_empty() {
None
} else {
Some(trimmed)
}
}
fn detect_font_dpi() -> f32 {
if let Some(dpi) = crate::detect::xft_dpi() {
return dpi;
}
if let Some(dpi) = crate::detect::physical_dpi() {
return dpi;
}
96.0
}
pub struct GnomePortalData {
pub is_dark: bool,
pub accent_rgb: Option<(f64, f64, f64)>,
pub high_contrast: bool,
pub reduce_motion: Option<bool>,
pub font_name: Option<String>,
pub monospace_font_name: Option<String>,
pub titlebar_font: Option<String>,
pub text_scaling_factor: Option<f32>,
pub font_dpi: f32,
pub overlay_scrolling: Option<bool>,
pub icon_theme: Option<String>,
pub gsettings_high_contrast: Option<bool>,
pub gsettings_enable_animations: Option<bool>,
}
fn accessibility_from_gnome_data(data: &GnomePortalData) -> crate::AccessibilityPreferences {
let mut acc = crate::AccessibilityPreferences::default();
let effective_high_contrast = data.high_contrast || data.gsettings_high_contrast == Some(true);
let effective_reduce_motion = data
.reduce_motion
.or_else(|| data.gsettings_enable_animations.map(|anim| !anim));
if let Some(tsf) = data.text_scaling_factor {
acc.text_scaling_factor = tsf;
}
if let Some(rm) = effective_reduce_motion {
acc.reduce_motion = rm;
}
acc.high_contrast = effective_high_contrast;
acc
}
fn build_gnome_variant_pure(data: &GnomePortalData) -> crate::ThemeMode {
let mut variant = crate::ThemeMode::default();
if let Some((r, g, b)) = data.accent_rgb
&& (0.0..=1.0).contains(&r)
&& (0.0..=1.0).contains(&g)
&& (0.0..=1.0).contains(&b)
{
let rgba = crate::Rgba::from_f32(r as f32, g as f32, b as f32, 1.0);
apply_accent(&mut variant, &rgba);
}
if let Some(ref font_str) = data.font_name
&& let Some(fs) = parse_gnome_font_to_fontspec(font_str)
{
variant.defaults.font = fs;
}
if let Some(ref mono_str) = data.monospace_font_name
&& let Some(fs) = parse_gnome_font_to_fontspec(mono_str)
{
variant.defaults.mono_font = fs;
}
if let Some(ref tb_str) = data.titlebar_font
&& let Some(fs) = parse_gnome_font_to_fontspec(tb_str)
{
variant.window.title_bar_font = Some(fs);
}
if let Some(overlay) = data.overlay_scrolling {
variant.scrollbar.overlay_mode = Some(overlay);
}
variant.dialog.button_order = Some(DialogButtonOrder::PrimaryRight);
variant
}
#[cfg(test)]
fn build_gnome_spec_pure(data: &GnomePortalData) -> crate::Result<crate::ReaderResult> {
let base = crate::Theme::preset("adwaita")?;
let is_dark = data.is_dark;
let mut variant = if is_dark {
base.dark.unwrap_or_default()
} else {
base.light.unwrap_or_default()
};
let os_variant = build_gnome_variant_pure(data);
variant.merge(&os_variant);
let acc = accessibility_from_gnome_data(data);
variant.defaults.icon_theme = data.icon_theme.clone().map(std::borrow::Cow::Owned);
let output = crate::ReaderOutput::Single {
mode: Box::new(variant),
is_dark,
};
Ok(crate::ReaderResult {
output,
name: "GNOME".into(),
icon_set: None,
layout: crate::LayoutTheme::default(),
font_dpi: Some(data.font_dpi),
accessibility: acc,
})
}
pub(crate) fn build_gnome_variant(
scheme: ColorScheme,
accent: Option<Color>,
contrast: Contrast,
reduced_motion: Option<ReducedMotion>,
) -> (crate::ThemeMode, crate::AccessibilityPreferences, f32) {
let accent_rgb = accent.as_ref().map(|c| {
let (r, g, b) = (c.red(), c.green(), c.blue());
(r, g, b)
});
let high_contrast = matches!(contrast, Contrast::High);
let reduce_motion = reduced_motion.map(|rm| match rm {
ReducedMotion::ReducedMotion => true,
ReducedMotion::NoPreference => false,
});
let font_name = read_gsetting("org.gnome.desktop.interface", "font-name");
let monospace_font_name = read_gsetting("org.gnome.desktop.interface", "monospace-font-name");
let titlebar_font = read_gsetting("org.gnome.desktop.wm.preferences", "titlebar-font");
let text_scaling_factor = read_gsetting("org.gnome.desktop.interface", "text-scaling-factor")
.and_then(|s| s.parse::<f32>().ok());
let font_dpi = detect_font_dpi();
let gsettings_high_contrast =
read_gsetting("org.gnome.desktop.a11y.interface", "high-contrast").and_then(|s| {
match s.as_str() {
"true" => Some(true),
"false" => Some(false),
_ => None,
}
});
let gsettings_enable_animations =
read_gsetting("org.gnome.desktop.interface", "enable-animations").and_then(|s| {
match s.as_str() {
"true" => Some(true),
"false" => Some(false),
_ => None,
}
});
let overlay_scrolling = read_gsetting("org.gnome.desktop.interface", "overlay-scrolling")
.and_then(|s| match s.as_str() {
"true" => Some(true),
"false" => Some(false),
_ => None,
});
let icon_theme = read_gsetting("org.gnome.desktop.interface", "icon-theme");
let data = GnomePortalData {
is_dark: false, accent_rgb,
high_contrast,
reduce_motion,
font_name,
monospace_font_name,
titlebar_font,
text_scaling_factor,
font_dpi,
overlay_scrolling,
icon_theme,
gsettings_high_contrast,
gsettings_enable_animations,
};
let _ = scheme;
let acc = accessibility_from_gnome_data(&data);
let dpi = data.font_dpi;
(build_gnome_variant_pure(&data), acc, dpi)
}
pub(crate) fn build_theme(
base: crate::Theme,
scheme: ColorScheme,
accent: Option<Color>,
contrast: Contrast,
reduced_motion: Option<ReducedMotion>,
) -> crate::Result<crate::ReaderResult> {
let is_dark = matches!(scheme, ColorScheme::PreferDark);
let mut variant = if is_dark {
base.dark.unwrap_or_default()
} else {
base.light.unwrap_or_default()
};
let (os_variant, acc, font_dpi) = build_gnome_variant(scheme, accent, contrast, reduced_motion);
variant.merge(&os_variant);
variant.defaults.icon_theme =
read_gsetting("org.gnome.desktop.interface", "icon-theme").map(std::borrow::Cow::Owned);
let output = crate::ReaderOutput::Single {
mode: Box::new(variant),
is_dark,
};
Ok(crate::ReaderResult {
output,
name: "GNOME".into(),
icon_set: None,
layout: crate::LayoutTheme::default(),
font_dpi: Some(font_dpi),
accessibility: acc,
})
}
pub(crate) struct GnomeReader;
#[async_trait::async_trait]
impl crate::reader::ThemeReader for GnomeReader {
async fn read(&self) -> crate::Result<crate::ReaderResult> {
let base = crate::Theme::preset("adwaita")?;
let settings = match ashpd::desktop::settings::Settings::new().await {
Ok(s) => s,
Err(_) => {
return build_theme(
base,
ColorScheme::NoPreference,
None,
Contrast::NoPreference,
None,
);
}
};
let scheme = settings.color_scheme().await.unwrap_or_default();
let accent = settings.accent_color().await.ok();
let contrast = settings.contrast().await.unwrap_or_default();
let reduced_motion = settings.reduced_motion().await.ok();
build_theme(base, scheme, accent, contrast, reduced_motion)
}
}
#[cfg(feature = "kde")]
pub(crate) struct GnomePortalKdeReader;
#[cfg(feature = "kde")]
#[async_trait::async_trait]
impl crate::reader::ThemeReader for GnomePortalKdeReader {
async fn read(&self) -> crate::Result<crate::ReaderResult> {
let mut result =
<crate::kde::KdeReader as crate::reader::ThemeReader>::read(&crate::kde::KdeReader)
.await?;
let settings = match ashpd::desktop::settings::Settings::new().await {
Ok(s) => s,
Err(_) => return Ok(result),
};
let accent = match settings.accent_color().await {
Ok(color) => color,
Err(_) => return Ok(result),
};
let rgba = match portal_color_to_rgba(&accent) {
Some(r) => r,
None => return Ok(result),
};
match &mut result.output {
crate::ReaderOutput::Single { mode, .. } => {
apply_accent(mode, &rgba);
}
crate::ReaderOutput::Dual { light, dark } => {
apply_accent(light, &rgba);
apply_accent(dark, &rgba);
}
}
Ok(result)
}
}
pub(crate) async fn detect_portal_backend() -> Option<super::LinuxDesktop> {
let connection = ashpd::zbus::Connection::session().await.ok()?;
let proxy = ashpd::zbus::fdo::DBusProxy::new(&connection).await.ok()?;
let names = proxy.list_activatable_names().await.ok()?;
for name in &names {
let name_str = name.as_str();
if name_str.contains("portal.desktop.kde") {
return Some(super::LinuxDesktop::Kde);
}
if name_str.contains("portal.desktop.gnome") {
return Some(super::LinuxDesktop::Gnome);
}
}
None
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::model::font::FontSize;
#[test]
fn fontspec_bold_weight() {
let fs = parse_gnome_font_to_fontspec("Cantarell Bold 11").unwrap();
assert_eq!(fs.family.as_deref(), Some("Cantarell"));
assert_eq!(fs.size, Some(FontSize::Pt(11.0)));
assert_eq!(fs.weight, Some(700));
}
#[test]
fn fontspec_light_weight() {
let fs = parse_gnome_font_to_fontspec("Inter Light 10").unwrap();
assert_eq!(fs.family.as_deref(), Some("Inter"));
assert_eq!(fs.size, Some(FontSize::Pt(10.0)));
assert_eq!(fs.weight, Some(300));
}
#[test]
fn fontspec_semi_bold_weight() {
let fs = parse_gnome_font_to_fontspec("Noto Sans Semi-Bold 12").unwrap();
assert_eq!(fs.family.as_deref(), Some("Noto Sans"));
assert_eq!(fs.size, Some(FontSize::Pt(12.0)));
assert_eq!(fs.weight, Some(600));
}
#[test]
fn fontspec_no_modifier_defaults_to_regular() {
let fs = parse_gnome_font_to_fontspec("Cantarell 11").unwrap();
assert_eq!(fs.family.as_deref(), Some("Cantarell"));
assert_eq!(fs.size, Some(FontSize::Pt(11.0)));
assert_eq!(fs.weight, Some(400));
}
#[test]
fn fontspec_medium_weight() {
let fs = parse_gnome_font_to_fontspec("Inter Medium 10.5").unwrap();
assert_eq!(fs.family.as_deref(), Some("Inter"));
assert_eq!(fs.size, Some(FontSize::Pt(10.5)));
assert_eq!(fs.weight, Some(500));
}
#[test]
fn fontspec_heavy_weight() {
let fs = parse_gnome_font_to_fontspec("'Fira Sans Heavy 14'").unwrap();
assert_eq!(fs.family.as_deref(), Some("Fira Sans"));
assert_eq!(fs.size, Some(FontSize::Pt(14.0)));
assert_eq!(fs.weight, Some(900));
}
#[test]
fn fontspec_thin_weight() {
let fs = parse_gnome_font_to_fontspec("Roboto Thin 12").unwrap();
assert_eq!(fs.family.as_deref(), Some("Roboto"));
assert_eq!(fs.size, Some(FontSize::Pt(12.0)));
assert_eq!(fs.weight, Some(100));
}
#[test]
fn fontspec_extra_bold_weight() {
let fs = parse_gnome_font_to_fontspec("Source Sans Extra-Bold 11").unwrap();
assert_eq!(fs.family.as_deref(), Some("Source Sans"));
assert_eq!(fs.size, Some(FontSize::Pt(11.0)));
assert_eq!(fs.weight, Some(800));
}
#[test]
fn fontspec_ultra_light_weight() {
let fs = parse_gnome_font_to_fontspec("Noto Sans Ultra-Light 10").unwrap();
assert_eq!(fs.family.as_deref(), Some("Noto Sans"));
assert_eq!(fs.size, Some(FontSize::Pt(10.0)));
assert_eq!(fs.weight, Some(200));
}
#[test]
fn fontspec_empty_returns_none() {
assert!(parse_gnome_font_to_fontspec("").is_none());
}
#[test]
fn fontspec_with_quotes() {
let fs = parse_gnome_font_to_fontspec("'Cantarell Bold 11'").unwrap();
assert_eq!(fs.family.as_deref(), Some("Cantarell"));
assert_eq!(fs.weight, Some(700));
}
#[test]
fn portal_color_valid_converts_to_rgba() {
let color = Color::new(0.2, 0.4, 0.6);
let result = portal_color_to_rgba(&color);
assert!(result.is_some());
let rgba = result.unwrap();
assert_eq!(rgba, crate::Rgba::from_f32(0.2, 0.4, 0.6, 1.0));
}
#[test]
fn portal_color_out_of_range_high_returns_none() {
let color = Color::new(1.5, 0.0, 0.0);
assert!(portal_color_to_rgba(&color).is_none());
}
#[test]
fn portal_color_out_of_range_negative_returns_none() {
let color = Color::new(-0.1, 0.5, 0.5);
assert!(portal_color_to_rgba(&color).is_none());
}
#[test]
fn portal_color_to_rgba_boundary_zero() {
let color = Color::new(0.0, 0.0, 0.0);
let result = portal_color_to_rgba(&color);
assert!(result.is_some());
assert_eq!(result.unwrap(), crate::Rgba::from_f32(0.0, 0.0, 0.0, 1.0));
}
#[test]
fn portal_color_to_rgba_boundary_one() {
let color = Color::new(1.0, 1.0, 1.0);
let result = portal_color_to_rgba(&color);
assert!(result.is_some());
assert_eq!(result.unwrap(), crate::Rgba::from_f32(1.0, 1.0, 1.0, 1.0));
}
#[test]
fn build_gnome_variant_default_has_dialog_button_order() {
let (v, _acc, _dpi) = build_gnome_variant(
ColorScheme::NoPreference,
None,
Contrast::NoPreference,
None,
);
assert_eq!(v.dialog.button_order, Some(DialogButtonOrder::PrimaryRight),);
}
#[test]
fn build_gnome_variant_high_contrast_sets_flag() {
let (_v, _acc, _dpi) =
build_gnome_variant(ColorScheme::NoPreference, None, Contrast::High, None);
}
#[test]
fn build_gnome_variant_normal_contrast_no_flag() {
let (_v, _acc, _dpi) = build_gnome_variant(
ColorScheme::NoPreference,
None,
Contrast::NoPreference,
None,
);
}
#[test]
fn build_gnome_variant_accent_sets_defaults() {
let accent = Color::new(0.2, 0.4, 0.8);
let (v, _acc, _dpi) = build_gnome_variant(
ColorScheme::NoPreference,
Some(accent),
Contrast::NoPreference,
None,
);
let expected = crate::Rgba::from_f32(0.2, 0.4, 0.8, 1.0);
assert_eq!(v.defaults.accent_color, Some(expected));
assert_eq!(v.defaults.selection_background, Some(expected));
assert_eq!(v.defaults.focus_ring_color, Some(expected));
}
#[test]
fn build_gnome_variant_invalid_accent_stays_none() {
let accent = Color::new(1.5, 0.0, 0.0); let (v, _acc, _dpi) = build_gnome_variant(
ColorScheme::NoPreference,
Some(accent),
Contrast::NoPreference,
None,
);
assert!(v.defaults.accent_color.is_none());
}
fn adwaita_base() -> crate::Theme {
crate::Theme::preset("adwaita").unwrap()
}
fn reader_mode(result: &crate::ReaderResult) -> &crate::ThemeMode {
match &result.output {
crate::ReaderOutput::Single { mode, .. } => mode,
crate::ReaderOutput::Dual { light, .. } => light,
}
}
#[test]
fn dark_scheme_produces_dark_variant_only() {
let result = build_theme(
adwaita_base(),
ColorScheme::PreferDark,
None,
Contrast::NoPreference,
None,
)
.unwrap();
assert_eq!(result.name, "GNOME");
assert!(matches!(
result.output,
crate::ReaderOutput::Single { is_dark: true, .. }
));
}
#[test]
fn light_scheme_produces_light_variant_only() {
let result = build_theme(
adwaita_base(),
ColorScheme::PreferLight,
None,
Contrast::NoPreference,
None,
)
.unwrap();
assert_eq!(result.name, "GNOME");
assert!(matches!(
result.output,
crate::ReaderOutput::Single { is_dark: false, .. }
));
}
#[test]
fn no_preference_defaults_to_light() {
let result = build_theme(
adwaita_base(),
ColorScheme::NoPreference,
None,
Contrast::NoPreference,
None,
)
.unwrap();
assert_eq!(result.name, "GNOME");
assert!(matches!(
result.output,
crate::ReaderOutput::Single { is_dark: false, .. }
));
}
#[test]
fn valid_accent_propagates_to_three_fields() {
let accent = Color::new(0.2, 0.4, 0.8);
let result = build_theme(
adwaita_base(),
ColorScheme::NoPreference,
Some(accent),
Contrast::NoPreference,
None,
)
.unwrap();
let variant = reader_mode(&result);
let expected = crate::Rgba::from_f32(0.2, 0.4, 0.8, 1.0);
assert_eq!(variant.defaults.accent_color, Some(expected));
assert_eq!(variant.defaults.selection_background, Some(expected));
assert_eq!(variant.defaults.focus_ring_color, Some(expected));
}
#[test]
fn high_contrast_sets_flag_on_theme_variant() {
let result = build_theme(
adwaita_base(),
ColorScheme::NoPreference,
None,
Contrast::High,
None,
)
.unwrap();
let _variant = reader_mode(&result);
}
#[test]
fn normal_contrast_preserves_adwaita_default() {
let result = build_theme(
adwaita_base(),
ColorScheme::NoPreference,
None,
Contrast::NoPreference,
None,
)
.unwrap();
let _variant = reader_mode(&result);
}
#[test]
fn build_theme_preserves_adwaita_colors_when_no_overrides() {
let base = adwaita_base();
let base_light = base.light.as_ref().unwrap().clone();
let result = build_theme(
adwaita_base(),
ColorScheme::NoPreference,
None,
Contrast::NoPreference,
None,
)
.unwrap();
let variant = reader_mode(&result);
assert_eq!(
variant.defaults.background_color,
base_light.defaults.background_color
);
assert_eq!(variant.defaults.text_color, base_light.defaults.text_color);
}
#[test]
fn build_theme_dialog_order_set() {
let result = build_theme(
adwaita_base(),
ColorScheme::NoPreference,
None,
Contrast::NoPreference,
None,
)
.unwrap();
let variant = reader_mode(&result);
assert_eq!(
variant.dialog.button_order,
Some(DialogButtonOrder::PrimaryRight),
);
}
#[test]
fn extract_weight_bold() {
let (family, weight) = extract_weight_from_family("Cantarell Bold");
assert_eq!(family, "Cantarell");
assert_eq!(weight, 700);
}
#[test]
fn extract_weight_no_modifier() {
let (family, weight) = extract_weight_from_family("Cantarell");
assert_eq!(family, "Cantarell");
assert_eq!(weight, 400);
}
#[test]
fn extract_weight_demi_bold() {
let (family, weight) = extract_weight_from_family("Source Sans Demi-Bold");
assert_eq!(family, "Source Sans");
assert_eq!(weight, 600);
}
#[test]
fn extract_weight_black() {
let (family, weight) = extract_weight_from_family("Inter Black");
assert_eq!(family, "Inter");
assert_eq!(weight, 900);
}
fn default_gnome_data() -> GnomePortalData {
GnomePortalData {
is_dark: false,
accent_rgb: None,
high_contrast: false,
reduce_motion: None,
font_name: Some("Cantarell 11".to_string()),
monospace_font_name: Some("Source Code Pro 10".to_string()),
titlebar_font: Some("Cantarell Bold 11".to_string()),
text_scaling_factor: Some(1.0),
font_dpi: 96.0,
overlay_scrolling: Some(true),
icon_theme: Some("Adwaita".to_string()),
gsettings_high_contrast: None,
gsettings_enable_animations: None,
}
}
#[test]
fn pure_light_scheme_produces_light_variant() {
let data = default_gnome_data();
let result = build_gnome_spec_pure(&data).unwrap();
assert!(matches!(
result.output,
crate::ReaderOutput::Single { is_dark: false, .. }
));
assert_eq!(result.name, "GNOME");
}
#[test]
fn pure_dark_scheme_produces_dark_variant() {
let mut data = default_gnome_data();
data.is_dark = true;
let result = build_gnome_spec_pure(&data).unwrap();
assert!(matches!(
result.output,
crate::ReaderOutput::Single { is_dark: true, .. }
));
assert_eq!(result.name, "GNOME");
}
#[test]
fn pure_accent_color_propagates_to_three_fields() {
let mut data = default_gnome_data();
data.accent_rgb = Some((0.2, 0.4, 0.8));
let result = build_gnome_spec_pure(&data).unwrap();
let variant = reader_mode(&result);
let expected = crate::Rgba::from_f32(0.2, 0.4, 0.8, 1.0);
assert_eq!(variant.defaults.accent_color, Some(expected));
assert_eq!(variant.defaults.selection_background, Some(expected));
assert_eq!(variant.defaults.focus_ring_color, Some(expected));
}
#[test]
fn pure_high_contrast_sets_flag() {
let mut data = default_gnome_data();
data.high_contrast = true;
let result = build_gnome_spec_pure(&data).unwrap();
let _variant = reader_mode(&result);
}
#[test]
fn pure_fonts_parsed_correctly() {
let mut data = default_gnome_data();
data.font_name = Some("Inter Bold 12".to_string());
let result = build_gnome_spec_pure(&data).unwrap();
let variant = reader_mode(&result);
assert_eq!(variant.defaults.font.family.as_deref(), Some("Inter"));
assert_eq!(variant.defaults.font.weight, Some(700));
assert_eq!(variant.defaults.font.size, Some(FontSize::Pt(12.0)));
}
#[test]
fn pure_out_of_range_accent_ignored() {
let baseline_data = default_gnome_data();
let baseline_result = build_gnome_spec_pure(&baseline_data).unwrap();
let baseline_variant = reader_mode(&baseline_result);
let baseline_accent = baseline_variant.defaults.accent_color;
let mut data = default_gnome_data();
data.accent_rgb = Some((1.5, 0.0, 0.0));
let result = build_gnome_spec_pure(&data).unwrap();
let variant = reader_mode(&result);
assert_eq!(variant.defaults.accent_color, baseline_accent);
}
#[test]
fn pure_gsettings_high_contrast_fallback() {
let mut data = default_gnome_data();
data.high_contrast = false;
data.gsettings_high_contrast = Some(true);
let result = build_gnome_spec_pure(&data).unwrap();
let _variant = reader_mode(&result);
}
#[test]
fn pure_reduce_motion_from_portal() {
let mut data = default_gnome_data();
data.reduce_motion = Some(true);
let result = build_gnome_spec_pure(&data).unwrap();
let _variant = reader_mode(&result);
}
#[test]
fn pure_reduce_motion_gsettings_fallback() {
let mut data = default_gnome_data();
data.reduce_motion = None;
data.gsettings_enable_animations = Some(false);
let result = build_gnome_spec_pure(&data).unwrap();
let _variant = reader_mode(&result);
}
#[test]
fn pure_overlay_scrolling() {
let mut data = default_gnome_data();
data.overlay_scrolling = Some(false);
let result = build_gnome_spec_pure(&data).unwrap();
let variant = reader_mode(&result);
assert_eq!(variant.scrollbar.overlay_mode, Some(false));
}
#[test]
fn gnome_reader_exists() {
let r: Box<dyn crate::reader::ThemeReader> = Box::new(super::GnomeReader);
let _ = &r;
#[cfg(feature = "kde")]
{
let rp: Box<dyn crate::reader::ThemeReader> = Box::new(super::GnomePortalKdeReader);
let _ = &rp;
}
}
}