use std::cell::Cell;
use gpui::{AnyElement, Subscription, Window, WindowAppearance, prelude::*};
use crate::controls::WidgetContext;
use crate::controls::segmented;
use crate::palette::{DEFAULT_SATURATION, MAX_SATURATION, Palette, normalized_saturation};
use crate::state::{ComboId, ControlHost};
use crate::swatch::{hue_slider, saturation_slider};
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub enum Scheme {
#[default]
System,
Light,
Dark,
}
impl Scheme {
pub const ALL: [Scheme; 3] = [Scheme::System, Scheme::Light, Scheme::Dark];
pub fn label(self) -> &'static str {
match self {
Scheme::System => "System",
Scheme::Light => "Light",
Scheme::Dark => "Dark",
}
}
pub fn index(self) -> usize {
Self::ALL
.iter()
.position(|scheme| *scheme == self)
.unwrap_or(0)
}
pub fn from_index(index: usize) -> Option<Scheme> {
Self::ALL.get(index).copied()
}
}
pub struct Theme {
pub hue: f64,
pub saturation: f64,
pub scheme: Scheme,
system_dark: bool,
hue_track: Cell<Option<ComboId>>,
saturation_track: Cell<Option<ComboId>>,
appearance: Option<Subscription>,
palettes: [Cell<Option<CachedPalette>>; 2],
}
#[derive(Clone, Copy)]
struct CachedPalette {
hue: u64,
saturation: u64,
palette: Palette,
}
pub const DEFAULT_HUE: f64 = 268.0;
impl Default for Theme {
fn default() -> Self {
Self {
hue: DEFAULT_HUE,
saturation: DEFAULT_SATURATION,
scheme: Scheme::System,
system_dark: false,
hue_track: Cell::new(None),
saturation_track: Cell::new(None),
appearance: None,
palettes: [Cell::new(None), Cell::new(None)],
}
}
}
impl Theme {
pub fn is_dark(&self) -> bool {
match self.scheme {
Scheme::System => self.system_dark,
Scheme::Light => false,
Scheme::Dark => true,
}
}
pub fn system_is_dark(&self) -> bool {
self.system_dark
}
pub fn set_system_dark(&mut self, dark: bool) -> bool {
let changed = self.system_dark != dark;
self.system_dark = dark;
changed
}
pub fn hue_track(&self) -> Option<ComboId> {
self.hue_track.get()
}
pub fn saturation_track(&self) -> Option<ComboId> {
self.saturation_track.get()
}
pub(crate) fn apply_track(&mut self, id: ComboId, at: f32) -> bool {
if self.hue_track() == Some(id) {
self.hue = Self::hue_from_track(at);
} else if self.saturation_track() == Some(id) {
self.saturation = Self::saturation_from_track(at);
} else {
return false;
}
true
}
pub(crate) fn keep_appearance(&mut self, subscription: Subscription) {
self.appearance = Some(subscription);
}
pub fn hue_from_track(at: f32) -> f64 {
(f64::from(at) * 360.0).clamp(0.0, 359.9)
}
pub fn saturation_from_track(at: f32) -> f64 {
normalized_saturation(f64::from(at) * MAX_SATURATION)
}
pub fn palette(&self) -> Palette {
self.palette_at(self.hue, self.saturation, self.is_dark())
}
pub(crate) fn palette_at(&self, hue: f64, saturation: f64, dark: bool) -> Palette {
let saturation = normalized_saturation(saturation);
let cache = &self.palettes[usize::from(dark)];
if let Some(cached) = cache.get()
&& cached.hue == hue.to_bits()
&& cached.saturation == saturation.to_bits()
{
return cached.palette;
}
let palette = Palette::from_hue_and_saturation(hue, saturation, dark);
cache.set(Some(CachedPalette {
hue: hue.to_bits(),
saturation: saturation.to_bits(),
palette,
}));
palette
}
}
pub fn system_dark(window: &Window) -> bool {
matches!(
window.appearance(),
WindowAppearance::Dark | WindowAppearance::VibrantDark
)
}
pub fn scheme_picker<V: ControlHost>(id: ComboId, ctx: WidgetContext<'_, '_, '_, V>) -> AnyElement {
let options: Vec<String> = Scheme::ALL
.iter()
.map(|scheme| scheme.label().to_string())
.collect();
let scheme = ctx.state().theme.scheme.index();
segmented(
id,
&options,
scheme,
true,
ctx,
|this, index, _window, cx| {
if let Some(scheme) = Scheme::from_index(index) {
this.control_state_mut().theme.scheme = scheme;
cx.notify();
}
},
)
.into_any_element()
}
pub fn hue_picker<V: ControlHost>(
id: ComboId,
ctx: WidgetContext<'_, '_, '_, V>,
) -> impl IntoElement {
let theme = &ctx.state().theme;
theme.hue_track.set(Some(id));
hue_slider(id, theme.hue, ctx)
}
pub fn saturation_picker<V: ControlHost>(
id: ComboId,
ctx: WidgetContext<'_, '_, '_, V>,
) -> impl IntoElement {
let theme = &ctx.state().theme;
theme.saturation_track.set(Some(id));
saturation_slider(id, theme.saturation, ctx)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn system_follows_the_desktop_and_a_choice_does_not() {
let mut theme = Theme::default();
assert!(!theme.is_dark());
assert!(theme.set_system_dark(true));
assert!(theme.is_dark());
theme.scheme = Scheme::Light;
assert!(!theme.is_dark());
theme.scheme = Scheme::Dark;
theme.set_system_dark(false);
assert!(theme.is_dark());
}
#[test]
fn schemes_round_trip_through_their_index() {
for scheme in Scheme::ALL {
assert_eq!(Scheme::from_index(scheme.index()), Some(scheme));
}
assert_eq!(Scheme::from_index(3), None);
}
#[test]
fn a_track_never_reaches_a_full_turn() {
assert_eq!(Theme::hue_from_track(0.0), 0.0);
assert!(Theme::hue_from_track(1.0) < 360.0);
assert!((Theme::hue_from_track(0.5) - 180.0).abs() < 1e-9);
}
#[test]
fn saturation_tracks_map_the_full_range_and_normalize_invalid_positions() {
for (position, expected) in [
(0.0, 0.0),
(0.25, 0.75),
(0.5, 1.5),
(1.0, MAX_SATURATION),
(-1.0, 0.0),
(2.0, MAX_SATURATION),
(f32::NEG_INFINITY, 0.0),
(f32::INFINITY, MAX_SATURATION),
(f32::NAN, DEFAULT_SATURATION),
] {
assert_eq!(Theme::saturation_from_track(position), expected);
}
}
#[test]
fn bound_tracks_update_their_theme_value_and_leave_other_tracks_to_the_host() {
let mut theme = Theme::default();
theme.hue_track.set(Some("theme-hue"));
theme.saturation_track.set(Some("theme-saturation"));
assert!(theme.apply_track("theme-hue", 0.5));
assert_eq!(theme.hue, 180.0);
assert_eq!(theme.saturation, DEFAULT_SATURATION);
for position in [0.0, 0.5, 1.0] {
assert!(theme.apply_track("theme-saturation", position));
assert_eq!(theme.saturation, Theme::saturation_from_track(position));
assert_eq!(theme.hue, 180.0);
}
assert!(!theme.apply_track("host-slider", 0.0));
assert_eq!(theme.saturation, MAX_SATURATION);
assert_eq!(theme.hue, 180.0);
}
#[test]
fn saturation_animates_programmatic_changes_and_snaps_during_its_own_drag() {
for scheme in [Scheme::Light, Scheme::Dark] {
let mut state = crate::ControlState::new();
state.theme.scheme = scheme;
state.theme.saturation_track.set(Some("saturation"));
let initial = state.palette();
state.theme.saturation = 0.0;
assert_eq!(state.palette(), initial);
assert!(state.animating());
state.begin_track_drag("saturation", crate::state::TrackAxis::Horizontal, None);
assert_eq!(state.palette(), state.theme.palette());
state.theme.saturation = MAX_SATURATION;
assert_eq!(state.palette(), state.theme.palette());
state.end_drag();
assert_eq!(state.palette(), state.theme.palette());
let settled = state.palette();
state.begin_track_drag("unrelated", crate::state::TrackAxis::Horizontal, None);
state.theme.saturation = 0.0;
assert_eq!(state.palette(), settled);
}
}
#[test]
fn palette_cache_tracks_direct_hue_saturation_and_scheme_changes() {
let mut theme = Theme::default();
assert_eq!(theme.palette(), Palette::from_hue(DEFAULT_HUE, false));
theme.hue = 37.25;
assert_eq!(theme.palette(), Palette::from_hue(37.25, false));
theme.scheme = Scheme::Dark;
assert_eq!(theme.palette(), Palette::from_hue(37.25, true));
theme.hue = 201.5;
assert_eq!(theme.palette(), Palette::from_hue(201.5, true));
theme.scheme = Scheme::System;
assert_eq!(theme.palette(), Palette::from_hue(201.5, false));
theme.set_system_dark(true);
assert_eq!(theme.palette(), Palette::from_hue(201.5, true));
for saturation in [0.0, 0.5, MAX_SATURATION, DEFAULT_SATURATION] {
theme.saturation = saturation;
for scheme in [Scheme::Light, Scheme::Dark] {
theme.scheme = scheme;
assert_eq!(
theme.palette(),
Palette::from_hue_and_saturation(201.5, saturation, theme.is_dark())
);
}
}
theme.saturation = f64::NAN;
assert_eq!(theme.palette(), Palette::from_hue(201.5, true));
}
}