#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ColorMode {
Light,
Dark,
}
impl ColorMode {
#[must_use]
pub fn is_dark(self) -> bool {
matches!(self, Self::Dark)
}
}
pub mod animated;
pub mod arrow_side;
pub mod border;
pub mod bundled;
pub mod defaults;
pub mod dialog_order;
pub mod font;
pub mod icon_sizes;
pub mod icons;
pub mod resolved;
pub mod tab_indicator_side;
pub mod widgets;
pub use animated::{
AnimatedIcon, EmptyFrameListError, FrameList, FramesData, TransformAnimation, TransformData,
};
pub use border::{
DefaultsBorderSpec, ResolvedDefaultsBorder, ResolvedPadding, ResolvedWidgetBorder,
WidgetBorderSpec,
};
pub use arrow_side::ArrowSide;
pub(crate) use bundled::{bundled_icon_by_name, bundled_icon_svg};
pub use defaults::ThemeDefaults;
pub use dialog_order::DialogButtonOrder;
pub use font::{
FontSize, FontSpec, FontStyle, ResolvedFontSpec, TextScale, TextScaleEntry, intern_font_family,
};
pub use icon_sizes::IconSizes;
pub use icons::{
IconData, IconProvider, IconRole, IconSet, icon_name, system_icon_set, system_icon_theme,
};
pub use resolved::{
Resolved, ResolvedDefaults, ResolvedIconSizes, ResolvedTextScale, ResolvedTextScaleEntry,
ResolvedTheme,
};
pub use tab_indicator_side::TabIndicatorSide;
pub use widgets::*;
use std::borrow::Cow;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct ThemeMode {
#[serde(default, skip_serializing_if = "ThemeDefaults::is_empty")]
pub defaults: ThemeDefaults,
#[serde(default, skip_serializing_if = "TextScale::is_empty")]
pub text_scale: TextScale,
#[serde(default, skip_serializing_if = "WindowTheme::is_empty")]
pub window: WindowTheme,
#[serde(default, skip_serializing_if = "ButtonTheme::is_empty")]
pub button: ButtonTheme,
#[serde(default, skip_serializing_if = "InputTheme::is_empty")]
pub input: InputTheme,
#[serde(default, skip_serializing_if = "TextAreaTheme::is_empty")]
pub text_area: TextAreaTheme,
#[serde(default, skip_serializing_if = "CheckboxTheme::is_empty")]
pub checkbox: CheckboxTheme,
#[serde(default, skip_serializing_if = "MenuTheme::is_empty")]
pub menu: MenuTheme,
#[serde(default, skip_serializing_if = "TooltipTheme::is_empty")]
pub tooltip: TooltipTheme,
#[serde(default, skip_serializing_if = "ScrollbarTheme::is_empty")]
pub scrollbar: ScrollbarTheme,
#[serde(default, skip_serializing_if = "SliderTheme::is_empty")]
pub slider: SliderTheme,
#[serde(default, skip_serializing_if = "ProgressBarTheme::is_empty")]
pub progress_bar: ProgressBarTheme,
#[serde(default, skip_serializing_if = "TabTheme::is_empty")]
pub tab: TabTheme,
#[serde(default, skip_serializing_if = "SidebarTheme::is_empty")]
pub sidebar: SidebarTheme,
#[serde(default, skip_serializing_if = "ToolbarTheme::is_empty")]
pub toolbar: ToolbarTheme,
#[serde(default, skip_serializing_if = "StatusBarTheme::is_empty")]
pub status_bar: StatusBarTheme,
#[serde(default, skip_serializing_if = "ListTheme::is_empty")]
pub list: ListTheme,
#[serde(default, skip_serializing_if = "PopoverTheme::is_empty")]
pub popover: PopoverTheme,
#[serde(default, skip_serializing_if = "SplitterTheme::is_empty")]
pub splitter: SplitterTheme,
#[serde(default, skip_serializing_if = "SeparatorTheme::is_empty")]
pub separator: SeparatorTheme,
#[serde(default, skip_serializing_if = "SwitchTheme::is_empty")]
pub switch: SwitchTheme,
#[serde(default, skip_serializing_if = "DialogTheme::is_empty")]
pub dialog: DialogTheme,
#[serde(default, skip_serializing_if = "SpinnerTheme::is_empty")]
pub spinner: SpinnerTheme,
#[serde(default, skip_serializing_if = "ComboBoxTheme::is_empty")]
pub combo_box: ComboBoxTheme,
#[serde(default, skip_serializing_if = "SegmentedControlTheme::is_empty")]
pub segmented_control: SegmentedControlTheme,
#[serde(default, skip_serializing_if = "CardTheme::is_empty")]
pub card: CardTheme,
#[serde(default, skip_serializing_if = "ExpanderTheme::is_empty")]
pub expander: ExpanderTheme,
#[serde(default, skip_serializing_if = "LinkTheme::is_empty")]
pub link: LinkTheme,
}
impl_merge!(ThemeMode {
nested {
defaults, text_scale, window, button, input, text_area, checkbox, menu,
tooltip, scrollbar, slider, progress_bar, tab, sidebar,
toolbar, status_bar, list, popover, splitter, separator,
switch, dialog, spinner, combo_box, segmented_control,
card, expander, link
}
});
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Theme {
pub name: Cow<'static, str>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub light: Option<ThemeMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dark: Option<ThemeMode>,
#[serde(default, skip_serializing_if = "LayoutTheme::is_empty")]
pub layout: LayoutTheme,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub icon_set: Option<IconSet>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub icon_theme: Option<Cow<'static, str>>,
}
impl Default for Theme {
fn default() -> Self {
Self {
name: Cow::Borrowed(""),
light: None,
dark: None,
layout: LayoutTheme::default(),
icon_set: None,
icon_theme: None,
}
}
}
impl Theme {
pub fn merge(&mut self, overlay: &Self) {
match (&mut self.light, &overlay.light) {
(Some(base), Some(over)) => base.merge(over),
(None, Some(over)) => self.light = Some(over.clone()),
_ => {}
}
match (&mut self.dark, &overlay.dark) {
(Some(base), Some(over)) => base.merge(over),
(None, Some(over)) => self.dark = Some(over.clone()),
_ => {}
}
self.layout.merge(&overlay.layout);
if overlay.icon_set.is_some() {
self.icon_set = overlay.icon_set;
}
if overlay.icon_theme.is_some() {
self.icon_theme.clone_from(&overlay.icon_theme);
}
}
pub fn pick_variant(&self, mode: ColorMode) -> crate::Result<&ThemeMode> {
match mode {
ColorMode::Dark => self.dark.as_ref().or(self.light.as_ref()),
ColorMode::Light => self.light.as_ref().or(self.dark.as_ref()),
}
.ok_or(crate::Error::NoVariant { mode })
}
pub fn into_variant(self, mode: ColorMode) -> crate::Result<ThemeMode> {
match mode {
ColorMode::Dark => self.dark.or(self.light),
ColorMode::Light => self.light.or(self.dark),
}
.ok_or(crate::Error::NoVariant { mode })
}
pub fn resolve(&self, mode: ColorMode) -> crate::Result<Resolved> {
self.resolve_in(mode, &crate::resolve::ResolutionContext::from_system())
}
pub(crate) fn resolve_in(
&self,
mode: ColorMode,
ctx: &crate::resolve::ResolutionContext,
) -> crate::Result<Resolved> {
let variant_ref = self.pick_variant(mode)?;
let tier1 = variant_ref.defaults.icon_theme.clone();
let tier2 = self.icon_theme.clone();
let icon_theme_explicit = tier1.is_some() || tier2.is_some();
let icon_theme = tier1.or(tier2).or_else(|| ctx.icon_theme.clone());
let icon_set = self
.icon_set
.unwrap_or_else(crate::model::icons::system_icon_set);
let variant = variant_ref.clone().into_resolved(ctx)?;
Ok(Resolved {
variant,
icon_set,
icon_theme,
icon_theme_explicit,
})
}
pub fn is_empty(&self) -> bool {
self.light.is_none()
&& self.dark.is_none()
&& self.layout.is_empty()
&& self.icon_set.is_none()
&& self.icon_theme.is_none()
}
pub fn preset(name: &str) -> crate::Result<Self> {
crate::presets::preset(name)
}
pub fn from_toml(toml_str: &str) -> crate::Result<Self> {
crate::presets::from_toml(toml_str)
}
pub fn from_file(path: impl AsRef<std::path::Path>) -> crate::Result<Self> {
crate::presets::from_file(path)
}
#[must_use]
pub fn list_presets() -> &'static [crate::presets::PresetInfo] {
crate::presets::list_presets()
}
#[must_use]
pub fn list_presets_for_platform() -> Vec<crate::presets::PresetInfo> {
crate::presets::list_presets_for_platform()
}
pub fn to_toml(&self) -> crate::Result<String> {
crate::presets::to_toml(self)
}
pub fn lint_toml(toml_str: &str) -> crate::Result<Vec<String>> {
let value: toml::Value =
toml::from_str(toml_str).map_err(|e: toml::de::Error| crate::Error::Toml(e))?;
let mut warnings = Vec::new();
let top_table = match &value {
toml::Value::Table(t) => t,
_ => return Ok(warnings),
};
const TOP_KEYS: &[&str] = &["name", "light", "dark", "layout", "icon_set", "icon_theme"];
for key in top_table.keys() {
if !TOP_KEYS.contains(&key.as_str()) {
warnings.push(format!("unknown field: {key}"));
}
}
const STRUCTURAL_KEYS: &[&str] = &["defaults", "text_scale"];
let widget_registry: std::collections::HashMap<&str, &[&str]> =
inventory::iter::<crate::resolve::WidgetFieldInfo>()
.map(|info| (info.widget_name, info.field_names))
.collect();
let struct_registry: std::collections::HashMap<&str, &[&str]> =
inventory::iter::<crate::resolve::FieldInfo>()
.map(|info| (info.struct_name, info.field_names))
.collect();
let get_struct_fields =
|name: &str| -> Option<&[&str]> { struct_registry.get(name).copied() };
let lint_text_scale = |table: &toml::map::Map<String, toml::Value>,
prefix: &str,
warnings: &mut Vec<String>| {
let Some(scale_fields) = get_struct_fields("TextScale") else {
return;
};
let entry_fields = get_struct_fields("TextScaleEntry");
for key in table.keys() {
if !scale_fields.contains(&key.as_str()) {
warnings.push(format!("unknown field: {prefix}.{key}"));
} else if let Some(toml::Value::Table(entry_table)) = table.get(key)
&& let Some(entry_fields) = entry_fields
{
for ekey in entry_table.keys() {
if !entry_fields.contains(&ekey.as_str()) {
warnings.push(format!("unknown field: {prefix}.{key}.{ekey}"));
}
}
}
}
};
let lint_defaults = |table: &toml::map::Map<String, toml::Value>,
prefix: &str,
warnings: &mut Vec<String>| {
let Some(defaults_fields) = get_struct_fields("ThemeDefaults") else {
return;
};
for key in table.keys() {
if !defaults_fields.contains(&key.as_str()) {
warnings.push(format!("unknown field: {prefix}.{key}"));
continue;
}
if let Some(toml::Value::Table(sub)) = table.get(key) {
let known = match key.as_str() {
"font" | "mono_font" => get_struct_fields("FontSpec"),
"border" => get_struct_fields("DefaultsBorderSpec"),
"icon_sizes" => get_struct_fields("IconSizes"),
_ => continue,
};
let Some(known) = known else { continue };
for skey in sub.keys() {
if !known.contains(&skey.as_str()) {
warnings.push(format!("unknown field: {prefix}.{key}.{skey}"));
}
}
}
}
};
let lint_variant = |table: &toml::map::Map<String, toml::Value>,
prefix: &str,
warnings: &mut Vec<String>| {
for key in table.keys() {
let key_str = key.as_str();
let is_structural = STRUCTURAL_KEYS.contains(&key_str);
let widget_fields = widget_registry.get(key_str);
if !is_structural && widget_fields.is_none() {
warnings.push(format!("unknown field: {prefix}.{key}"));
continue;
}
if let Some(toml::Value::Table(sub)) = table.get(key) {
let sub_prefix = format!("{prefix}.{key}");
match key_str {
"defaults" => lint_defaults(sub, &sub_prefix, warnings),
"text_scale" => lint_text_scale(sub, &sub_prefix, warnings),
_ => {
if let Some(fields) = widget_fields {
for skey in sub.keys() {
if !fields.contains(&skey.as_str()) {
warnings
.push(format!("unknown field: {sub_prefix}.{skey}"));
}
if let Some(toml::Value::Table(nested)) = sub.get(skey) {
let nested_known = match skey.as_str() {
s if s == "font" || s.ends_with("_font") => {
get_struct_fields("FontSpec")
}
"border" => get_struct_fields("WidgetBorderSpec"),
_ => None,
};
if let Some(known) = nested_known {
for nkey in nested.keys() {
if !known.contains(&nkey.as_str()) {
warnings.push(format!(
"unknown field: {sub_prefix}.{skey}.{nkey}"
));
}
}
}
}
}
}
}
}
}
}
};
for variant_key in &["light", "dark"] {
if let Some(toml::Value::Table(variant_table)) = top_table.get(*variant_key) {
lint_variant(variant_table, variant_key, &mut warnings);
}
}
if let Some(toml::Value::Table(layout_table)) = top_table.get("layout")
&& let Some(layout_fields) = get_struct_fields("LayoutTheme")
{
for key in layout_table.keys() {
if !layout_fields.contains(&key.as_str()) {
warnings.push(format!("unknown field: layout.{key}"));
}
}
}
Ok(warnings)
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::Rgba;
#[test]
fn theme_variant_default_is_empty() {
assert!(ThemeMode::default().is_empty());
}
#[test]
fn theme_variant_not_empty_when_color_set() {
let mut v = ThemeMode::default();
v.defaults.accent_color = Some(Rgba::rgb(0, 120, 215));
assert!(!v.is_empty());
}
#[test]
fn theme_variant_not_empty_when_font_set() {
let mut v = ThemeMode::default();
v.defaults.font.family = Some("Inter".into());
assert!(!v.is_empty());
}
#[test]
fn theme_variant_merge_recursively() {
let mut base = ThemeMode::default();
base.defaults.background_color = Some(Rgba::rgb(255, 255, 255));
base.defaults.font.family = Some("Noto Sans".into());
let mut overlay = ThemeMode::default();
overlay.defaults.accent_color = Some(Rgba::rgb(0, 120, 215));
overlay.defaults.border.corner_radius = Some(4.0);
base.merge(&overlay);
assert_eq!(
base.defaults.background_color,
Some(Rgba::rgb(255, 255, 255))
);
assert_eq!(base.defaults.accent_color, Some(Rgba::rgb(0, 120, 215)));
assert_eq!(base.defaults.font.family.as_deref(), Some("Noto Sans"));
assert_eq!(base.defaults.border.corner_radius, Some(4.0));
}
#[test]
fn theme_variant_has_all_widgets() {
let mut v = ThemeMode::default();
v.window.background_color = Some(Rgba::rgb(255, 255, 255));
v.button.min_height = Some(32.0);
v.input.min_height = Some(32.0);
v.checkbox.indicator_width = Some(18.0);
v.menu.row_height = Some(28.0);
v.tooltip.max_width = Some(300.0);
v.scrollbar.groove_width = Some(14.0);
v.slider.track_height = Some(4.0);
v.progress_bar.track_height = Some(6.0);
v.tab.min_height = Some(32.0);
v.sidebar.background_color = Some(Rgba::rgb(240, 240, 240));
v.toolbar.bar_height = Some(40.0);
v.status_bar.background_color = Some(Rgba::rgb(240, 240, 240));
v.list.row_height = Some(28.0);
v.popover.background_color = Some(Rgba::rgb(255, 255, 255));
v.splitter.divider_width = Some(4.0);
v.separator.line_color = Some(Rgba::rgb(200, 200, 200));
v.switch.track_width = Some(32.0);
v.dialog.min_width = Some(320.0);
v.spinner.diameter = Some(24.0);
v.combo_box.min_height = Some(32.0);
v.segmented_control.segment_height = Some(28.0);
v.card.background_color = Some(Rgba::rgb(255, 255, 255));
v.expander.header_height = Some(32.0);
v.link.underline_enabled = Some(true);
assert!(!v.is_empty());
assert!(!v.window.is_empty());
assert!(!v.button.is_empty());
assert!(!v.input.is_empty());
assert!(!v.checkbox.is_empty());
assert!(!v.menu.is_empty());
assert!(!v.tooltip.is_empty());
assert!(!v.scrollbar.is_empty());
assert!(!v.slider.is_empty());
assert!(!v.progress_bar.is_empty());
assert!(!v.tab.is_empty());
assert!(!v.sidebar.is_empty());
assert!(!v.toolbar.is_empty());
assert!(!v.status_bar.is_empty());
assert!(!v.list.is_empty());
assert!(!v.popover.is_empty());
assert!(!v.splitter.is_empty());
assert!(!v.separator.is_empty());
assert!(!v.switch.is_empty());
assert!(!v.dialog.is_empty());
assert!(!v.spinner.is_empty());
assert!(!v.combo_box.is_empty());
assert!(!v.segmented_control.is_empty());
assert!(!v.card.is_empty());
assert!(!v.expander.is_empty());
assert!(!v.link.is_empty());
}
#[test]
fn theme_variant_merge_per_widget() {
let mut base = ThemeMode::default();
base.button.background_color = Some(Rgba::rgb(200, 200, 200));
base.button.min_height = Some(28.0);
base.tooltip.background_color = Some(Rgba::rgb(50, 50, 50));
let mut overlay = ThemeMode::default();
overlay.button.background_color = Some(Rgba::rgb(255, 255, 255));
overlay.button.min_width = Some(64.0);
base.merge(&overlay);
assert_eq!(base.button.background_color, Some(Rgba::rgb(255, 255, 255)));
assert_eq!(base.button.min_width, Some(64.0));
assert_eq!(base.button.min_height, Some(28.0));
assert_eq!(base.tooltip.background_color, Some(Rgba::rgb(50, 50, 50)));
}
#[test]
fn native_theme_default_is_empty() {
let theme = Theme::default();
assert!(theme.is_empty());
assert_eq!(theme.name, "");
}
#[test]
fn native_theme_merge_keeps_base_name() {
let mut base = Theme {
name: "Base Theme".into(),
..Theme::default()
};
let overlay = Theme {
name: "Overlay Theme".into(),
..Theme::default()
};
base.merge(&overlay);
assert_eq!(base.name, "Base Theme");
}
#[test]
fn native_theme_merge_overlay_light_into_none() {
let mut base = Theme {
name: "Theme".into(),
..Theme::default()
};
let mut overlay = Theme {
name: "Overlay".into(),
..Theme::default()
};
let mut light = ThemeMode::default();
light.defaults.accent_color = Some(Rgba::rgb(0, 120, 215));
overlay.light = Some(light);
base.merge(&overlay);
assert!(base.light.is_some());
assert_eq!(
base.light.as_ref().unwrap().defaults.accent_color,
Some(Rgba::rgb(0, 120, 215))
);
}
#[test]
fn native_theme_merge_both_light_variants() {
let mut base = Theme {
name: "Theme".into(),
..Theme::default()
};
let mut base_light = ThemeMode::default();
base_light.defaults.background_color = Some(Rgba::rgb(255, 255, 255));
base.light = Some(base_light);
let mut overlay = Theme {
name: "Overlay".into(),
..Theme::default()
};
let mut overlay_light = ThemeMode::default();
overlay_light.defaults.accent_color = Some(Rgba::rgb(0, 120, 215));
overlay.light = Some(overlay_light);
base.merge(&overlay);
let light = base.light.as_ref().unwrap();
assert_eq!(
light.defaults.background_color,
Some(Rgba::rgb(255, 255, 255))
);
assert_eq!(light.defaults.accent_color, Some(Rgba::rgb(0, 120, 215)));
}
#[test]
fn native_theme_merge_base_light_only_preserved() {
let mut base = Theme {
name: "Theme".into(),
..Theme::default()
};
let mut base_light = ThemeMode::default();
base_light.defaults.font.family = Some("Inter".into());
base.light = Some(base_light);
let overlay = Theme {
name: "Overlay".into(),
..Theme::default()
};
base.merge(&overlay);
assert!(base.light.is_some());
assert_eq!(
base.light.as_ref().unwrap().defaults.font.family.as_deref(),
Some("Inter")
);
}
#[test]
fn native_theme_merge_dark_variant() {
let mut base = Theme {
name: "Theme".into(),
..Theme::default()
};
let mut overlay = Theme {
name: "Overlay".into(),
..Theme::default()
};
let mut dark = ThemeMode::default();
dark.defaults.background_color = Some(Rgba::rgb(30, 30, 30));
overlay.dark = Some(dark);
base.merge(&overlay);
assert!(base.dark.is_some());
assert_eq!(
base.dark.as_ref().unwrap().defaults.background_color,
Some(Rgba::rgb(30, 30, 30))
);
}
#[test]
fn native_theme_not_empty_with_light() {
let mut theme = Theme {
name: "Theme".into(),
..Theme::default()
};
theme.light = Some(ThemeMode::default());
assert!(!theme.is_empty());
}
#[test]
fn pick_variant_dark_with_both_variants_returns_dark() {
let mut theme = Theme {
name: "Test".into(),
..Theme::default()
};
let mut light = ThemeMode::default();
light.defaults.background_color = Some(Rgba::rgb(255, 255, 255));
theme.light = Some(light);
let mut dark = ThemeMode::default();
dark.defaults.background_color = Some(Rgba::rgb(30, 30, 30));
theme.dark = Some(dark);
let picked = theme.pick_variant(ColorMode::Dark).unwrap();
assert_eq!(
picked.defaults.background_color,
Some(Rgba::rgb(30, 30, 30))
);
}
#[test]
fn pick_variant_light_with_both_variants_returns_light() {
let mut theme = Theme {
name: "Test".into(),
..Theme::default()
};
let mut light = ThemeMode::default();
light.defaults.background_color = Some(Rgba::rgb(255, 255, 255));
theme.light = Some(light);
let mut dark = ThemeMode::default();
dark.defaults.background_color = Some(Rgba::rgb(30, 30, 30));
theme.dark = Some(dark);
let picked = theme.pick_variant(ColorMode::Light).unwrap();
assert_eq!(
picked.defaults.background_color,
Some(Rgba::rgb(255, 255, 255))
);
}
#[test]
fn pick_variant_dark_with_only_light_falls_back() {
let mut theme = Theme {
name: "Test".into(),
..Theme::default()
};
let mut light = ThemeMode::default();
light.defaults.background_color = Some(Rgba::rgb(255, 255, 255));
theme.light = Some(light);
let picked = theme.pick_variant(ColorMode::Dark).unwrap();
assert_eq!(
picked.defaults.background_color,
Some(Rgba::rgb(255, 255, 255))
);
}
#[test]
fn pick_variant_light_with_only_dark_falls_back() {
let mut theme = Theme {
name: "Test".into(),
..Theme::default()
};
let mut dark = ThemeMode::default();
dark.defaults.background_color = Some(Rgba::rgb(30, 30, 30));
theme.dark = Some(dark);
let picked = theme.pick_variant(ColorMode::Light).unwrap();
assert_eq!(
picked.defaults.background_color,
Some(Rgba::rgb(30, 30, 30))
);
}
#[test]
fn pick_variant_with_no_variants_returns_err() {
let theme = Theme {
name: "Empty".into(),
..Theme::default()
};
assert!(theme.pick_variant(ColorMode::Dark).is_err());
assert!(theme.pick_variant(ColorMode::Light).is_err());
}
#[test]
fn icon_set_default_is_none() {
assert!(Theme::default().icon_set.is_none());
}
#[test]
fn icon_set_merge_overlay() {
let mut base = Theme {
name: "Base".into(),
..Theme::default()
};
let mut overlay = Theme {
name: "Overlay".into(),
..Theme::default()
};
overlay.icon_set = Some(IconSet::Material);
base.merge(&overlay);
assert_eq!(base.icon_set, Some(IconSet::Material));
}
#[test]
fn icon_set_merge_none_preserves() {
let mut base = Theme {
name: "Base".into(),
..Theme::default()
};
base.icon_set = Some(IconSet::SfSymbols);
let overlay = Theme {
name: "Overlay".into(),
..Theme::default()
};
base.merge(&overlay);
assert_eq!(base.icon_set, Some(IconSet::SfSymbols));
}
#[test]
fn icon_set_is_empty_when_set() {
assert!(Theme::default().is_empty());
let mut t = Theme {
name: "Test".into(),
..Theme::default()
};
t.icon_set = Some(IconSet::Material);
assert!(!t.is_empty());
}
#[test]
fn icon_set_toml_round_trip() {
let mut theme = Theme {
name: "Test".into(),
..Theme::default()
};
theme.icon_set = Some(IconSet::Material);
let mut light = ThemeMode::default();
light.defaults.icon_theme = Some("material".into());
theme.light = Some(light);
let toml_str = theme.to_toml().unwrap();
assert!(toml_str.contains("icon_set"));
let deserialized = Theme::from_toml(&toml_str).unwrap();
assert_eq!(deserialized.icon_set, Some(IconSet::Material));
assert_eq!(
deserialized
.light
.as_ref()
.unwrap()
.defaults
.icon_theme
.as_deref(),
Some("material")
);
}
#[test]
fn icon_set_toml_absent_deserializes_to_none() {
let toml_str = r##"
name = "Bare"
[light.defaults]
accent_color = "#ff0000"
"##;
let theme = Theme::from_toml(toml_str).unwrap();
assert!(theme.icon_set.is_none());
assert!(theme.light.as_ref().unwrap().defaults.icon_theme.is_none());
}
#[test]
fn native_theme_serde_toml_round_trip() {
let theme = Theme::preset("material").expect("material preset should load");
let toml_str = theme.to_toml().expect("should serialize");
let theme2 = Theme::from_toml(&toml_str).expect("should deserialize");
assert_eq!(theme, theme2, "round-trip should preserve Theme");
}
#[test]
fn resolve_material_uses_theme_level_icon_theme() {
let theme = Theme::preset("material").unwrap();
for mode in [ColorMode::Light, ColorMode::Dark] {
let r = theme.resolve(mode).unwrap();
assert_eq!(
r.icon_theme.as_deref(),
Some("material"),
"material (tier 2) for {mode:?}"
);
assert!(
r.icon_theme_explicit,
"explicit flag must be true for {mode:?}"
);
assert_eq!(r.icon_set, IconSet::Material);
}
}
#[test]
fn resolve_kde_breeze_uses_per_variant_icon_theme() {
let theme = Theme::preset("kde-breeze").unwrap();
let light = theme.resolve(ColorMode::Light).unwrap();
assert_eq!(light.icon_theme.as_deref(), Some("breeze"));
assert!(light.icon_theme_explicit);
let dark = theme.resolve(ColorMode::Dark).unwrap();
assert_eq!(dark.icon_theme.as_deref(), Some("breeze-dark"));
assert!(dark.icon_theme_explicit);
assert_eq!(light.icon_set, IconSet::Freedesktop);
assert_eq!(dark.icon_set, IconSet::Freedesktop);
}
fn adwaita_without_icon_theme() -> Theme {
let mut theme = Theme::preset("adwaita").unwrap();
theme.icon_theme = None;
if let Some(v) = theme.light.as_mut() {
v.defaults.icon_theme = None;
}
if let Some(v) = theme.dark.as_mut() {
v.defaults.icon_theme = None;
}
theme
}
#[test]
fn resolve_minimal_theme_takes_the_detected_icon_theme() {
let ctx = crate::resolve::ResolutionContext::with_detected_icon_theme(Ok(
"detected-theme".to_string()
));
let r = adwaita_without_icon_theme()
.resolve_in(ColorMode::Light, &ctx)
.unwrap();
assert_eq!(r.icon_theme.as_deref(), Some("detected-theme"));
assert!(
!r.icon_theme_explicit,
"tier 3 fallback must report explicit = false"
);
}
#[test]
fn resolve_minimal_theme_without_detection_has_no_icon_theme() {
let ctx = crate::resolve::ResolutionContext::with_detected_icon_theme(Err(
crate::Error::PlatformUnsupported {
platform: "the test's failing detection",
},
));
let r = adwaita_without_icon_theme()
.resolve_in(ColorMode::Light, &ctx)
.expect("a failed icon-theme detection must not fail resolution");
assert_eq!(r.icon_theme, None);
assert!(!r.icon_theme_explicit);
}
#[test]
fn resolve_minimal_theme_resolves_whatever_detection_gives() {
let r = adwaita_without_icon_theme()
.resolve(ColorMode::Light)
.unwrap();
assert!(!r.icon_theme_explicit);
assert_eq!(
r.icon_theme.as_deref(),
crate::model::icons::system_icon_theme().ok().as_deref()
);
}
#[test]
fn resolve_tier1_wins_over_tier2() {
let mut theme = Theme::preset("adwaita").unwrap();
theme.icon_theme = Some(Cow::Borrowed("theme-level"));
theme.light.as_mut().unwrap().defaults.icon_theme = Some(Cow::Borrowed("per-variant"));
let r = theme.resolve(ColorMode::Light).unwrap();
assert_eq!(r.icon_theme.as_deref(), Some("per-variant"));
assert!(r.icon_theme_explicit);
}
#[test]
fn resolve_cross_mode_fallback_picks_available_variant() {
let mut theme = Theme::preset("adwaita").unwrap();
theme.dark = None;
theme.icon_theme = None;
theme.light.as_mut().unwrap().defaults.icon_theme = Some(Cow::Borrowed("only-one"));
let r = theme.resolve(ColorMode::Dark).unwrap();
assert_eq!(r.icon_theme.as_deref(), Some("only-one"));
assert!(r.icon_theme_explicit);
}
#[test]
fn resolve_empty_theme_returns_no_variant_error() {
let theme = Theme {
name: "Empty".into(),
..Theme::default()
};
assert!(matches!(
theme.resolve(ColorMode::Light),
Err(crate::Error::NoVariant {
mode: ColorMode::Light
})
));
}
#[test]
fn resolve_all_presets_succeed() {
for info in Theme::list_presets() {
let theme = Theme::preset(info.key).unwrap();
for mode in [ColorMode::Light, ColorMode::Dark] {
theme.resolve(mode).unwrap_or_else(|e| {
panic!("preset '{}' failed to resolve({mode:?}): {e}", info.key)
});
}
}
}
#[test]
fn lint_toml_valid_returns_empty() {
let toml = r##"
name = "Valid Theme"
[light.defaults]
accent_color = "#ff0000"
background_color = "#ffffff"
[light.defaults.font]
family = "Inter"
size_px = 14.0
[light.button]
min_height_px = 32.0
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert!(
warnings.is_empty(),
"Expected no warnings, got: {warnings:?}"
);
}
#[test]
fn lint_toml_detects_unknown_top_level() {
let toml = r##"
name = "Test"
theme_version = 2
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("theme_version"));
}
#[test]
fn lint_toml_detects_misspelled_defaults_field() {
let toml = r##"
name = "Test"
[light.defaults]
backround = "#ffffff"
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("backround"));
assert!(warnings[0].contains("light.defaults.backround"));
}
#[test]
fn lint_toml_detects_unknown_widget_field() {
let toml = r##"
name = "Test"
[dark.button]
primary_bg = "#0078d7"
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("primary_bg"));
}
#[test]
fn lint_toml_detects_unknown_variant_section() {
let toml = r##"
name = "Test"
[light.badges]
color = "#ff0000"
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("badges"));
}
#[test]
fn lint_toml_detects_unknown_font_subfield() {
let toml = r##"
name = "Test"
[light.defaults.font]
famly = "Inter"
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("famly"));
}
#[test]
fn lint_toml_detects_unknown_border_subfield() {
let toml = r##"
name = "Test"
[light.defaults.border]
radiusss = 4.0
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("radiusss"));
}
#[test]
fn lint_toml_detects_unknown_text_scale_entry() {
let toml = r##"
name = "Test"
[light.text_scale.headline]
size = 24.0
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("headline"));
}
#[test]
fn lint_toml_detects_unknown_text_scale_entry_field() {
let toml = r##"
name = "Test"
[light.text_scale.caption]
font_size = 12.0
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("font_size"));
}
#[test]
fn lint_toml_multiple_errors() {
let toml = r##"
name = "Test"
author = "Me"
[light.defaults]
backround = "#ffffff"
[light.button]
primay_bg = "#0078d7"
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 3);
}
#[test]
fn lint_toml_invalid_toml_returns_error() {
let result = Theme::lint_toml("{{{{invalid");
assert!(result.is_err());
}
#[test]
fn lint_toml_preset_has_no_warnings() {
let theme = Theme::preset("material").expect("material preset should load");
let toml_str = theme.to_toml().expect("should serialize");
let warnings = Theme::lint_toml(&toml_str).expect("should parse");
assert!(
warnings.is_empty(),
"material preset should have no lint warnings, got: {warnings:?}"
);
}
#[test]
fn lint_toml_all_presets_clean() {
for info in Theme::list_presets() {
let name = info.key;
let theme = Theme::preset(name).unwrap_or_else(|e| {
panic!("preset {name} should load: {e}");
});
let toml_str = theme.to_toml().unwrap_or_else(|e| {
panic!("preset {name} should serialize: {e}");
});
let warnings = Theme::lint_toml(&toml_str).unwrap_or_else(|e| {
panic!("preset {name} should lint: {e}");
});
assert!(
warnings.is_empty(),
"preset {name} should have no lint warnings, got: {warnings:?}"
);
}
}
#[test]
fn lint_toml_accepts_padding_sides_and_shorthand() {
let toml = r##"
name = "Test"
[light.button.border]
padding_top_px = 1.0
padding_right_px = 2.0
padding_bottom_px = 3.0
padding_left_px = 4.0
[light.input.border]
padding_horizontal_px = 6.0
padding_vertical_px = 0.0
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert!(warnings.is_empty(), "got: {warnings:?}");
let warnings =
Theme::lint_toml("name = \"T\"\n[light.input.border]\npadding_sideways_px = 1.0\n")
.unwrap();
assert_eq!(warnings.len(), 1, "got: {warnings:?}");
}
#[test]
fn lint_toml_rejects_unknown_field_on_registered_widget() {
let toml = r##"
name = "Test"
[light.button]
nonexistent_field = "#ff0000"
"##;
let warnings = Theme::lint_toml(toml).unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].contains("nonexistent_field"));
assert!(warnings[0].contains("light.button"));
}
#[test]
fn lint_toml_recognizes_all_registered_widgets() {
for entry in inventory::iter::<crate::resolve::WidgetFieldInfo> {
let toml_str = format!("name = \"Test\"\n[light.{}]\n", entry.widget_name,);
let warnings = Theme::lint_toml(&toml_str).unwrap();
assert!(
warnings.is_empty(),
"widget '{}' should be recognized, got: {:?}",
entry.widget_name,
warnings,
);
}
}
#[test]
fn theme_spec_layout_merge() {
let mut base = Theme {
name: "Base".into(),
..Theme::default()
};
base.layout.widget_gap = Some(6.0);
let mut overlay = Theme {
name: "Overlay".into(),
..Theme::default()
};
overlay.layout.container_margin = Some(8.0);
base.merge(&overlay);
assert_eq!(base.layout.widget_gap, Some(6.0));
assert_eq!(base.layout.container_margin, Some(8.0));
}
#[test]
fn theme_spec_layout_toml_round_trip() {
let mut theme = Theme {
name: "Layout Test".into(),
..Theme::default()
};
theme.layout.widget_gap = Some(8.0);
theme.layout.container_margin = Some(12.0);
theme.layout.window_margin = Some(16.0);
theme.layout.section_gap = Some(24.0);
let toml_str = theme.to_toml().unwrap();
let theme2 = Theme::from_toml(&toml_str).unwrap();
assert_eq!(theme.layout, theme2.layout);
}
#[test]
fn theme_spec_is_empty_with_layout() {
let mut theme = Theme {
name: "Layout Only".into(),
..Theme::default()
};
assert!(theme.is_empty()); theme.layout.widget_gap = Some(8.0);
assert!(!theme.is_empty());
}
#[test]
fn theme_spec_layout_top_level_toml() {
let mut theme = Theme {
name: "Top Level".into(),
..Theme::default()
};
theme.layout.widget_gap = Some(8.0);
let toml_str = theme.to_toml().unwrap();
assert!(
toml_str.contains("[layout]"),
"TOML should have [layout] section"
);
assert!(!toml_str.contains("[light.layout]"));
assert!(!toml_str.contains("[dark.layout]"));
}
fn field_info_entry(name: &'static str) -> Option<&'static [&'static str]> {
inventory::iter::<crate::resolve::FieldInfo>()
.find(|info| info.struct_name == name)
.map(|info| info.field_names)
}
#[test]
fn font_spec_field_info_matches_baseline() {
let baseline: &[&str] = &["family", "size_pt", "size_px", "weight", "style", "color"];
assert_eq!(field_info_entry("FontSpec"), Some(baseline));
}
#[test]
fn text_scale_entry_field_info_matches_baseline() {
let baseline: &[&str] = &[
"size_pt",
"size_px",
"weight",
"line_height_pt",
"line_height_px",
];
assert_eq!(field_info_entry("TextScaleEntry"), Some(baseline));
}
#[test]
fn text_scale_field_info_matches_baseline() {
let baseline: &[&str] = &["caption", "section_heading", "dialog_title", "display"];
assert_eq!(field_info_entry("TextScale"), Some(baseline));
}
#[test]
fn defaults_border_spec_field_info_matches_baseline() {
let baseline: &[&str] = &[
"color",
"corner_radius_px",
"corner_radius_lg_px",
"line_width_px",
"opacity",
"shadow_enabled",
];
assert_eq!(field_info_entry("DefaultsBorderSpec"), Some(baseline));
}
#[test]
fn widget_border_spec_field_info_matches_baseline() {
let baseline: &[&str] = &[
"color",
"corner_radius_px",
"line_width_px",
"shadow_enabled",
"padding_top_px",
"padding_right_px",
"padding_bottom_px",
"padding_left_px",
"padding_horizontal_px",
"padding_vertical_px",
];
assert_eq!(field_info_entry("WidgetBorderSpec"), Some(baseline));
}
#[test]
fn theme_defaults_field_info_matches_baseline() {
let baseline: &[&str] = &[
"font",
"line_height",
"mono_font",
"background_color",
"text_color",
"accent_color",
"accent_text_color",
"surface_color",
"muted_color",
"shadow_color",
"link_color",
"selection_background",
"selection_text_color",
"selection_inactive_background",
"text_selection_background",
"text_selection_color",
"disabled_text_color",
"danger_color",
"danger_text_color",
"warning_color",
"warning_text_color",
"success_color",
"success_text_color",
"info_color",
"info_text_color",
"border",
"disabled_opacity",
"focus_ring_color",
"focus_ring_width_px",
"focus_ring_offset_px",
"icon_sizes",
"icon_theme",
];
assert_eq!(field_info_entry("ThemeDefaults"), Some(baseline));
}
#[test]
fn icon_sizes_field_info_matches_baseline() {
let baseline: &[&str] = &[
"toolbar_px",
"small_px",
"large_px",
"dialog_px",
"panel_px",
];
assert_eq!(field_info_entry("IconSizes"), Some(baseline));
}
#[test]
fn layout_theme_field_info_matches_baseline() {
let baseline: &[&str] = &[
"widget_gap_px",
"container_margin_px",
"window_margin_px",
"section_gap_px",
];
assert_eq!(field_info_entry("LayoutTheme"), Some(baseline));
}
#[test]
fn widget_registry_still_has_all_widgets() {
let widget_count = inventory::iter::<crate::resolve::WidgetFieldInfo>().count();
assert!(
widget_count >= 25,
"expected >=25 widgets in WidgetFieldInfo, got {widget_count}"
);
}
}