#![warn(missing_docs)]
#![deny(unsafe_code)]
#![deny(clippy::unwrap_used)]
#![deny(clippy::expect_used)]
#[doc = include_str!("../README.md")]
#[cfg(doctest)]
pub struct ReadmeDoctests;
macro_rules! impl_merge {
(
$struct_name:ident {
$(option { $($opt_field:ident),* $(,)? })?
$(nested { $($nest_field:ident),* $(,)? })?
$(optional_nested { $($on_field:ident),* $(,)? })*
}
) => {
impl $struct_name {
pub fn merge(&mut self, overlay: &Self) {
$($(
if overlay.$opt_field.is_some() {
self.$opt_field = overlay.$opt_field.clone();
}
)*)?
$($(
self.$nest_field.merge(&overlay.$nest_field);
)*)?
$($(
match (&mut self.$on_field, &overlay.$on_field) {
(Some(base), Some(over)) => base.merge(over),
(None, Some(over)) => self.$on_field = Some(over.clone()),
_ => {}
}
)*)*
}
pub fn is_empty(&self) -> bool {
true
$($(&& self.$opt_field.is_none())*)?
$($(&& self.$nest_field.is_empty())*)?
$($(&& self.$on_field.as_ref().map_or(true, |v| v.is_empty()))*)*
}
}
};
}
pub mod color;
pub mod detect;
pub mod error;
pub mod fonts;
#[cfg(all(target_os = "linux", feature = "portal"))]
pub(crate) mod gnome;
pub mod icons;
#[cfg(all(target_os = "linux", feature = "kde"))]
pub mod kde;
#[path = "kde/metrics.rs"]
pub(crate) mod kde_metrics;
mod model;
pub mod pipeline;
pub mod presets;
mod reader;
pub mod resolve;
#[cfg(any(
feature = "material-icons",
feature = "lucide-icons",
feature = "system-icons"
))]
mod spinners;
#[cfg(feature = "watch")]
pub mod watch;
pub mod prelude;
pub mod theme {
pub use crate::model::widgets::*;
pub use crate::model::{
ArrowSide, ColorMode, DefaultsBorderSpec, DialogButtonOrder, DialogEntranceStyle, FontSize,
FontSpec, FontStyle, IconSet, IconSizes, Resolved, ResolvedDefaults,
ResolvedDefaultsBorder, ResolvedFontSpec, ResolvedIconSizes, ResolvedPadding,
ResolvedTextScale, ResolvedTextScaleEntry, ResolvedTheme, ResolvedWidgetBorder,
TabIndicatorSide, TextScale, TextScaleEntry, Theme, ThemeDefaults, ThemeMode,
WidgetBorderSpec, intern_font_family,
};
pub use crate::presets::PresetInfo;
}
#[cfg(all(target_os = "linux", feature = "system-icons"))]
pub(crate) mod freedesktop;
pub(crate) mod macos;
#[cfg(feature = "svg-rasterize")]
pub mod rasterize;
#[cfg(all(target_os = "macos", feature = "system-icons"))]
pub(crate) mod sficons;
#[cfg(target_os = "windows")]
#[cfg_attr(not(feature = "windows"), allow(dead_code))]
pub(crate) mod windows;
#[cfg(not(target_os = "windows"))]
#[allow(dead_code, unused_variables)]
pub(crate) mod windows;
#[cfg(all(target_os = "windows", feature = "system-icons"))]
pub(crate) mod winicons;
#[cfg(all(not(target_os = "windows"), feature = "system-icons"))]
#[allow(dead_code, unused_imports)]
pub(crate) mod winicons;
use std::borrow::Cow;
pub type Result<T> = std::result::Result<T, error::Error>;
#[allow(unused_imports)]
pub(crate) use color::ParseColorError;
pub use color::Rgba;
#[cfg(target_os = "linux")]
#[allow(unused_imports)]
pub(crate) use detect::LinuxDesktop;
#[cfg(target_os = "linux")]
#[allow(unused_imports)]
pub(crate) use detect::detect_linux_desktop;
#[allow(unused_imports)]
pub(crate) use detect::{detect_icon_theme, system_icon_set, system_icon_theme};
#[allow(unused_imports)]
pub(crate) use detect::{
detect_is_dark, detect_reduced_motion, invalidate_caches, prefers_reduced_motion,
system_is_dark,
};
pub use error::Error;
#[allow(unused_imports)]
pub(crate) use error::{ErrorKind, RangeViolation};
#[allow(unused_imports)]
pub(crate) use icons::{
FreedesktopLoader, IconId, LucideLoader, MaterialLoader, SegoeFluentLoader, SfSymbolsLoader,
is_freedesktop_theme_available, load_icon, load_icon_indicator,
};
#[allow(unused_imports)]
pub(crate) use model::icons::icon_name;
#[allow(unused_imports)]
pub(crate) use model::{
AnimatedIcon, ButtonTheme, CardTheme, CheckboxTheme, ComboBoxTheme, DefaultsBorderSpec,
DialogButtonOrder, DialogTheme, ExpanderTheme, FontSize, FontSpec, FontStyle, IconData,
IconProvider, IconRole, IconSet, IconSizes, InputTheme, LayoutTheme, LinkTheme, ListTheme,
MenuTheme, PopoverTheme, ProgressBarTheme, ResolvedDefaults, ResolvedDefaultsBorder,
ResolvedFontSpec, ResolvedIconSizes, ResolvedPadding, ResolvedTextScale,
ResolvedTextScaleEntry, ResolvedWidgetBorder, ScrollbarTheme, SegmentedControlTheme,
SeparatorTheme, SidebarTheme, SliderTheme, SpinnerTheme, SplitterTheme, StatusBarTheme,
SwitchTheme, TabTheme, TextScale, TextScaleEntry, ThemeDefaults, ThemeMode, ToolbarTheme,
TooltipTheme, TransformAnimation, WidgetBorderSpec, WindowTheme, bundled_icon_by_name,
bundled_icon_svg,
};
pub use pipeline::{DiagnosticEntry, PlatformPreset, VersionMatch};
#[allow(unused_imports)]
pub(crate) use pipeline::{diagnose_platform_support, platform_preset_name};
pub use resolve::ResolutionContext;
pub use theme::{ColorMode, Resolved, ResolvedTheme, Theme};
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct AccessibilityPreferences {
pub text_scaling_factor: f32,
pub reduce_motion: bool,
pub high_contrast: bool,
pub reduce_transparency: bool,
}
impl Default for AccessibilityPreferences {
fn default() -> Self {
Self::DEFAULT
}
}
impl AccessibilityPreferences {
pub const DEFAULT: Self = Self {
text_scaling_factor: 1.0,
reduce_motion: false,
high_contrast: false,
reduce_transparency: false,
};
#[must_use]
pub fn from_system() -> Self {
pollster::block_on(pipeline::reader_accessibility())
}
#[must_use]
pub fn text_scale_factor(&self) -> f32 {
let s = self.text_scaling_factor;
if s.is_finite() && s > 0.0 { s } else { 1.0 }
}
#[must_use]
pub fn scaled(&self, size: f32) -> f32 {
let product = size * self.text_scale_factor();
if product.is_normal() && product > 0.0 {
product
} else {
size
}
}
}
#[derive(Clone, Debug)]
pub(crate) struct ReaderResult {
pub(crate) output: ReaderOutput,
pub(crate) name: Cow<'static, str>,
pub(crate) icon_set: Option<IconSet>,
pub(crate) layout: LayoutTheme,
pub(crate) font_dpi: Option<f32>,
pub(crate) accessibility: AccessibilityPreferences,
}
#[derive(Clone, Debug)]
pub(crate) enum ReaderOutput {
#[cfg_attr(all(target_os = "windows", not(feature = "windows")), allow(dead_code))]
Single {
mode: Box<ThemeMode>,
is_dark: bool,
},
#[allow(dead_code)]
Dual {
light: Box<ThemeMode>,
dark: Box<ThemeMode>,
is_dark: bool,
},
}
impl ReaderOutput {
pub(crate) fn mode(&self) -> ColorMode {
let (ReaderOutput::Single { is_dark, .. } | ReaderOutput::Dual { is_dark, .. }) = self;
if *is_dark {
ColorMode::Dark
} else {
ColorMode::Light
}
}
pub(crate) fn to_theme(
&self,
name: &str,
icon_set: Option<IconSet>,
layout: &LayoutTheme,
) -> Theme {
let (light, dark) = match self {
ReaderOutput::Single { mode, is_dark } => {
if *is_dark {
(None, Some(ThemeMode::clone(mode)))
} else {
(Some(ThemeMode::clone(mode)), None)
}
}
ReaderOutput::Dual { light, dark, .. } => {
(Some(ThemeMode::clone(light)), Some(ThemeMode::clone(dark)))
}
};
Theme {
name: std::borrow::Cow::Owned(name.to_string()),
light,
dark,
layout: layout.clone(),
icon_set,
icon_theme: None,
}
}
}
#[derive(Clone, Debug)]
pub(crate) struct OverlaySource {
pub(crate) reader_output: ReaderOutput,
pub(crate) name: Cow<'static, str>,
pub(crate) icon_set: Option<IconSet>,
pub(crate) layout: LayoutTheme,
pub(crate) preset_name: String,
pub(crate) context: crate::resolve::ResolutionContext,
pub(crate) overlay: Option<Theme>,
}
#[derive(Clone, Debug)]
pub struct SystemTheme {
pub name: Cow<'static, str>,
pub mode: ColorMode,
pub light: ResolvedTheme,
pub dark: ResolvedTheme,
pub(crate) overlay_source: OverlaySource,
pub preset: String,
pub version_match: Option<VersionMatch>,
pub icon_set: IconSet,
pub icon_theme: Option<Cow<'static, str>>,
pub(crate) light_icon_theme: Option<Cow<'static, str>>,
pub(crate) dark_icon_theme: Option<Cow<'static, str>>,
pub layout: LayoutTheme,
pub accessibility: AccessibilityPreferences,
}
impl SystemTheme {
#[must_use]
pub fn pick(&self, mode: ColorMode) -> &ResolvedTheme {
match mode {
ColorMode::Light => &self.light,
ColorMode::Dark => &self.dark,
}
}
#[must_use]
pub fn icon_theme_for(&self, mode: ColorMode) -> Option<&str> {
match mode {
ColorMode::Light => self.light_icon_theme.as_deref(),
ColorMode::Dark => self.dark_icon_theme.as_deref(),
}
}
#[must_use]
pub fn icon<'a>(
&self,
id: impl Into<IconId<'a>>,
mode: ColorMode,
color: Option<Rgba>,
) -> Option<IconData> {
self.with_icon_source(mode, |set, theme| {
icons::load_icon_in(id.into(), set, theme, color, None)
})
}
#[must_use]
pub fn icon_indicator(&self, mode: ColorMode) -> Option<AnimatedIcon> {
self.with_icon_source(mode, icons::load_icon_indicator)
}
fn with_icon_source<'s, R>(
&'s self,
mode: ColorMode,
load: impl FnOnce(IconSet, Option<&'s str>) -> R,
) -> R {
load(self.icon_set, self.icon_theme_for(mode))
}
pub fn with_overlay(&self, overlay: &Theme) -> crate::Result<Self> {
let mut source = self.overlay_source.clone();
source.overlay = Some(match source.overlay.take() {
Some(mut stacked) => {
stacked.merge(overlay);
stacked
}
None => overlay.clone(),
});
Ok(SystemTheme {
name: self.name.clone(),
preset: self.preset.clone(),
version_match: self.version_match,
..pipeline::replay(source, self.mode, self.accessibility.clone())?
})
}
pub fn from_system() -> crate::Result<Self> {
pollster::block_on(pipeline::from_system_inner())
}
pub async fn from_system_async() -> crate::Result<Self> {
pipeline::from_system_inner().await
}
pub fn from_system_with_preset(preset: &str) -> crate::Result<Self> {
pollster::block_on(pipeline::from_system_with_preset_inner(preset))
}
pub async fn from_system_with_preset_async(preset: &str) -> crate::Result<Self> {
pipeline::from_system_with_preset_inner(preset).await
}
}
#[cfg(test)]
#[allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::field_reassign_with_default
)]
mod system_theme_tests {
use super::*;
#[test]
fn test_system_theme_pick_dark_mode() {
let preset = Theme::preset("catppuccin-mocha").unwrap();
let mut light_v = preset.light.clone().unwrap();
let mut dark_v = preset.dark.clone().unwrap();
light_v.defaults.accent_color = Some(Rgba::rgb(0, 0, 255));
dark_v.defaults.accent_color = Some(Rgba::rgb(255, 0, 0));
light_v.resolve_all();
dark_v.resolve_all();
let light_resolved = light_v.validate().unwrap();
let dark_resolved = dark_v.validate().unwrap();
let st = SystemTheme {
name: "test".into(),
mode: ColorMode::Dark,
light: light_resolved.clone(),
dark: dark_resolved.clone(),
overlay_source: OverlaySource {
reader_output: ReaderOutput::Dual {
light: Box::new(ThemeMode::default()),
dark: Box::new(ThemeMode::default()),
is_dark: false,
},
name: Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
preset_name: "catppuccin-mocha".into(),
context: crate::resolve::ResolutionContext::for_tests(),
overlay: None,
},
preset: "catppuccin-mocha".into(),
version_match: None,
icon_set: IconSet::Lucide,
icon_theme: Some("lucide".into()),
light_icon_theme: None,
dark_icon_theme: Some("lucide".into()),
layout: LayoutTheme::default(),
accessibility: AccessibilityPreferences::default(),
};
assert_eq!(
st.pick(st.mode).defaults.accent_color,
dark_resolved.defaults.accent_color
);
}
#[test]
fn test_system_theme_pick_light_mode() {
let preset = Theme::preset("catppuccin-mocha").unwrap();
let mut light_v = preset.light.clone().unwrap();
let mut dark_v = preset.dark.clone().unwrap();
light_v.defaults.accent_color = Some(Rgba::rgb(0, 0, 255));
dark_v.defaults.accent_color = Some(Rgba::rgb(255, 0, 0));
light_v.resolve_all();
dark_v.resolve_all();
let light_resolved = light_v.validate().unwrap();
let dark_resolved = dark_v.validate().unwrap();
let st = SystemTheme {
name: "test".into(),
mode: ColorMode::Light,
light: light_resolved.clone(),
dark: dark_resolved.clone(),
overlay_source: OverlaySource {
reader_output: ReaderOutput::Dual {
light: Box::new(ThemeMode::default()),
dark: Box::new(ThemeMode::default()),
is_dark: false,
},
name: Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
preset_name: "catppuccin-mocha".into(),
context: crate::resolve::ResolutionContext::for_tests(),
overlay: None,
},
preset: "catppuccin-mocha".into(),
version_match: None,
icon_set: IconSet::Lucide,
icon_theme: Some("lucide".into()),
light_icon_theme: Some("lucide".into()),
dark_icon_theme: None,
layout: LayoutTheme::default(),
accessibility: AccessibilityPreferences::default(),
};
assert_eq!(
st.pick(st.mode).defaults.accent_color,
light_resolved.defaults.accent_color
);
}
#[test]
fn test_system_theme_pick_explicit() {
let preset = Theme::preset("catppuccin-mocha").unwrap();
let mut light_v = preset.light.clone().unwrap();
let mut dark_v = preset.dark.clone().unwrap();
light_v.defaults.accent_color = Some(Rgba::rgb(0, 0, 255));
dark_v.defaults.accent_color = Some(Rgba::rgb(255, 0, 0));
light_v.resolve_all();
dark_v.resolve_all();
let light_resolved = light_v.validate().unwrap();
let dark_resolved = dark_v.validate().unwrap();
let st = SystemTheme {
name: "test".into(),
mode: ColorMode::Light,
light: light_resolved.clone(),
dark: dark_resolved.clone(),
overlay_source: OverlaySource {
reader_output: ReaderOutput::Dual {
light: Box::new(ThemeMode::default()),
dark: Box::new(ThemeMode::default()),
is_dark: false,
},
name: Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
preset_name: "catppuccin-mocha".into(),
context: crate::resolve::ResolutionContext::for_tests(),
overlay: None,
},
preset: "catppuccin-mocha".into(),
version_match: None,
icon_set: IconSet::Lucide,
icon_theme: Some("lucide".into()),
light_icon_theme: Some("lucide".into()),
dark_icon_theme: None,
layout: LayoutTheme::default(),
accessibility: AccessibilityPreferences::default(),
};
assert_eq!(
st.pick(ColorMode::Dark).defaults.accent_color,
dark_resolved.defaults.accent_color
);
assert_eq!(
st.pick(ColorMode::Light).defaults.accent_color,
light_resolved.defaults.accent_color
);
}
#[test]
#[cfg(target_os = "linux")]
#[cfg(feature = "kde")]
fn sync_consumer_no_async_runtime() {
let _result = SystemTheme::from_system();
}
#[test]
#[cfg(target_os = "linux")]
fn test_platform_preset_name_kde() {
let preset = pipeline::linux_preset_for_de(detect::parse_linux_desktop("KDE"));
assert_eq!(preset.name, "kde-breeze");
}
#[test]
#[cfg(target_os = "linux")]
fn test_platform_preset_name_gnome() {
let preset = pipeline::linux_preset_for_de(detect::parse_linux_desktop("GNOME"));
assert_eq!(preset.name, "adwaita");
}
#[test]
fn accessibility_preferences_from_system_is_consistent_with_system_theme() {
let prefs = AccessibilityPreferences::from_system();
assert!(prefs.text_scaling_factor.is_finite());
assert!(prefs.text_scaling_factor > 0.0);
if let Ok(sys) = SystemTheme::from_system() {
assert_eq!(
prefs.text_scaling_factor,
sys.accessibility.text_scaling_factor
);
assert_eq!(prefs.high_contrast, sys.accessibility.high_contrast);
assert_eq!(
prefs.reduce_transparency,
sys.accessibility.reduce_transparency
);
assert_eq!(prefs.reduce_motion, sys.accessibility.reduce_motion);
}
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod overlay_tests {
use super::*;
fn default_system_theme() -> crate::Result<SystemTheme> {
let preset = Theme::preset("catppuccin-mocha")?;
let reader = ReaderResult {
output: ReaderOutput::Dual {
light: Box::new(preset.light.clone().unwrap_or_default()),
dark: Box::new(preset.dark.clone().unwrap_or_default()),
is_dark: false,
},
name: preset.name,
icon_set: preset.icon_set,
layout: preset.layout,
font_dpi: None,
accessibility: AccessibilityPreferences::default(),
};
pipeline::run_pipeline(reader, "catppuccin-mocha")
}
fn violation_paths(result: crate::Result<SystemTheme>) -> Vec<String> {
let Err(crate::Error::ResolutionInvalid { errors }) = result else {
panic!("expected ResolutionInvalid, got {:?}", result.err());
};
errors.into_iter().map(|rv| rv.path).collect()
}
#[test]
fn test_overlay_error_names_the_variant() -> crate::Result<()> {
let st = default_system_theme()?;
let overlay = Theme::from_toml("name = \"overlay\"\n[dark.button]\nmin_height_px = -1.0")?;
assert_eq!(
violation_paths(st.with_overlay(&overlay)),
["dark.button.min_height_px"]
);
Ok(())
}
#[test]
fn test_pipeline_error_names_the_variant() -> crate::Result<()> {
let preset = Theme::preset("catppuccin-mocha")?;
let mut light = preset.light.clone().unwrap_or_default();
light.button.min_height = Some(-1.0);
let reader = ReaderResult {
output: ReaderOutput::Dual {
light: Box::new(light),
dark: Box::new(preset.dark.clone().unwrap_or_default()),
is_dark: true,
},
name: preset.name,
icon_set: preset.icon_set,
layout: preset.layout,
font_dpi: None,
accessibility: AccessibilityPreferences::default(),
};
assert_eq!(
violation_paths(pipeline::run_pipeline(reader, "catppuccin-mocha",)),
["light.button.min_height_px"]
);
Ok(())
}
#[test]
fn test_overlay_accent_propagates() -> crate::Result<()> {
let st = default_system_theme()?;
let new_accent = Rgba::rgb(255, 0, 0);
let mut overlay = Theme::default();
let mut light_v = ThemeMode::default();
light_v.defaults.accent_color = Some(new_accent);
let mut dark_v = ThemeMode::default();
dark_v.defaults.accent_color = Some(new_accent);
overlay.light = Some(light_v);
overlay.dark = Some(dark_v);
let result = st.with_overlay(&overlay)?;
assert_eq!(result.light.defaults.accent_color, new_accent);
assert_eq!(result.light.button.primary_background, new_accent);
assert_eq!(result.light.checkbox.checked_background, new_accent);
assert_eq!(result.light.slider.fill_color, new_accent);
assert_eq!(result.light.progress_bar.fill_color, new_accent);
assert_eq!(result.light.switch.checked_background, new_accent);
assert_eq!(
result.light.spinner.fill_color, new_accent,
"spinner.fill should re-derive from new accent"
);
Ok(())
}
#[test]
fn test_overlay_preserves_unrelated_fields() -> crate::Result<()> {
let st = default_system_theme()?;
let original_bg = st.light.defaults.background_color;
let mut overlay = Theme::default();
let mut light_v = ThemeMode::default();
light_v.defaults.accent_color = Some(Rgba::rgb(255, 0, 0));
overlay.light = Some(light_v);
let result = st.with_overlay(&overlay)?;
assert_eq!(
result.light.defaults.background_color, original_bg,
"background should be unchanged"
);
Ok(())
}
#[test]
fn test_overlay_empty_noop() -> crate::Result<()> {
let st = default_system_theme()?;
let original_light_accent = st.light.defaults.accent_color;
let original_dark_accent = st.dark.defaults.accent_color;
let original_light_bg = st.light.defaults.background_color;
let overlay = Theme::default();
let result = st.with_overlay(&overlay)?;
assert_eq!(result.light.defaults.accent_color, original_light_accent);
assert_eq!(result.dark.defaults.accent_color, original_dark_accent);
assert_eq!(result.light.defaults.background_color, original_light_bg);
Ok(())
}
#[test]
fn test_overlay_both_variants() -> crate::Result<()> {
let st = default_system_theme()?;
let red = Rgba::rgb(255, 0, 0);
let green = Rgba::rgb(0, 255, 0);
let mut overlay = Theme::default();
let mut light_v = ThemeMode::default();
light_v.defaults.accent_color = Some(red);
let mut dark_v = ThemeMode::default();
dark_v.defaults.accent_color = Some(green);
overlay.light = Some(light_v);
overlay.dark = Some(dark_v);
let result = st.with_overlay(&overlay)?;
assert_eq!(
result.light.defaults.accent_color, red,
"light accent = red"
);
assert_eq!(
result.dark.defaults.accent_color, green,
"dark accent = green"
);
Ok(())
}
#[test]
fn test_overlay_font_family() -> crate::Result<()> {
let st = default_system_theme()?;
let mut overlay = Theme::default();
let mut light_v = ThemeMode::default();
light_v.defaults.font.family = Some("Comic Sans".into());
overlay.light = Some(light_v);
let result = st.with_overlay(&overlay)?;
assert_eq!(result.light.defaults.font.family.as_ref(), "Comic Sans");
Ok(())
}
#[test]
fn test_overlay_roundtrip_via_overlay_source() -> crate::Result<()> {
let st = default_system_theme()?;
let new_accent = Rgba::rgb(255, 0, 0);
let mut overlay = Theme::default();
let mut light_v = ThemeMode::default();
light_v.defaults.accent_color = Some(new_accent);
overlay.light = Some(light_v);
let result = st.with_overlay(&overlay)?;
assert_eq!(result.light.defaults.accent_color, new_accent);
assert_eq!(
result.dark.defaults.accent_color,
st.dark.defaults.accent_color
);
Ok(())
}
#[test]
fn test_overlay_source_no_variant_fields() -> crate::Result<()> {
let st = default_system_theme()?;
let _ = &st.overlay_source; Ok(())
}
}
#[cfg(test)]
mod accessibility_tests {
use super::*;
fn prefs(text_scaling_factor: f32) -> AccessibilityPreferences {
AccessibilityPreferences {
text_scaling_factor,
..AccessibilityPreferences::default()
}
}
#[test]
fn text_scale_factor_keeps_a_finite_positive_factor() {
assert_eq!(prefs(2.0).text_scale_factor(), 2.0);
assert_eq!(prefs(2.0).scaled(10.0), 20.0);
assert_eq!(AccessibilityPreferences::default().text_scale_factor(), 1.0);
}
#[test]
fn text_scale_factor_ignores_a_factor_that_is_not_finite_and_positive() {
for f in [f32::NAN, 0.0, -0.0, -1.0, f32::INFINITY, f32::NEG_INFINITY] {
assert_eq!(prefs(f).text_scale_factor(), 1.0, "{f}");
assert_eq!(prefs(f).scaled(10.0), 10.0, "{f}");
}
}
#[test]
fn scaled_keeps_a_size_whose_product_is_not_a_normal_positive_number() {
assert_eq!(prefs(f32::MAX).scaled(13.0), 13.0);
assert_eq!(prefs(3e37).scaled(13.0), 13.0);
assert!((13.0 * 1e-45_f32).is_subnormal());
assert_eq!(prefs(1e-45).scaled(13.0), 13.0);
assert_eq!(
prefs(f32::MIN_POSITIVE).scaled(f32::MIN_POSITIVE),
f32::MIN_POSITIVE
);
assert_eq!(prefs(2e37).scaled(13.0), 13.0 * 2e37);
}
}