From 0c3a4211ef20c7d17d8616d5f95e8e18c7897c08 Mon Sep 17 00:00:00 2001 From: Ren Amamiya Date: Wed, 11 Nov 2026 07:53:46 +0700 Subject: [PATCH] theme: add custom theme layered --- crates/theme/src/lib.rs | 195 +++++++++++++++++++++--------------- crates/theme/src/resolve.rs | 156 ++++++++++++++++++++++------- 2 files changed, 232 insertions(+), 119 deletions(-) diff --git a/crates/theme/src/lib.rs b/crates/theme/src/lib.rs index e0ec57f..a1e0e0d 100644 --- a/crates/theme/src/lib.rs +++ b/crates/theme/src/lib.rs @@ -130,6 +130,16 @@ impl ThemeVariant { } } +/// A named control size class. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub enum Size { + Small, + /// The default. + #[default] + Medium, + Large, +} + /// The resolved theme, installed as the app-wide global. #[derive(Clone, Copy, Debug, PartialEq)] pub struct Theme { @@ -161,6 +171,63 @@ pub struct Theme { impl Global for Theme {} +impl Theme { + /// Reads the theme global. Panics before `init`. + pub fn global(cx: &App) -> &Self { + cx.global::() + } + + fn from_resolved(resolved: ResolvedTheme) -> Self { + Self { + variant: resolved.variant, + colors: resolved.colors, + material: resolved.material, + ramps: resolved.ramps, + radius: resolved.radius, + borders: resolved.borders, + spacing: resolved.spacing, + elevations: resolved.elevations, + motion: resolved.motion, + scrollbar: resolved.scrollbar, + titlebar_height: resolved.titlebar_height, + root_font_size: resolved.root_font_size, + mono_font: resolved.mono_font, + sizes: resolved.sizes, + accessibility: resolved.accessibility, + window_background: resolved.window_background, + } + } + + /// Installs the engine global, its platform watchers, and the initial resolved theme. + pub fn init(cx: &mut App) { + let mut engine = ThemeEngine { + source: source::platform_source(), + mode_override: None, + preset: None, + custom: None, + }; + engine.source.install_watchers(cx.to_async()); + cx.set_global(engine); + reapply(cx); + } + + /// Synchronizes the theme from the window's appearance. + pub fn sync_from_window(window: &mut gpui::Window, cx: &mut App) { + let window_variant = ThemeVariant::from_appearance(window.appearance()); + let theme = cx.global::(); + let engine = cx.global::(); + if engine.mode_override.is_none() && theme.variant != window_variant { + reapply(cx); + } + } + + /// Sizes the window's rem to the theme's root font size. + pub fn sync_window_rem_size(window: &mut gpui::Window, cx: &App) { + let theme = cx.global::(); + window.set_rem_size(theme.root_font_size); + } +} + /// Corner radii components paint from; grows one class at a time. #[derive(Clone, Copy, Debug, PartialEq)] pub struct Radius { @@ -408,16 +475,6 @@ impl Default for Scrollbar { } } -/// A named control size class. -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -pub enum Size { - Small, - /// The default. - #[default] - Medium, - Large, -} - /// The control metrics for one size class. #[derive(Clone, Copy, Debug, PartialEq)] pub struct ControlMetrics { @@ -592,6 +649,28 @@ impl SizeTable { } } +/// User customizations layered over the resolved theme. +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct CustomTheme { + pub root_font_size: Option, + pub sm_radius: Option, + pub control_radius: Option, + pub overlay_radius: Option, + pub popover_elevation: Option, + pub dialog_elevation: Option, + pub control_elevation: Option, +} + +/// The engine's knobs and its platform source. +struct ThemeEngine { + source: Box, + mode_override: Option, + preset: Option<(&'static str, ThemeDefinition)>, + custom: Option, +} + +impl Global for ThemeEngine {} + /// Reads the resolved theme global from any app context. pub trait ActiveTheme { fn theme(&self) -> &Theme; @@ -603,89 +682,26 @@ impl ActiveTheme for App { } } -impl Theme { - /// Reads the theme global. Panics before `init`. - pub fn global(cx: &App) -> &Self { - cx.global::() - } - - fn from_resolved(resolved: ResolvedTheme) -> Self { - Self { - variant: resolved.variant, - colors: resolved.colors, - material: resolved.material, - ramps: resolved.ramps, - radius: resolved.radius, - borders: resolved.borders, - spacing: resolved.spacing, - elevations: resolved.elevations, - motion: resolved.motion, - scrollbar: resolved.scrollbar, - titlebar_height: resolved.titlebar_height, - root_font_size: resolved.root_font_size, - mono_font: resolved.mono_font, - sizes: resolved.sizes, - accessibility: resolved.accessibility, - window_background: resolved.window_background, - } - } - - /// Installs the engine global, its platform watchers, and the initial resolved theme. - pub fn init(cx: &mut App) { - let mut engine = ThemeEngine { - source: source::platform_source(), - mode_override: None, - preset: None, - }; - engine.source.install_watchers(cx.to_async()); - cx.set_global(engine); - reapply(cx); - } - - /// Re-resolves when no override is set and a window's appearance differs - /// from the resolved variant; an override pins the variant instead. - /// - /// Wire to `Window::observe_window_appearance`. - pub fn sync_from_window(window: &mut gpui::Window, cx: &mut App) { - let window_variant = ThemeVariant::from_appearance(window.appearance()); - let theme = cx.global::(); - let engine = cx.global::(); - if engine.mode_override.is_none() && theme.variant != window_variant { - reapply(cx); - } - } - - /// Sizes the window's rem to the theme's root font size. - pub fn sync_window_rem_size(window: &mut gpui::Window, cx: &App) { - let theme = cx.global::(); - window.set_rem_size(theme.root_font_size); - } -} - -/// The engine's knobs and its platform source. -struct ThemeEngine { - source: Box, - mode_override: Option, - preset: Option<(&'static str, ThemeDefinition)>, -} - -impl Global for ThemeEngine {} - -/// Reads the system, resolves through the current knobs, -/// installs the theme global, and repaints every window. +/// Reapplies the theme to the application. pub(crate) fn reapply(cx: &mut App) { - let (preset, mode_override, system) = { + let (preset, mode_override, custom, system) = { let engine = cx.global::(); let system_appearance = ThemeVariant::from_appearance(cx.window_appearance()); let preset = engine.preset.as_ref().map(|(_, def)| def.clone()); let mode_override = engine.mode_override; + let custom = engine.custom; let variant = mode_override .or(preset.as_ref().and_then(|def| def.mode())) .unwrap_or(system_appearance); - (preset, mode_override, engine.source.snapshot(variant)) + ( + preset, + mode_override, + custom, + engine.source.snapshot(variant), + ) }; - let resolved = resolve::resolve(&system, preset.as_ref(), mode_override); + let resolved = resolve::resolve(&system, preset.as_ref(), mode_override, custom); cx.set_reduce_motion(resolved.accessibility.reduce_motion); cx.set_global(Theme::from_resolved(resolved)); @@ -717,12 +733,25 @@ pub fn set_preset(name: Option<&str>, cx: &mut App) -> anyhow::Result<()> { Ok(()) } +/// Installs the user's custom theme, or `None` to follow the current scheme. +pub fn set_custom_theme(custom: Option, cx: &mut App) { + let engine = cx.global_mut::(); + engine.custom = custom; + reapply(cx); +} + /// The variant the mode override forces, if any. pub fn mode_override(cx: &App) -> Option { let engine = cx.global::(); engine.mode_override } +/// The installed custom theme, if any. +pub fn custom_theme(cx: &App) -> Option { + let engine = cx.global::(); + engine.custom +} + /// The active preset name, if one is installed. pub fn active_preset(cx: &App) -> Option<&'static str> { let engine = cx.global::(); diff --git a/crates/theme/src/resolve.rs b/crates/theme/src/resolve.rs index 6eb9cc4..5cf164c 100644 --- a/crates/theme/src/resolve.rs +++ b/crates/theme/src/resolve.rs @@ -2,8 +2,8 @@ use crate::definition::ThemeDefinition; use crate::ramps::{AccentShades, Oklch, contrast_foreground, derive_shades, mix}; use crate::system::SystemTheme; use crate::{ - Borders, ColorTokens, Elevations, MaterialTokens, Motion, Radius, Scrollbar, SizeTable, - Spacing, ThemeVariant, + Borders, ColorTokens, CustomTheme, Elevations, MaterialTokens, Motion, Radius, Scrollbar, + SizeTable, Spacing, ThemeVariant, }; use gpui::{WindowBackgroundAppearance, px}; @@ -48,12 +48,16 @@ pub struct ResolvedTheme { pub window_background: WindowBackgroundAppearance, } -/// Overlay order (later wins): neutral base → system → preset definition. +/// 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); @@ -212,10 +216,16 @@ pub(crate) fn resolve( } // The platform's root font size scales every control metric: - // a medium control's label is exactly the root font size. + // - A medium control's label is exactly the root font size. + // - A custom theme's stated font size wins over the platform's. // // Fallback: 16 (the web default gpui also uses for rems). - let root_font_size = system.root_font_size.unwrap_or(px(16.)); + let root_font_size = custom + .root_font_size + .or(system.root_font_size) + .unwrap_or(px(16.)); + + // Initialize sizes with the resolved root font size. let mut sizes = SizeTable::with_root_font_size(root_font_size); if let Some(control_height) = system.control_height { @@ -245,25 +255,25 @@ pub(crate) fn resolve( let mut radius = Radius::default(); - if let Some(control) = preset - .and_then(|def| def.control_radius()) - .map(px) + if let Some(control) = custom + .control_radius + .or(preset.and_then(|def| def.control_radius()).map(px)) .or(system.control_radius) { radius.control = control; } - if let Some(overlay) = preset - .and_then(|def| def.overlay_radius()) - .map(px) + if let Some(overlay) = custom + .overlay_radius + .or(preset.and_then(|def| def.overlay_radius()).map(px)) .or(system.overlay_radius) { radius.overlay = overlay; } - if let Some(sm) = preset - .and_then(|def| def.sm_radius()) - .map(px) + if let Some(sm) = custom + .sm_radius + .or(preset.and_then(|def| def.sm_radius()).map(px)) .or(system.sm_radius) { radius.sm = sm; @@ -293,6 +303,19 @@ pub(crate) fn resolve( window_background != WindowBackgroundAppearance::Opaque, ); + let platform_elevations = Elevations::for_platform(system.source, variant); + let elevations = Elevations { + popover: custom + .popover_elevation + .unwrap_or(platform_elevations.popover), + dialog: custom + .dialog_elevation + .unwrap_or(platform_elevations.dialog), + control: custom + .control_elevation + .unwrap_or(platform_elevations.control), + }; + ResolvedTheme { variant, ramps, @@ -303,7 +326,7 @@ pub(crate) fn resolve( spacing: Spacing { unit: system.source.spacing_unit(), }, - elevations: Elevations::for_platform(system.source, variant), + elevations, motion: Motion::default(), scrollbar: Scrollbar { autohide: system.source.scrollbar_autohide(), @@ -333,6 +356,7 @@ fn mono_font() -> &'static str { mod tests { use super::*; use crate::system::{AccessibilityPreferences, PartialPalette, SourceKind}; + use crate::{Elevation, Shadow}; use gpui::{Rgba, WindowBackgroundAppearance, rgb}; fn hsla(hex: u32) -> gpui::Hsla { @@ -375,6 +399,7 @@ mod tests { }, None, None, + None, ); let base = match variant { ThemeVariant::Light => ColorTokens::light(), @@ -422,7 +447,7 @@ mod tests { fn a_stated_titlebar_height_wins_over_the_control_scale() { let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None); stated.titlebar_height = Some(px(32.)); - assert_eq!(resolve(&stated, None, None).titlebar_height, px(32.)); + assert_eq!(resolve(&stated, None, None, None).titlebar_height, px(32.)); } #[test] @@ -430,7 +455,7 @@ mod tests { // macOS states 13pt; the medium control shrinks to native proportions. let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None); stated.root_font_size = Some(px(13.)); - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); assert_eq!(resolved.root_font_size, px(13.)); assert_eq!(resolved.sizes.medium.control_height, px(22.75)); assert_eq!(resolved.sizes.medium.text_size, px(13.)); @@ -441,29 +466,29 @@ mod tests { fn scrollbar_autohide_follows_the_platform_source() { let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None); stated.source = SourceKind::Macos; - assert!(resolve(&stated, None, None).scrollbar.autohide); + assert!(resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Gnome; - assert!(resolve(&stated, None, None).scrollbar.autohide); + assert!(resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Omarchy; - assert!(resolve(&stated, None, None).scrollbar.autohide); + assert!(resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Windows; - assert!(!resolve(&stated, None, None).scrollbar.autohide); + assert!(!resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Kde; - assert!(!resolve(&stated, None, None).scrollbar.autohide); + assert!(!resolve(&stated, None, None, None).scrollbar.autohide); stated.source = SourceKind::Fallback; - assert!(!resolve(&stated, None, None).scrollbar.autohide); + assert!(!resolve(&stated, None, None, None).scrollbar.autohide); } #[test] fn a_stated_input_height_overrides_the_derived_one_and_scales() { let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None); stated.input_height = Some(px(24.)); - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); assert_eq!(resolved.sizes.medium.input_height, px(24.)); let derived = SizeTable::with_root_font_size(px(16.)); let scale = px(24.) / derived.medium.input_height; @@ -475,7 +500,7 @@ mod tests { fn a_stated_control_height_overrides_the_medium_class_and_scales() { let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None); stated.control_height = Some(px(32.)); - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); assert_eq!(resolved.sizes.medium.control_height, px(32.)); let derived = SizeTable::with_root_font_size(px(16.)); @@ -493,7 +518,7 @@ mod tests { stated.switch_width = Some(px(40.)); stated.switch_knob = Some(px(12.)); stated.menu_item_height = Some(px(33.)); - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); assert_eq!(resolved.sizes.medium.switch_height, px(20.)); assert_eq!(resolved.sizes.medium.switch_width, px(40.)); @@ -507,13 +532,13 @@ mod tests { stated.control_radius = Some(px(9.)); stated.overlay_radius = Some(px(15.)); stated.sm_radius = Some(px(6.)); - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); assert_eq!(resolved.radius.control, px(9.)); assert_eq!(resolved.radius.overlay, px(15.)); assert_eq!(resolved.radius.sm, px(6.)); let def = ThemeDefinition::parse_toml("overlay_radius = 12.0\n").unwrap(); - let overridden = resolve(&stated, Some(&def), None); + let overridden = resolve(&stated, Some(&def), None, None); assert_eq!(overridden.radius.overlay, px(12.)); assert_eq!(overridden.radius.sm, px(6.)); } @@ -523,7 +548,7 @@ mod tests { let chrome = |source| { let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None); stated.source = source; - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); (resolved.borders, resolved.spacing.unit) }; @@ -555,7 +580,7 @@ mod tests { for source in [SourceKind::Macos, SourceKind::Gnome, SourceKind::Omarchy] { let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None); stated.source = source; - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); assert!( resolved.borders.overlays, "{source:?} frames floating layers in dark" @@ -569,7 +594,7 @@ mod tests { fn the_platforms_window_material_resolves_into_the_theme() { let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None); stated.window_background = Some(WindowBackgroundAppearance::MicaBackdrop); - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); assert_eq!( resolved.window_background, @@ -583,6 +608,7 @@ mod tests { &system(ThemeVariant::Light, PartialPalette::default(), None), None, None, + None, ); assert_eq!( unstated.window_background, @@ -598,7 +624,7 @@ mod tests { let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None); stated.window_background = Some(WindowBackgroundAppearance::Blurred); stated.accessibility.reduce_transparency = true; - let resolved = resolve(&stated, None, None); + let resolved = resolve(&stated, None, None, None); assert_eq!( resolved.window_background, @@ -615,11 +641,13 @@ mod tests { &system(ThemeVariant::Light, PartialPalette::default(), None), None, None, + None, ); let dark = resolve( &system(ThemeVariant::Dark, PartialPalette::default(), None), None, None, + None, ); // Both scrims are translucent black; dark is denser for contrast. @@ -631,6 +659,7 @@ mod tests { &system(ThemeVariant::Light, PartialPalette::default(), None), Some(&def), None, + None, ); assert_eq!(overridden.colors.overlay, hsla(0x000000)); assert_eq!(overridden.colors.overlay.a, 1.0); @@ -642,6 +671,7 @@ mod tests { &system(ThemeVariant::Light, PartialPalette::default(), None), None, None, + None, ); // The popover shadow is softer and tighter than the dialog's. @@ -660,7 +690,7 @@ mod tests { let popover = |source| { let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None); stated.source = source; - resolve(&stated, None, None).elevations.popover + resolve(&stated, None, None, None).elevations.popover }; // macOS paints a soft layered stack; Linux keeps a compact single one. @@ -675,7 +705,7 @@ mod tests { let dark = |source| { let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None); stated.source = source; - resolve(&stated, None, None).elevations + resolve(&stated, None, None, None).elevations }; assert_eq!(dark(SourceKind::Macos), dark(SourceKind::Windows)); assert_eq!(dark(SourceKind::Macos), dark(SourceKind::Fallback)); @@ -692,6 +722,7 @@ mod tests { &system(ThemeVariant::Dark, palette, Some(hsla(0xff8800))), None, None, + None, ); assert_eq!(resolved.colors.background, hsla(0x112233)); assert_eq!(resolved.colors.border, hsla(0x445566)); @@ -711,6 +742,7 @@ mod tests { &system(ThemeVariant::Light, palette, Some(hsla(0xffd60a))), None, None, + None, ); assert_eq!(resolved.colors.accent, hsla(0xffd60a)); assert_eq!(resolved.colors.accent_foreground, hsla(0xffffff)); @@ -723,6 +755,7 @@ mod tests { ), None, None, + None, ); assert_eq!(derived.colors.accent_foreground, hsla(0x000000)); } @@ -741,6 +774,7 @@ mod tests { &system(ThemeVariant::Light, palette, None), Some(&def), None, + None, ); assert_eq!(resolved.variant, ThemeVariant::Dark); // Compare in RGB space: Hsla round-trips are lossy at low saturation. @@ -756,6 +790,7 @@ mod tests { &system(ThemeVariant::Light, palette, 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 @@ -771,6 +806,7 @@ mod tests { &system(ThemeVariant::Dark, PartialPalette::default(), None), Some(&def), None, + None, ); // The definition sets accent only; primary still falls back to the // dark base. accent_foreground/primary_foreground are derived per @@ -798,6 +834,7 @@ mod tests { ), None, None, + None, ); let primary = Rgba::from(resolved.colors.primary); assert!((primary.r - 0x7a as f32 / 255.0).abs() < 0.001); @@ -815,6 +852,7 @@ mod tests { &system(ThemeVariant::Dark, PartialPalette::default(), None), None, None, + None, ); a11y.high_contrast = true; let contrasted = resolve( @@ -824,6 +862,7 @@ mod tests { }, None, None, + None, ); let plain_border = Oklch::from_hsla(plain.colors.border); let contrasted_border = Oklch::from_hsla(contrasted.colors.border); @@ -838,6 +877,7 @@ mod tests { &system(variant, PartialPalette::default(), None), None, None, + None, ); assert_ne!(resolved.colors.background, resolved.colors.foreground); assert_ne!(resolved.colors.border, resolved.colors.background); @@ -859,6 +899,7 @@ mod tests { ), None, None, + None, ); assert_eq!(resolved.ramps.primary.base, red_accent); assert_ne!(resolved.colors.info, resolved.colors.destructive); @@ -871,12 +912,55 @@ mod tests { info: Some(hsla(0x155e75)), ..PartialPalette::default() }; - let system_stated = resolve(&system(ThemeVariant::Dark, palette, None), None, None); + let system_stated = resolve(&system(ThemeVariant::Dark, palette, None), None, None, None); assert_eq!(system_stated.colors.info, hsla(0x155e75)); assert_eq!(system_stated.ramps.info.base, hsla(0x155e75)); let def = ThemeDefinition::parse_toml("info = \"#0ea5e9\"\n").unwrap(); - let preset_stated = resolve(&system(ThemeVariant::Dark, palette, None), Some(&def), None); + let preset_stated = resolve( + &system(ThemeVariant::Dark, palette, None), + Some(&def), + None, + None, + ); assert_eq!(preset_stated.colors.info, hsla(0x0ea5e9)); } + + #[test] + fn a_custom_theme_beats_preset_system_and_platform() { + let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None); + stated.control_radius = Some(px(9.)); + 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(&stated, 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 platform = Elevations::for_platform(stated.source, ThemeVariant::Light); + assert_eq!(resolved.elevations.dialog, platform.dialog); + assert_eq!(resolved.elevations.control, platform.control); + } + + #[test] + fn a_custom_root_font_size_beats_the_platform_and_rescales_the_table() { + let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None); + stated.root_font_size = Some(px(13.)); + let custom = CustomTheme { + root_font_size: Some(px(20.)), + ..CustomTheme::default() + }; + let resolved = resolve(&stated, None, None, Some(custom)); + assert_eq!(resolved.root_font_size, px(20.)); + assert_eq!(resolved.sizes.medium.control_height, px(35.)); + assert_eq!(resolved.sizes.medium.text_size, px(20.)); + assert_eq!(resolved.titlebar_height, px(35.)); + } }