use crate::definition::ThemeDefinition; use crate::ramps::{AccentShades, Oklch, contrast_foreground, derive_shades, mix}; use crate::system::{SourceKind, SystemTheme}; use crate::{ ColorTokens, CustomTheme, Elevations, MaterialTokens, Motion, Radius, Scrollbar, SizeTable, Spacing, ThemeVariant, Typography, }; use gpui::{WindowBackgroundAppearance, px}; /// Derived state shades for the colors that get pressed and hovered. #[derive(Clone, Copy, Debug, PartialEq)] pub struct Ramps { pub primary: AccentShades, pub secondary: AccentShades, pub destructive: AccentShades, pub success: AccentShades, pub warning: AccentShades, pub info: AccentShades, } /// Everything a component paints from, after the overlay chain. #[derive(Clone, Copy, Debug, PartialEq)] pub struct ResolvedTheme { pub variant: ThemeVariant, pub colors: ColorTokens, /// The translucent paints over the window's native material. pub material: MaterialTokens, pub ramps: Ramps, pub radius: Radius, pub spacing: Spacing, pub elevations: Elevations, pub motion: Motion, pub scrollbar: Scrollbar, /// The height the window's titlebar strips draw at. pub titlebar_height: gpui::Pixels, /// The theme's root font size. pub root_font_size: gpui::Pixels, /// The monospace family, for code surfaces. pub mono_font: &'static str, /// The type ladder, resolved at the root font size. pub typography: Typography, pub sizes: SizeTable, pub accessibility: crate::system::AccessibilityPreferences, /// The material a window should open with, after accessibility. pub window_background: WindowBackgroundAppearance, } /// Overlay order (later wins): /// neutral base → system → preset definition → custom theme. pub(crate) fn resolve( system: &SystemTheme, preset: Option<&ThemeDefinition>, mode_override: Option, custom: Option, ) -> ResolvedTheme { let custom = custom.unwrap_or_default(); let variant = mode_override .or(preset.and_then(|def| def.mode())) .unwrap_or(system.variant); let base = match variant { ThemeVariant::Light => ColorTokens::light(), ThemeVariant::Dark => ColorTokens::dark(), }; let def_color = |field: fn(&ThemeDefinition) -> Option| preset.and_then(field); let accent = def_color(|d| d.accent()) .or(system.accent) .unwrap_or(base.accent); let primary = def_color(|d| d.primary()).unwrap_or(accent); let destructive = def_color(|d| d.destructive()).unwrap_or(base.destructive); let success = def_color(|d| d.success()).unwrap_or(base.success); let warning = def_color(|d| d.warning()).unwrap_or(base.warning); let info = def_color(|d| d.info()).unwrap_or(base.info); let mut colors = ColorTokens { background: def_color(|d| d.background()).unwrap_or(base.background), foreground: def_color(|d| d.foreground()).unwrap_or(base.foreground), surface: def_color(|d| d.surface()).unwrap_or(base.surface), surface_foreground: def_color(|d| d.surface_foreground()) .unwrap_or(base.surface_foreground), sidebar: def_color(|d| d.sidebar()).unwrap_or(base.sidebar), primary, primary_foreground: def_color(|d| d.primary_foreground()) .unwrap_or_else(|| contrast_foreground(primary)), secondary: def_color(|d| d.secondary()).unwrap_or(base.secondary), secondary_foreground: def_color(|d| d.secondary_foreground()) .unwrap_or(base.secondary_foreground), muted: def_color(|d| d.muted()).unwrap_or(base.muted), muted_hover: def_color(|d| d.muted_hover()).unwrap_or(base.muted_hover), muted_foreground: def_color(|d| d.muted_foreground()).unwrap_or(base.muted_foreground), accent, accent_foreground: def_color(|d| d.accent_foreground()) .unwrap_or_else(|| contrast_foreground(accent)), destructive, destructive_foreground: def_color(|d| d.destructive_foreground()) .unwrap_or_else(|| contrast_foreground(destructive)), success, success_foreground: def_color(|d| d.success_foreground()) .unwrap_or_else(|| contrast_foreground(success)), warning, warning_foreground: def_color(|d| d.warning_foreground()) .unwrap_or_else(|| contrast_foreground(warning)), info, info_foreground: def_color(|d| d.info_foreground()) .unwrap_or_else(|| contrast_foreground(info)), border: def_color(|d| d.border()).unwrap_or(base.border), input: def_color(|d| d.input()).unwrap_or(base.input), ring: def_color(|d| d.ring()).unwrap_or(accent), selection: def_color(|d| d.selection()).unwrap_or(base.selection), overlay: def_color(|d| d.overlay()).unwrap_or(base.overlay), scrollbar_thumb: def_color(|d| d.scrollbar_thumb()).unwrap_or(base.scrollbar_thumb), }; // The knob scales the fill over a platform-stated blur. let transparency = custom .transparency .map(|level| level.min(100)) .filter(|_| system.source != SourceKind::Windows && system.window_background.is_some()); // Reduced transparency forces the window opaque. let window_background = if system.accessibility.reduce_transparency || transparency == Some(0) { WindowBackgroundAppearance::Opaque } else { system .window_background .unwrap_or(WindowBackgroundAppearance::Opaque) }; let accessibility = system.accessibility; if accessibility.high_contrast { colors.border = mix( Oklch::from_hsla(colors.border), Oklch::from_hsla(colors.foreground), 0.35, ) .to_hsla(); } // A custom theme's stated font size wins over the 16px design root. let root_font_size = custom.root_font_size.unwrap_or(px(16.)); let sizes = SizeTable::with_root_font_size(root_font_size); let titlebar_height = root_font_size * 2.5; let mut radius = Radius::default(); if let Some(control) = custom .control_radius .or(preset.and_then(|def| def.control_radius()).map(px)) { radius.control = control; } if let Some(overlay) = custom .overlay_radius .or(preset.and_then(|def| def.overlay_radius()).map(px)) { radius.overlay = overlay; } if let Some(sm) = custom .sm_radius .or(preset.and_then(|def| def.sm_radius()).map(px)) { radius.sm = sm; } let ramps = Ramps { primary: derive_shades(primary, colors.background, variant == ThemeVariant::Dark), secondary: derive_shades( colors.secondary, colors.background, variant == ThemeVariant::Dark, ), destructive: derive_shades( destructive, colors.background, variant == ThemeVariant::Dark, ), success: derive_shades(success, colors.background, variant == ThemeVariant::Dark), warning: derive_shades(warning, colors.background, variant == ThemeVariant::Dark), info: derive_shades(info, colors.background, variant == ThemeVariant::Dark), }; if def_color(|d| d.selection()).is_none() { colors.selection = ramps.primary.subtle; } let material = MaterialTokens::derive( &colors, ramps.primary.base, variant, window_background != WindowBackgroundAppearance::Opaque, transparency, ); let default_elevations = Elevations::for_variant(variant); let elevations = Elevations { popover: custom .popover_elevation .unwrap_or(default_elevations.popover), dialog: custom.dialog_elevation.unwrap_or(default_elevations.dialog), control: custom .control_elevation .unwrap_or(default_elevations.control), }; ResolvedTheme { variant, ramps, colors, material, radius, spacing: Spacing { unit: root_font_size * 0.25, }, elevations, motion: Motion::default(), scrollbar: Scrollbar { autohide: system.source.scrollbar_autohide(), ..Scrollbar::default() }, titlebar_height, root_font_size, mono_font: mono_font(), typography: Typography::resolve(root_font_size), sizes, accessibility, window_background, } } /// The platform's monospace family, for code surfaces. fn mono_font() -> &'static str { if cfg!(target_os = "macos") { "Menlo" } else if cfg!(target_os = "windows") { "Consolas" } else { "monospace" } } #[cfg(test)] mod tests { use super::*; use crate::system::{AccessibilityPreferences, SourceKind}; use crate::{Elevation, Shadow}; use gpui::{Rgba, WindowBackgroundAppearance, rgb}; fn hsla(hex: u32) -> gpui::Hsla { gpui::Hsla::from(rgb(hex)) } fn system(variant: ThemeVariant, accent: Option) -> SystemTheme { SystemTheme { variant, accent, accessibility: AccessibilityPreferences::default(), window_background: None, source: SourceKind::Macos, } } #[test] fn empty_system_resolves_to_the_neutral_fallback() { for variant in [ThemeVariant::Light, ThemeVariant::Dark] { let resolved = resolve( &SystemTheme { source: SourceKind::Fallback, ..system(variant, None) }, None, None, None, ); let base = match variant { ThemeVariant::Light => ColorTokens::light(), ThemeVariant::Dark => ColorTokens::dark(), }; assert_eq!(resolved.colors.background, base.background); assert_eq!(resolved.colors.accent, base.accent); assert_eq!(resolved.colors.ring, base.accent); assert_eq!(resolved.ramps.primary.base, base.primary); assert_eq!(resolved.ramps.secondary.base, base.secondary); assert_eq!(resolved.colors.selection, resolved.ramps.primary.subtle); assert_eq!(resolved.radius.sm, px(4.)); assert_eq!(resolved.radius.control, px(6.)); assert_eq!(resolved.radius.overlay, px(10.)); assert_eq!(resolved.root_font_size, px(16.)); assert_eq!(resolved.sizes.medium.control_height, px(32.)); assert_eq!(resolved.sizes.medium.input_height, px(32.)); assert_eq!(resolved.sizes.medium.text_size, px(14.)); assert_eq!(resolved.sizes.small.control_height, px(28.)); assert_eq!(resolved.sizes.small.text_size, px(12.)); assert_eq!(resolved.sizes.small.avatar_size, px(24.)); assert_eq!(resolved.sizes.medium.avatar_size, px(32.)); assert_eq!(resolved.sizes.large.avatar_size, px(40.)); assert_eq!(resolved.sizes.small.caption_size, px(12.)); assert_eq!(resolved.sizes.medium.caption_size, px(12.)); assert_eq!(resolved.sizes.large.caption_size, px(14.)); assert_eq!(resolved.sizes.medium.dense_padding_x, px(8.)); assert_eq!(resolved.sizes.medium.plate_inset, px(2.)); assert_eq!(resolved.sizes.medium.strip_height, px(32.)); assert_eq!(resolved.sizes.medium.icon_size, px(16.)); assert_eq!(resolved.sizes.medium.indicator_size, px(16.)); assert_eq!(resolved.sizes.medium.menu_item_height, px(32.)); assert_eq!(resolved.sizes.large.control_height, px(40.)); assert_eq!(resolved.sizes.large.text_size, px(16.)); assert_eq!(resolved.sizes.medium.switch_height, px(20.)); assert_eq!(resolved.sizes.medium.switch_width, px(36.)); assert_eq!(resolved.sizes.medium.switch_knob, px(14.)); assert_eq!(resolved.spacing.unit, px(4.)); assert_eq!(resolved.titlebar_height, px(40.)); assert_eq!(resolved.typography.body.size, px(16.)); } } #[test] fn scrollbar_autohide_follows_the_platform_source() { let mut stated = system(ThemeVariant::Dark, None); stated.source = SourceKind::Macos; assert!(resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Gnome; assert!(resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Omarchy; assert!(resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Windows; assert!(!resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Kde; assert!(!resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Fallback; assert!(!resolve(&stated, None, None, None).scrollbar.autohide); } #[test] fn accent_drives_primary_ring_and_selection() { let red = hsla(0xdc2626); let resolved = resolve(&system(ThemeVariant::Light, Some(red)), None, None, None); assert_eq!(resolved.colors.accent, red); assert_eq!(resolved.colors.primary, red); assert_eq!(resolved.colors.ring, red); assert_eq!(resolved.ramps.primary.base, red); assert_eq!(resolved.colors.selection, resolved.ramps.primary.subtle); let base = ColorTokens::light(); assert_eq!(resolved.colors.background, base.background); assert_eq!(resolved.colors.foreground, base.foreground); assert_eq!(resolved.colors.border, base.border); } #[test] fn every_source_resolves_the_same_tokens() { let mut stated = system(ThemeVariant::Dark, None); stated.accent = Some(hsla(0x7aa2f7)); stated.window_background = Some(WindowBackgroundAppearance::Blurred); let sources = [ SourceKind::Fallback, SourceKind::Macos, SourceKind::Windows, SourceKind::Gnome, SourceKind::Kde, SourceKind::Omarchy, ]; let first = resolve( &SystemTheme { source: sources[0], ..stated }, None, None, None, ); for source in &sources[1..] { let next = resolve( &SystemTheme { source: *source, ..stated }, None, None, None, ); assert_eq!(next.colors, first.colors, "{source:?}"); assert_eq!(next.radius, first.radius, "{source:?}"); assert_eq!(next.spacing, first.spacing, "{source:?}"); assert_eq!(next.elevations, first.elevations, "{source:?}"); assert_eq!(next.titlebar_height, first.titlebar_height, "{source:?}"); assert_eq!(next.root_font_size, first.root_font_size, "{source:?}"); assert_eq!(next.typography, first.typography, "{source:?}"); assert_eq!(next.sizes, first.sizes, "{source:?}"); } } #[test] fn the_radius_ladder_follows_custom_values_with_preset_priority() { let resolved = resolve(&system(ThemeVariant::Light, None), None, None, None); assert_eq!(resolved.radius.sm, px(4.)); assert_eq!(resolved.radius.control, px(6.)); assert_eq!(resolved.radius.overlay, px(10.)); let def = ThemeDefinition::parse_toml("overlay_radius = 12.0\n").unwrap(); let overridden = resolve(&system(ThemeVariant::Light, None), Some(&def), None, None); assert_eq!(overridden.radius.overlay, px(12.)); assert_eq!(overridden.radius.sm, px(4.)); let custom = CustomTheme { sm_radius: Some(px(2.)), control_radius: Some(px(9.)), ..CustomTheme::default() }; let custom = resolve( &system(ThemeVariant::Light, None), Some(&def), None, Some(custom), ); assert_eq!(custom.radius.sm, px(2.)); assert_eq!(custom.radius.control, px(9.)); assert_eq!(custom.radius.overlay, px(12.)); } #[test] fn elevations_follow_the_variant() { let light = resolve(&system(ThemeVariant::Light, None), None, None, None); assert_eq!(light.elevations.popover.shadows().len(), 2); assert_eq!(light.elevations.dialog.shadows().len(), 2); assert_eq!(light.elevations.control.shadows().len(), 1); let dark = resolve(&system(ThemeVariant::Dark, None), None, None, None); assert!(dark.elevations.popover.shadows().is_empty()); assert!(dark.elevations.dialog.shadows().is_empty()); assert_eq!(dark.elevations.control.shadows().len(), 1); } #[test] fn the_platforms_window_material_resolves_into_the_theme() { let mut stated = system(ThemeVariant::Light, None); stated.window_background = Some(WindowBackgroundAppearance::MicaBackdrop); let resolved = resolve(&stated, None, None, None); assert_eq!( resolved.window_background, WindowBackgroundAppearance::MicaBackdrop ); // Material surfaces stay translucent over the stated backdrop. assert!(resolved.material.background.a < resolved.colors.background.a); assert!(resolved.material.selection.a < 1.0); let unstated = resolve(&system(ThemeVariant::Light, None), None, None, None); assert_eq!( unstated.window_background, WindowBackgroundAppearance::Opaque ); assert_eq!(unstated.material.background, unstated.colors.background); assert_eq!(unstated.material.hover, unstated.colors.muted); assert_eq!(unstated.material.selection, unstated.ramps.primary.base); } #[test] fn reduced_transparency_forces_an_opaque_window_and_material() { let mut stated = system(ThemeVariant::Dark, None); stated.window_background = Some(WindowBackgroundAppearance::Blurred); stated.accessibility.reduce_transparency = true; let resolved = resolve(&stated, None, None, None); assert_eq!( resolved.window_background, WindowBackgroundAppearance::Opaque ); assert_eq!(resolved.material.background, resolved.colors.background); assert_eq!(resolved.material.hover, resolved.colors.muted); assert_eq!(resolved.material.selection, resolved.ramps.primary.base); } #[test] fn a_custom_transparency_level_scales_the_material_fill() { let mut stated = system(ThemeVariant::Dark, None); stated.window_background = Some(WindowBackgroundAppearance::Blurred); let custom = CustomTheme { transparency: Some(80), ..CustomTheme::default() }; let resolved = resolve(&stated, None, None, Some(custom)); assert_eq!( resolved.window_background, WindowBackgroundAppearance::Blurred ); assert!((resolved.material.background.a - 0.32).abs() < 1e-6); // Levels past 100 clamp, bottoming out at the dark floor. let clamped = resolve( &stated, None, None, Some(CustomTheme { transparency: Some(150), ..CustomTheme::default() }), ); assert!((clamped.material.background.a - 0.15).abs() < 1e-6); } #[test] fn light_mode_keeps_a_heavier_fill_at_full_transparency() { let mut light_system = system(ThemeVariant::Light, None); light_system.window_background = Some(WindowBackgroundAppearance::Blurred); let mut dark_system = system(ThemeVariant::Dark, None); dark_system.window_background = Some(WindowBackgroundAppearance::Blurred); let maxed = CustomTheme { transparency: Some(100), ..CustomTheme::default() }; let light = resolve(&light_system, None, None, Some(maxed)); let dark = resolve(&dark_system, None, None, Some(maxed)); assert!((light.material.background.a - 0.45).abs() < 1e-6); assert!((dark.material.background.a - 0.15).abs() < 1e-6); } #[test] fn transparency_zero_opens_an_opaque_window() { let mut stated = system(ThemeVariant::Dark, None); stated.window_background = Some(WindowBackgroundAppearance::Blurred); let resolved = resolve( &stated, None, None, Some(CustomTheme { transparency: Some(0), ..CustomTheme::default() }), ); assert_eq!( resolved.window_background, WindowBackgroundAppearance::Opaque ); assert_eq!(resolved.material.background, resolved.colors.background); assert_eq!(resolved.material.hover, resolved.colors.muted); assert_eq!(resolved.material.selection, resolved.ramps.primary.base); } #[test] fn the_transparency_knob_skips_windows_and_platforms_without_a_material() { let mut windows = system(ThemeVariant::Dark, None); windows.source = SourceKind::Windows; windows.window_background = Some(WindowBackgroundAppearance::MicaBackdrop); let resolved_windows = resolve( &windows, None, None, Some(CustomTheme { transparency: Some(100), ..CustomTheme::default() }), ); assert_eq!( resolved_windows.window_background, WindowBackgroundAppearance::MicaBackdrop ); // The knob's value is ignored on Windows; the default drives the fill. let unset = resolve(&windows, None, None, None); assert_eq!( resolved_windows.material.background, unset.material.background ); let mut unstated = system(ThemeVariant::Dark, None); unstated.window_background = None; let resolved_unstated = resolve( &unstated, None, None, Some(CustomTheme { transparency: Some(100), ..CustomTheme::default() }), ); assert_eq!( resolved_unstated.window_background, WindowBackgroundAppearance::Opaque ); assert_eq!( resolved_unstated.material.background, resolved_unstated.colors.background ); } #[test] fn overlay_is_translucent_and_overridable() { let light = resolve(&system(ThemeVariant::Light, None), None, None, None); let dark = resolve(&system(ThemeVariant::Dark, None), None, None, None); // Both scrims are translucent black; dark is denser for contrast. assert!(light.colors.overlay.a > 0.0 && light.colors.overlay.a < 0.5); assert!(dark.colors.overlay.a > light.colors.overlay.a); let def = ThemeDefinition::parse_toml("overlay = \"#000000\"").unwrap(); let overridden = resolve(&system(ThemeVariant::Light, None), Some(&def), None, None); assert_eq!(overridden.colors.overlay, hsla(0x000000)); assert_eq!(overridden.colors.overlay.a, 1.0); } #[test] fn elevations_and_motion_resolve_with_defaults() { let resolved = resolve(&system(ThemeVariant::Light, None), None, None, None); // The popover shadow is softer and tighter than the dialog's. assert!( resolved.elevations.popover.layers[0].blur_radius < resolved.elevations.dialog.layers[0].blur_radius ); assert!(resolved.motion.overlay > std::time::Duration::ZERO); let shadows = resolved.elevations.popover.shadows(); assert_eq!(shadows.len(), 2); assert!(!shadows[0].inset); } #[test] fn preset_beats_system_and_the_mode_override_beats_everything() { let def = ThemeDefinition::parse_toml( "mode = \"dark\"\nbackground = \"#1a1b26\"\naccent = \"#7aa2f7\"\ncontrol_radius = 12.0\n", ) .unwrap(); let resolved = resolve(&system(ThemeVariant::Light, None), Some(&def), None, None); assert_eq!(resolved.variant, ThemeVariant::Dark); // Compare in RGB space: Hsla round-trips are lossy at low saturation. let bg = Rgba::from(resolved.colors.background); assert!((bg.r - 0x1a as f32 / 255.0).abs() < 0.001); assert!((bg.b - 0x26 as f32 / 255.0).abs() < 0.001); let accent = Rgba::from(resolved.colors.accent); assert!((accent.r - 0x7a as f32 / 255.0).abs() < 0.001); // And the metric override beats the radius default. assert_eq!(resolved.radius.control, px(12.)); let forced = resolve( &system(ThemeVariant::Light, None), Some(&def), Some(ThemeVariant::Light), None, ); assert_eq!(forced.variant, ThemeVariant::Light); // The override flips the variant (and with it the base roles), but // the preset's explicit background still wins over the base. let forced_bg = Rgba::from(forced.colors.background); assert!((forced_bg.r - 0x1a as f32 / 255.0).abs() < 0.001); } #[test] fn an_accent_only_override_derives_foregrounds_and_ramps() { let def = ThemeDefinition::parse_toml("mode = \"dark\"\naccent = \"#7aa2f7\"\n").unwrap(); let resolved = resolve(&system(ThemeVariant::Dark, None), Some(&def), None, None); // The definition sets accent only; primary follows it, and both // foregrounds derive from their own color. let accent = Rgba::from(resolved.colors.accent); assert!((accent.r - 0x7a as f32 / 255.0).abs() < 0.001); assert_eq!(resolved.colors.primary, resolved.colors.accent); assert_eq!(resolved.colors.ring, resolved.colors.accent); assert_eq!(resolved.colors.selection, resolved.ramps.primary.subtle); assert_eq!(resolved.ramps.primary.base, resolved.colors.primary); assert_eq!(resolved.ramps.destructive.base, resolved.colors.destructive); assert_ne!(resolved.ramps.primary.hover, resolved.ramps.primary.base); assert_ne!(resolved.ramps.primary.subtle, resolved.ramps.primary.base); } #[test] fn system_accent_becomes_primary() { let resolved = resolve( &system(ThemeVariant::Dark, Some(hsla(0x7aa2f7))), None, None, None, ); let primary = Rgba::from(resolved.colors.primary); assert!((primary.r - 0x7a as f32 / 255.0).abs() < 0.001); assert_eq!(resolved.ramps.primary.base, resolved.colors.primary); assert_eq!( resolved.colors.primary_foreground, resolved.colors.accent_foreground ); } #[test] fn high_contrast_sharpens_the_border_toward_the_foreground() { let mut a11y = AccessibilityPreferences::default(); let plain = resolve(&system(ThemeVariant::Dark, None), None, None, None); a11y.high_contrast = true; let contrasted = resolve( &SystemTheme { accessibility: a11y, ..system(ThemeVariant::Dark, None) }, None, None, None, ); let plain_border = Oklch::from_hsla(plain.colors.border); let contrasted_border = Oklch::from_hsla(contrasted.colors.border); let foreground_l = Oklch::from_hsla(plain.colors.foreground).l; assert!((contrasted_border.l - foreground_l).abs() < (plain_border.l - foreground_l).abs()); } #[test] fn every_resolved_role_is_distinct_enough_to_paint_with() { for variant in [ThemeVariant::Light, ThemeVariant::Dark] { let resolved = resolve(&system(variant, None), None, None, None); assert_ne!(resolved.colors.background, resolved.colors.foreground); assert_ne!(resolved.colors.border, resolved.colors.background); assert_ne!(resolved.colors.muted_foreground, resolved.colors.foreground); assert!(resolved.colors.ring != resolved.colors.background); } } #[test] fn info_stays_calm_when_the_accent_warms_up() { // The whole point of the info role: a warm platform accent (GNOME // red, Omarchy red themes) must not make Info toasts read as Danger. let red_accent = hsla(0xdc2626); let resolved = resolve( &system(ThemeVariant::Dark, Some(red_accent)), None, None, None, ); assert_eq!(resolved.ramps.primary.base, red_accent); assert_ne!(resolved.colors.info, resolved.colors.destructive); assert_ne!(resolved.ramps.info.base, resolved.ramps.destructive.base); } #[test] fn info_follows_the_preset() { let def = ThemeDefinition::parse_toml("info = \"#0ea5e9\"\n").unwrap(); let resolved = resolve(&system(ThemeVariant::Dark, None), Some(&def), None, None); assert_eq!(resolved.colors.info, hsla(0x0ea5e9)); assert_eq!(resolved.ramps.info.base, hsla(0x0ea5e9)); } #[test] fn a_custom_theme_beats_the_preset_and_defaults() { let def = ThemeDefinition::parse_toml("overlay_radius = 12.0\n").unwrap(); let popover = Elevation::single(Shadow::black(0., 2., 8., 0.3)); let custom = CustomTheme { sm_radius: Some(px(2.)), control_radius: Some(px(4.)), popover_elevation: Some(popover), ..CustomTheme::default() }; let resolved = resolve( &system(ThemeVariant::Light, None), Some(&def), None, Some(custom), ); assert_eq!(resolved.radius.control, px(4.)); assert_eq!(resolved.radius.sm, px(2.)); // Fields the custom theme leaves unstated keep the resolved values. assert_eq!(resolved.radius.overlay, px(12.)); assert_eq!(resolved.elevations.popover, popover); let defaults = Elevations::for_variant(ThemeVariant::Light); assert_eq!(resolved.elevations.dialog, defaults.dialog); assert_eq!(resolved.elevations.control, defaults.control); } #[test] fn a_custom_root_font_size_rescales_the_table() { let custom = CustomTheme { root_font_size: Some(px(20.)), ..CustomTheme::default() }; let resolved = resolve(&system(ThemeVariant::Light, None), None, None, Some(custom)); assert_eq!(resolved.root_font_size, px(20.)); assert_eq!(resolved.sizes.medium.control_height, px(40.)); assert_eq!(resolved.sizes.medium.text_size, px(17.5)); assert_eq!(resolved.spacing.unit, px(5.)); assert_eq!(resolved.titlebar_height, px(50.)); assert_eq!(resolved.typography.body.size, px(20.)); assert_eq!(resolved.typography.large_title.size, px(30.)); } }