#![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),* $(,)? })?
$(soft_option { $($so_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();
}
)*)?
$($(
if overlay.$so_field.is_some() {
self.$so_field = overlay.$so_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.$so_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 mod gnome;
pub mod icons;
#[cfg(all(target_os = "linux", feature = "kde"))]
pub mod kde;
#[path = "kde/metrics.rs"]
pub(crate) mod kde_metrics;
pub 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::*;
pub use crate::presets::PresetInfo;
}
#[cfg(all(target_os = "linux", feature = "system-icons"))]
pub mod freedesktop;
#[cfg(target_os = "macos")]
pub mod macos;
#[cfg(not(target_os = "macos"))]
pub(crate) mod macos;
#[cfg(feature = "svg-rasterize")]
pub mod rasterize;
#[cfg(all(target_os = "macos", feature = "system-icons"))]
pub mod sficons;
#[cfg(target_os = "windows")]
#[cfg_attr(not(feature = "windows"), allow(dead_code))]
pub 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 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, 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_is_dark, detect_reduced_motion, invalidate_caches, prefers_reduced_motion,
system_is_dark,
};
#[allow(unused_imports)]
pub(crate) use error::{Error, ErrorKind, RangeViolation};
#[allow(unused_imports)]
pub(crate) use icons::{
FreedesktopLoader, IconId, LucideLoader, MaterialLoader, SegoeIconsLoader, SfSymbolsLoader,
is_freedesktop_theme_available, load_icon, load_icon_indicator,
};
pub use icons::{IconSetChoice, default_icon_choice, list_freedesktop_themes};
#[allow(unused_imports)]
pub(crate) use model::icons::{detect_icon_theme, icon_name, system_icon_set, system_icon_theme};
#[allow(unused_imports)]
pub(crate) use model::{
AnimatedIcon, ButtonTheme, CardTheme, CheckboxTheme, ColorMode, 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, ResolvedTheme, ResolvedWidgetBorder, ScrollbarTheme,
SegmentedControlTheme, SeparatorTheme, SidebarTheme, SliderTheme, SpinnerTheme, SplitterTheme,
StatusBarTheme, SwitchTheme, TabTheme, TextScale, TextScaleEntry, Theme, ThemeDefaults,
ThemeMode, ToolbarTheme, TooltipTheme, TransformAnimation, WidgetBorderSpec, WindowTheme,
bundled_icon_by_name, bundled_icon_svg,
};
pub use pipeline::{DiagnosticEntry, PlatformPreset};
#[allow(unused_imports)]
pub(crate) use pipeline::{diagnose_platform_support, platform_preset_name};
pub use resolve::ResolutionContext;
#[derive(Clone, Debug, PartialEq)]
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 {
text_scaling_factor: 1.0,
reduce_motion: false,
high_contrast: false,
reduce_transparency: false,
}
}
}
impl AccessibilityPreferences {
#[must_use]
#[cfg(target_os = "linux")]
pub fn from_system() -> Self {
pollster::block_on(pipeline::accessibility_from_system_inner())
}
#[must_use]
#[cfg(not(target_os = "linux"))]
pub fn from_system() -> Self {
let waker = std::task::Waker::noop();
let mut cx = std::task::Context::from_waker(&waker);
let mut fut = std::pin::pin!(pipeline::accessibility_from_system_inner());
match fut.as_mut().poll(&mut cx) {
std::task::Poll::Ready(prefs) => prefs,
std::task::Poll::Pending => Self::default(),
}
}
}
#[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>,
},
}
impl ReaderOutput {
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,
}
#[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(crate) live_preset: String,
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(),
}
}
pub fn with_overlay(&self, overlay: &Theme) -> crate::Result<Self> {
let src = &self.overlay_source;
let live_preset = Theme::preset(&src.preset_name)?;
let full_preset_name = src
.preset_name
.strip_suffix("-live")
.unwrap_or(&src.preset_name);
let full_preset = Theme::preset(full_preset_name)?;
let reader_as_theme = src
.reader_output
.to_theme(&src.name, src.icon_set, &src.layout);
let mut merged = full_preset.clone();
merged.merge(&live_preset);
merged.merge(&reader_as_theme);
let layout = merged.layout.clone();
let (mut light, mut dark) = match &src.reader_output {
ReaderOutput::Single { is_dark, .. } => {
if *is_dark {
(
full_preset.light.unwrap_or_default(),
merged.dark.unwrap_or_default(),
)
} else {
(
merged.light.unwrap_or_default(),
full_preset.dark.unwrap_or_default(),
)
}
}
ReaderOutput::Dual { .. } => (
merged.light.unwrap_or_default(),
merged.dark.unwrap_or_default(),
),
};
if let Some(over) = &overlay.light {
light.merge(over);
}
if let Some(over) = &overlay.dark {
dark.merge(over);
}
let resolved_light = light.into_resolved(&src.context)?;
let resolved_dark = dark.into_resolved(&src.context)?;
Ok(SystemTheme {
name: self.name.clone(),
mode: self.mode,
light: resolved_light,
dark: resolved_dark,
overlay_source: self.overlay_source.clone(),
live_preset: self.live_preset.clone(),
preset: self.preset.clone(),
icon_set: self.icon_set,
icon_theme: self.icon_theme.clone(),
light_icon_theme: self.light_icon_theme.clone(),
dark_icon_theme: self.dark_icon_theme.clone(),
layout,
accessibility: self.accessibility.clone(),
})
}
#[cfg(target_os = "linux")]
pub fn from_system() -> crate::Result<Self> {
pollster::block_on(pipeline::from_system_inner())
}
#[cfg(not(target_os = "linux"))]
pub fn from_system() -> crate::Result<Self> {
let waker = std::task::Waker::noop();
let mut cx = std::task::Context::from_waker(&waker);
let mut fut = std::pin::pin!(pipeline::from_system_inner());
match fut.as_mut().poll(&mut cx) {
std::task::Poll::Ready(result) => result,
std::task::Poll::Pending => Err(crate::Error::PlatformUnsupported {
platform: "unexpected async suspension",
}),
}
}
pub async fn from_system_async() -> crate::Result<Self> {
pipeline::from_system_inner().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()),
},
name: Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
preset_name: "catppuccin-mocha".into(),
context: crate::resolve::ResolutionContext::for_tests(),
},
live_preset: "catppuccin-mocha".into(),
preset: "catppuccin-mocha".into(),
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()),
},
name: Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
preset_name: "catppuccin-mocha".into(),
context: crate::resolve::ResolutionContext::for_tests(),
},
live_preset: "catppuccin-mocha".into(),
preset: "catppuccin-mocha".into(),
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()),
},
name: Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
preset_name: "catppuccin-mocha".into(),
context: crate::resolve::ResolutionContext::for_tests(),
},
live_preset: "catppuccin-mocha".into(),
preset: "catppuccin-mocha".into(),
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");
assert!(preset.is_live);
assert_eq!(preset.live_name(), "kde-breeze-live");
}
#[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");
assert!(preset.is_live);
assert_eq!(preset.live_name(), "adwaita-live");
}
#[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!(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()),
},
name: preset.name,
icon_set: preset.icon_set,
layout: preset.layout,
font_dpi: None,
accessibility: AccessibilityPreferences::default(),
};
pipeline::run_pipeline(reader, "catppuccin-mocha", ColorMode::Light)
}
#[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(())
}
}