use std::cell::Cell;
use gpui::{AnyElement, Context, Subscription, Window, WindowAppearance, prelude::*};
use crate::controls::segmented;
use crate::palette::Palette;
use crate::state::{ComboId, ControlHost};
use crate::swatch::hue_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 scheme: Scheme,
system_dark: bool,
hue_track: Cell<Option<ComboId>>,
appearance: Option<Subscription>,
}
pub const DEFAULT_HUE: f64 = 268.0;
impl Default for Theme {
fn default() -> Self {
Self {
hue: DEFAULT_HUE,
scheme: Scheme::System,
system_dark: false,
hue_track: Cell::new(None),
appearance: 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(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 palette(&self) -> Palette {
Palette::from_hue(self.hue, self.is_dark())
}
}
pub fn system_dark(window: &Window) -> bool {
matches!(
window.appearance(),
WindowAppearance::Dark | WindowAppearance::VibrantDark
)
}
pub fn scheme_picker<V: ControlHost>(
id: ComboId,
palette: Palette,
view: &V,
cx: &mut Context<V>,
) -> AnyElement {
let options: Vec<String> = Scheme::ALL
.iter()
.map(|scheme| scheme.label().to_string())
.collect();
segmented(
id,
&options,
view.control_state().theme.scheme.index(),
true,
palette,
view,
cx,
|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,
palette: Palette,
view: &V,
cx: &mut Context<V>,
) -> impl IntoElement {
let theme = &view.control_state().theme;
theme.hue_track.set(Some(id));
hue_slider(id, theme.hue, palette, view, cx)
}
#[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);
}
}