Marshall Bowers
c5a23faf7c
This PR makes it so the One themes—One Dark and One Light—are used as a fallback when trying to reload a theme that no longer exists in the registry. This makes it so when an extension providing the current theme is removed, the active theme will change to either One Dark or One Light (based on the system appearance) instead of retaining a cached version of the theme. Release Notes: - Changed the behavior when uninstalling a theme to default to One Dark or One Light (based on system appearance) rather than keeping a cached version of the old theme.
434 lines
14 KiB
Rust
434 lines
14 KiB
Rust
use crate::one_themes::one_dark;
|
|
use crate::{Appearance, SyntaxTheme, Theme, ThemeRegistry, ThemeStyleContent};
|
|
use anyhow::Result;
|
|
use derive_more::{Deref, DerefMut};
|
|
use gpui::{
|
|
px, AppContext, Font, FontFeatures, FontStyle, FontWeight, Global, Pixels, Subscription,
|
|
ViewContext,
|
|
};
|
|
use refineable::Refineable;
|
|
use schemars::{
|
|
gen::SchemaGenerator,
|
|
schema::{InstanceType, Schema, SchemaObject},
|
|
JsonSchema,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::Value;
|
|
use settings::{Settings, SettingsJsonSchemaParams};
|
|
use std::sync::Arc;
|
|
use util::ResultExt as _;
|
|
|
|
const MIN_FONT_SIZE: Pixels = px(6.0);
|
|
const MIN_LINE_HEIGHT: f32 = 1.0;
|
|
|
|
#[derive(Clone)]
|
|
pub struct ThemeSettings {
|
|
pub ui_font_size: Pixels,
|
|
pub ui_font: Font,
|
|
pub buffer_font: Font,
|
|
pub buffer_font_size: Pixels,
|
|
pub buffer_line_height: BufferLineHeight,
|
|
pub theme_selection: Option<ThemeSelection>,
|
|
pub active_theme: Arc<Theme>,
|
|
pub theme_overrides: Option<ThemeStyleContent>,
|
|
}
|
|
|
|
impl ThemeSettings {
|
|
/// Reloads the current theme.
|
|
///
|
|
/// Reads the [`ThemeSettings`] to know which theme should be loaded,
|
|
/// taking into account the current [`SystemAppearance`].
|
|
pub fn reload_current_theme(cx: &mut AppContext) {
|
|
let mut theme_settings = ThemeSettings::get_global(cx).clone();
|
|
let system_appearance = SystemAppearance::global(cx);
|
|
|
|
if let Some(theme_selection) = theme_settings.theme_selection.clone() {
|
|
let mut theme_name = theme_selection.theme(*system_appearance);
|
|
|
|
// If the selected theme doesn't exist, fall back to a default theme
|
|
// based on the system appearance.
|
|
let theme_registry = ThemeRegistry::global(cx);
|
|
if theme_registry.get(&theme_name).ok().is_none() {
|
|
theme_name = match *system_appearance {
|
|
Appearance::Light => "One Light",
|
|
Appearance::Dark => "One Dark",
|
|
};
|
|
};
|
|
|
|
if let Some(_theme) = theme_settings.switch_theme(&theme_name, cx) {
|
|
ThemeSettings::override_global(theme_settings, cx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The appearance of the system.
|
|
#[derive(Debug, Clone, Copy, Deref)]
|
|
pub struct SystemAppearance(pub Appearance);
|
|
|
|
impl Default for SystemAppearance {
|
|
fn default() -> Self {
|
|
Self(Appearance::Dark)
|
|
}
|
|
}
|
|
|
|
#[derive(Deref, DerefMut, Default)]
|
|
struct GlobalSystemAppearance(SystemAppearance);
|
|
|
|
impl Global for GlobalSystemAppearance {}
|
|
|
|
impl SystemAppearance {
|
|
/// Initializes the [`SystemAppearance`] for the application.
|
|
pub fn init(cx: &mut AppContext) {
|
|
*cx.default_global::<GlobalSystemAppearance>() =
|
|
GlobalSystemAppearance(SystemAppearance(cx.window_appearance().into()));
|
|
}
|
|
|
|
/// Returns the global [`SystemAppearance`].
|
|
///
|
|
/// Inserts a default [`SystemAppearance`] if one does not yet exist.
|
|
pub(crate) fn default_global(cx: &mut AppContext) -> Self {
|
|
cx.default_global::<GlobalSystemAppearance>().0
|
|
}
|
|
|
|
/// Returns the global [`SystemAppearance`].
|
|
pub fn global(cx: &AppContext) -> Self {
|
|
cx.global::<GlobalSystemAppearance>().0
|
|
}
|
|
|
|
/// Returns a mutable reference to the global [`SystemAppearance`].
|
|
pub fn global_mut(cx: &mut AppContext) -> &mut Self {
|
|
cx.global_mut::<GlobalSystemAppearance>()
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub(crate) struct AdjustedBufferFontSize(Pixels);
|
|
|
|
impl Global for AdjustedBufferFontSize {}
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
|
|
#[serde(untagged)]
|
|
pub enum ThemeSelection {
|
|
Static(#[schemars(schema_with = "theme_name_ref")] String),
|
|
Dynamic {
|
|
#[serde(default)]
|
|
mode: ThemeMode,
|
|
#[schemars(schema_with = "theme_name_ref")]
|
|
light: String,
|
|
#[schemars(schema_with = "theme_name_ref")]
|
|
dark: String,
|
|
},
|
|
}
|
|
|
|
fn theme_name_ref(_: &mut SchemaGenerator) -> Schema {
|
|
Schema::new_ref("#/definitions/ThemeName".into())
|
|
}
|
|
|
|
#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum ThemeMode {
|
|
/// Use the specified `light` theme.
|
|
Light,
|
|
|
|
/// Use the specified `dark` theme.
|
|
Dark,
|
|
|
|
/// Use the theme based on the system's appearance.
|
|
#[default]
|
|
System,
|
|
}
|
|
|
|
impl ThemeSelection {
|
|
pub fn theme(&self, system_appearance: Appearance) -> &str {
|
|
match self {
|
|
Self::Static(theme) => theme,
|
|
Self::Dynamic { mode, light, dark } => match mode {
|
|
ThemeMode::Light => light,
|
|
ThemeMode::Dark => dark,
|
|
ThemeMode::System => match system_appearance {
|
|
Appearance::Light => light,
|
|
Appearance::Dark => dark,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
|
|
pub struct ThemeSettingsContent {
|
|
#[serde(default)]
|
|
pub ui_font_size: Option<f32>,
|
|
#[serde(default)]
|
|
pub ui_font_family: Option<String>,
|
|
#[serde(default)]
|
|
pub ui_font_features: Option<FontFeatures>,
|
|
#[serde(default)]
|
|
pub buffer_font_family: Option<String>,
|
|
#[serde(default)]
|
|
pub buffer_font_size: Option<f32>,
|
|
#[serde(default)]
|
|
pub buffer_line_height: Option<BufferLineHeight>,
|
|
#[serde(default)]
|
|
pub buffer_font_features: Option<FontFeatures>,
|
|
#[serde(default)]
|
|
pub theme: Option<ThemeSelection>,
|
|
|
|
/// EXPERIMENTAL: Overrides for the current theme.
|
|
///
|
|
/// These values will override the ones on the current theme specified in `theme`.
|
|
#[serde(rename = "experimental.theme_overrides", default)]
|
|
pub theme_overrides: Option<ThemeStyleContent>,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, JsonSchema, Default)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum BufferLineHeight {
|
|
#[default]
|
|
Comfortable,
|
|
Standard,
|
|
Custom(f32),
|
|
}
|
|
|
|
impl BufferLineHeight {
|
|
pub fn value(&self) -> f32 {
|
|
match self {
|
|
BufferLineHeight::Comfortable => 1.618,
|
|
BufferLineHeight::Standard => 1.3,
|
|
BufferLineHeight::Custom(line_height) => *line_height,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ThemeSettings {
|
|
pub fn buffer_font_size(&self, cx: &AppContext) -> Pixels {
|
|
cx.try_global::<AdjustedBufferFontSize>()
|
|
.map_or(self.buffer_font_size, |size| size.0)
|
|
.max(MIN_FONT_SIZE)
|
|
}
|
|
|
|
pub fn line_height(&self) -> f32 {
|
|
f32::max(self.buffer_line_height.value(), MIN_LINE_HEIGHT)
|
|
}
|
|
|
|
/// Switches to the theme with the given name, if it exists.
|
|
///
|
|
/// Returns a `Some` containing the new theme if it was successful.
|
|
/// Returns `None` otherwise.
|
|
pub fn switch_theme(&mut self, theme: &str, cx: &mut AppContext) -> Option<Arc<Theme>> {
|
|
let themes = ThemeRegistry::default_global(cx);
|
|
|
|
let mut new_theme = None;
|
|
|
|
if let Some(theme) = themes.get(&theme).log_err() {
|
|
self.active_theme = theme.clone();
|
|
new_theme = Some(theme);
|
|
}
|
|
|
|
self.apply_theme_overrides();
|
|
|
|
new_theme
|
|
}
|
|
|
|
/// Applies the theme overrides, if there are any, to the current theme.
|
|
pub fn apply_theme_overrides(&mut self) {
|
|
if let Some(theme_overrides) = &self.theme_overrides {
|
|
let mut base_theme = (*self.active_theme).clone();
|
|
|
|
base_theme
|
|
.styles
|
|
.colors
|
|
.refine(&theme_overrides.theme_colors_refinement());
|
|
base_theme
|
|
.styles
|
|
.status
|
|
.refine(&theme_overrides.status_colors_refinement());
|
|
base_theme.styles.syntax = Arc::new(SyntaxTheme {
|
|
highlights: {
|
|
let mut highlights = base_theme.styles.syntax.highlights.clone();
|
|
// Overrides come second in the highlight list so that they take precedence
|
|
// over the ones in the base theme.
|
|
highlights.extend(theme_overrides.syntax_overrides());
|
|
highlights
|
|
},
|
|
});
|
|
|
|
self.active_theme = Arc::new(base_theme);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn observe_buffer_font_size_adjustment<V: 'static>(
|
|
cx: &mut ViewContext<V>,
|
|
f: impl 'static + Fn(&mut V, &mut ViewContext<V>),
|
|
) -> Subscription {
|
|
cx.observe_global::<AdjustedBufferFontSize>(f)
|
|
}
|
|
|
|
pub fn adjusted_font_size(size: Pixels, cx: &mut AppContext) -> Pixels {
|
|
if let Some(AdjustedBufferFontSize(adjusted_size)) = cx.try_global::<AdjustedBufferFontSize>() {
|
|
let buffer_font_size = ThemeSettings::get_global(cx).buffer_font_size;
|
|
let delta = *adjusted_size - buffer_font_size;
|
|
size + delta
|
|
} else {
|
|
size
|
|
}
|
|
.max(MIN_FONT_SIZE)
|
|
}
|
|
|
|
pub fn adjust_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
|
|
let buffer_font_size = ThemeSettings::get_global(cx).buffer_font_size;
|
|
let mut adjusted_size = cx
|
|
.try_global::<AdjustedBufferFontSize>()
|
|
.map_or(buffer_font_size, |adjusted_size| adjusted_size.0);
|
|
|
|
f(&mut adjusted_size);
|
|
adjusted_size = adjusted_size.max(MIN_FONT_SIZE);
|
|
cx.set_global(AdjustedBufferFontSize(adjusted_size));
|
|
cx.refresh();
|
|
}
|
|
|
|
pub fn reset_font_size(cx: &mut AppContext) {
|
|
if cx.has_global::<AdjustedBufferFontSize>() {
|
|
cx.remove_global::<AdjustedBufferFontSize>();
|
|
cx.refresh();
|
|
}
|
|
}
|
|
|
|
impl settings::Settings for ThemeSettings {
|
|
const KEY: Option<&'static str> = None;
|
|
|
|
type FileContent = ThemeSettingsContent;
|
|
|
|
fn load(
|
|
defaults: &Self::FileContent,
|
|
user_values: &[&Self::FileContent],
|
|
cx: &mut AppContext,
|
|
) -> Result<Self> {
|
|
let themes = ThemeRegistry::default_global(cx);
|
|
let system_appearance = SystemAppearance::default_global(cx);
|
|
|
|
let mut this = Self {
|
|
ui_font_size: defaults.ui_font_size.unwrap().into(),
|
|
ui_font: Font {
|
|
family: defaults.ui_font_family.clone().unwrap().into(),
|
|
features: defaults.ui_font_features.clone().unwrap(),
|
|
weight: Default::default(),
|
|
style: Default::default(),
|
|
},
|
|
buffer_font: Font {
|
|
family: defaults.buffer_font_family.clone().unwrap().into(),
|
|
features: defaults.buffer_font_features.clone().unwrap(),
|
|
weight: FontWeight::default(),
|
|
style: FontStyle::default(),
|
|
},
|
|
buffer_font_size: defaults.buffer_font_size.unwrap().into(),
|
|
buffer_line_height: defaults.buffer_line_height.unwrap(),
|
|
theme_selection: defaults.theme.clone(),
|
|
active_theme: themes
|
|
.get(defaults.theme.as_ref().unwrap().theme(*system_appearance))
|
|
.or(themes.get(&one_dark().name))
|
|
.unwrap(),
|
|
theme_overrides: None,
|
|
};
|
|
|
|
for value in user_values.into_iter().copied().cloned() {
|
|
if let Some(value) = value.buffer_font_family {
|
|
this.buffer_font.family = value.into();
|
|
}
|
|
if let Some(value) = value.buffer_font_features {
|
|
this.buffer_font.features = value;
|
|
}
|
|
|
|
if let Some(value) = value.ui_font_family {
|
|
this.ui_font.family = value.into();
|
|
}
|
|
if let Some(value) = value.ui_font_features {
|
|
this.ui_font.features = value;
|
|
}
|
|
|
|
if let Some(value) = &value.theme {
|
|
this.theme_selection = Some(value.clone());
|
|
|
|
let theme_name = value.theme(*system_appearance);
|
|
|
|
if let Some(theme) = themes.get(theme_name).log_err() {
|
|
this.active_theme = theme;
|
|
}
|
|
}
|
|
|
|
this.theme_overrides = value.theme_overrides;
|
|
this.apply_theme_overrides();
|
|
|
|
merge(&mut this.ui_font_size, value.ui_font_size.map(Into::into));
|
|
merge(
|
|
&mut this.buffer_font_size,
|
|
value.buffer_font_size.map(Into::into),
|
|
);
|
|
merge(&mut this.buffer_line_height, value.buffer_line_height);
|
|
}
|
|
|
|
Ok(this)
|
|
}
|
|
|
|
fn json_schema(
|
|
generator: &mut SchemaGenerator,
|
|
params: &SettingsJsonSchemaParams,
|
|
cx: &AppContext,
|
|
) -> schemars::schema::RootSchema {
|
|
let mut root_schema = generator.root_schema_for::<ThemeSettingsContent>();
|
|
let theme_names = ThemeRegistry::global(cx)
|
|
.list_names(params.staff_mode)
|
|
.into_iter()
|
|
.map(|theme_name| Value::String(theme_name.to_string()))
|
|
.collect();
|
|
|
|
let theme_name_schema = SchemaObject {
|
|
instance_type: Some(InstanceType::String.into()),
|
|
enum_values: Some(theme_names),
|
|
..Default::default()
|
|
};
|
|
|
|
let available_fonts = params
|
|
.font_names
|
|
.iter()
|
|
.cloned()
|
|
.map(Value::String)
|
|
.collect();
|
|
let fonts_schema = SchemaObject {
|
|
instance_type: Some(InstanceType::String.into()),
|
|
enum_values: Some(available_fonts),
|
|
..Default::default()
|
|
};
|
|
root_schema.definitions.extend([
|
|
("ThemeName".into(), theme_name_schema.into()),
|
|
("FontFamilies".into(), fonts_schema.into()),
|
|
]);
|
|
|
|
root_schema
|
|
.schema
|
|
.object
|
|
.as_mut()
|
|
.unwrap()
|
|
.properties
|
|
.extend([
|
|
(
|
|
"buffer_font_family".to_owned(),
|
|
Schema::new_ref("#/definitions/FontFamilies".into()),
|
|
),
|
|
(
|
|
"ui_font_family".to_owned(),
|
|
Schema::new_ref("#/definitions/FontFamilies".into()),
|
|
),
|
|
]);
|
|
|
|
root_schema
|
|
}
|
|
}
|
|
|
|
fn merge<T: Copy>(target: &mut T, value: Option<T>) {
|
|
if let Some(value) = value {
|
|
*target = value;
|
|
}
|
|
}
|