699 lines
22 KiB
Rust
699 lines
22 KiB
Rust
use std::path::PathBuf;
|
|
use std::rc::Rc;
|
|
|
|
use anyhow::{Error, anyhow};
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
use common::config_dir;
|
|
use gpui::{App, AppContext, Context, Entity, Global, ImageSource, Subscription, Task, px};
|
|
use gpui_kit::component::{Theme, ThemeConfig, ThemeMode, ThemeRegistry};
|
|
use nostr_sdk::prelude::*;
|
|
use serde::{Deserialize, Serialize};
|
|
use smallvec::{SmallVec, smallvec};
|
|
|
|
/// Browser storage key for the settings JSON
|
|
#[cfg(target_arch = "wasm32")]
|
|
const SETTINGS_KEY: &str = "coop.settings";
|
|
|
|
/// The default base font size for the interface
|
|
pub const DEFAULT_FONT_SIZE: f32 = 16.0;
|
|
|
|
const DEFAULT_FILE_SERVER: &str = "https://nostr.download/";
|
|
const LEGACY_FILE_SERVER: &str = "blossom.band";
|
|
/// Minimum days between automatic encryption key rotations
|
|
pub const NIP4E_ROTATION_MIN_DAYS: u32 = 1;
|
|
/// Maximum days between automatic encryption key rotations
|
|
pub const NIP4E_ROTATION_MAX_DAYS: u32 = 90;
|
|
/// Days between automatic encryption key rotations when enabled
|
|
pub const NIP4E_ROTATION_DEFAULT_DAYS: u32 = 30;
|
|
/// Built-in image shown behind chat and group panels
|
|
pub const DEFAULT_BACKGROUND: &str = "brand/default-bg.jpg";
|
|
|
|
/// The user's appearance preference, persisted with the rest of the settings.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
|
|
pub enum AppearanceMode {
|
|
/// Follow the OS.
|
|
System,
|
|
Light,
|
|
/// Paint dark regardless of the OS.
|
|
#[default]
|
|
Dark,
|
|
}
|
|
|
|
impl AppearanceMode {
|
|
pub const ALL: [Self; 3] = [Self::System, Self::Light, Self::Dark];
|
|
|
|
/// Menu/label text.
|
|
pub fn label(self) -> &'static str {
|
|
match self {
|
|
Self::System => "System",
|
|
Self::Light => "Light",
|
|
Self::Dark => "Dark",
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Signer kind
|
|
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub enum SignerKind {
|
|
Auto,
|
|
Encryption,
|
|
#[default]
|
|
User,
|
|
}
|
|
|
|
impl SignerKind {
|
|
pub fn encryption(&self) -> bool {
|
|
matches!(self, SignerKind::Encryption)
|
|
}
|
|
}
|
|
|
|
/// User tuning applied on top of the native OS theme
|
|
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
|
|
pub struct ThemeSettings {
|
|
/// The base UI font size in pixels
|
|
pub font_size: f32,
|
|
/// Draw a ring around focused controls
|
|
pub focus_ring: bool,
|
|
/// Corner radius for general elements; follows the OS theme when unset
|
|
pub radius: Option<f32>,
|
|
/// Corner radius for large elements like dialogs; follows the OS theme when unset
|
|
pub radius_lg: Option<f32>,
|
|
}
|
|
|
|
impl Default for ThemeSettings {
|
|
fn default() -> Self {
|
|
Self {
|
|
font_size: DEFAULT_FONT_SIZE,
|
|
focus_ring: false,
|
|
radius: None,
|
|
radius_lg: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Room configuration
|
|
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub struct RoomConfig {
|
|
backup: bool,
|
|
signer_kind: SignerKind,
|
|
}
|
|
|
|
impl RoomConfig {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
backup: true,
|
|
signer_kind: SignerKind::default(),
|
|
}
|
|
}
|
|
|
|
/// Get backup config
|
|
pub fn backup(&self) -> bool {
|
|
self.backup
|
|
}
|
|
|
|
/// Set backup config
|
|
pub fn toggle_backup(&mut self) {
|
|
self.backup = !self.backup;
|
|
}
|
|
|
|
/// Get signer kind config
|
|
pub fn signer_kind(&self) -> &SignerKind {
|
|
&self.signer_kind
|
|
}
|
|
|
|
/// Set signer kind config
|
|
pub fn set_signer_kind(&mut self, kind: &SignerKind) {
|
|
self.signer_kind = kind.to_owned();
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Settings {
|
|
#[serde(default, alias = "theme_mode")]
|
|
pub appearance_mode: AppearanceMode,
|
|
/// Hide user avatars
|
|
pub hide_avatar: bool,
|
|
/// Enable screening for unknown chat requests
|
|
pub screening: bool,
|
|
/// Promote chat requests from people followed by the user's contacts
|
|
pub wot_auto_trust: bool,
|
|
/// Enable decoupling encryption key
|
|
pub nip4e: bool,
|
|
/// Days between automatic encryption key rotations; None disables rotation
|
|
#[serde(default)]
|
|
pub nip4e_rotation_days: Option<u32>,
|
|
/// Hide the notice that messages in public groups are not encrypted
|
|
#[serde(default)]
|
|
pub hide_group_notice: bool,
|
|
/// Tuning applied on top of the native OS theme
|
|
#[serde(default)]
|
|
pub theme: ThemeSettings,
|
|
/// Bundled theme applied in light appearance; None uses the default light theme
|
|
#[serde(default)]
|
|
pub theme_light: Option<String>,
|
|
/// Bundled theme applied in dark appearance; None uses the default dark theme
|
|
#[serde(default)]
|
|
pub theme_dark: Option<String>,
|
|
/// Show an image behind chat and group panels
|
|
#[serde(default)]
|
|
pub panel_background: bool,
|
|
/// Custom image for the panel background; the built-in one when unset
|
|
#[serde(default)]
|
|
pub panel_background_path: Option<PathBuf>,
|
|
/// Trusted relays; Coop will automatically authenticate with these relays
|
|
pub trusted_relays: Vec<String>,
|
|
/// Server for blossom media attachments
|
|
pub file_server: Url,
|
|
/// Pinned chat rooms, by conversation ID
|
|
#[serde(default)]
|
|
pub pinned_rooms: Vec<u64>,
|
|
/// Pinned groups, by cache tag
|
|
#[serde(default)]
|
|
pub pinned_groups: Vec<String>,
|
|
}
|
|
|
|
impl Default for Settings {
|
|
fn default() -> Self {
|
|
Self {
|
|
appearance_mode: AppearanceMode::default(),
|
|
hide_avatar: false,
|
|
screening: true,
|
|
wot_auto_trust: true,
|
|
nip4e: false,
|
|
nip4e_rotation_days: None,
|
|
hide_group_notice: false,
|
|
theme: ThemeSettings::default(),
|
|
theme_light: None,
|
|
theme_dark: None,
|
|
panel_background: true,
|
|
panel_background_path: None,
|
|
trusted_relays: vec![],
|
|
file_server: Url::parse(DEFAULT_FILE_SERVER).unwrap(),
|
|
pinned_rooms: vec![],
|
|
pinned_groups: vec![],
|
|
}
|
|
}
|
|
}
|
|
|
|
struct GlobalAppSettings(Entity<AppSettings>);
|
|
|
|
impl Global for GlobalAppSettings {}
|
|
|
|
/// Application settings
|
|
pub struct AppSettings {
|
|
/// Settings
|
|
inner: Entity<Settings>,
|
|
/// Event subscriptions
|
|
_subscriptions: SmallVec<[Subscription; 2]>,
|
|
}
|
|
|
|
macro_rules! setting_accessors {
|
|
($(pub $field:ident: $type:ty),* $(,)?) => {
|
|
impl AppSettings {
|
|
$(
|
|
paste::paste! {
|
|
pub fn [<get_ $field>](cx: &App) -> $type {
|
|
Self::global(cx).read(cx).inner.read(cx).$field.clone()
|
|
}
|
|
|
|
pub fn [<update_ $field>](value: $type, cx: &mut App) {
|
|
Self::global(cx).update(cx, |this, cx| {
|
|
this.inner.update(cx, |inner, cx| {
|
|
inner.$field = value;
|
|
cx.notify();
|
|
});
|
|
});
|
|
}
|
|
}
|
|
)*
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! setting_getters {
|
|
($(pub $field:ident: $type:ty),* $(,)?) => {
|
|
impl AppSettings {
|
|
$(
|
|
paste::paste! {
|
|
pub fn [<get_ $field>](cx: &App) -> $type {
|
|
Self::global(cx).read(cx).inner.read(cx).$field.clone()
|
|
}
|
|
}
|
|
)*
|
|
}
|
|
};
|
|
}
|
|
|
|
setting_accessors! {
|
|
pub appearance_mode: AppearanceMode,
|
|
pub hide_avatar: bool,
|
|
pub screening: bool,
|
|
pub wot_auto_trust: bool,
|
|
pub nip4e: bool,
|
|
pub nip4e_rotation_days: Option<u32>,
|
|
pub hide_group_notice: bool,
|
|
pub file_server: Url,
|
|
pub panel_background: bool,
|
|
pub panel_background_path: Option<PathBuf>,
|
|
pub theme_light: Option<String>,
|
|
pub theme_dark: Option<String>,
|
|
}
|
|
|
|
setting_getters! {
|
|
pub theme: ThemeSettings,
|
|
pub pinned_rooms: Vec<u64>,
|
|
pub pinned_groups: Vec<String>,
|
|
}
|
|
|
|
impl AppSettings {
|
|
/// Retrieve the global settings instance
|
|
pub fn global(cx: &App) -> Entity<Self> {
|
|
cx.global::<GlobalAppSettings>().0.clone()
|
|
}
|
|
|
|
/// Set the global settings instance
|
|
fn set_global(state: Entity<Self>, cx: &mut App) {
|
|
cx.set_global(GlobalAppSettings(state));
|
|
}
|
|
|
|
fn new(cx: &mut Context<Self>) -> Self {
|
|
let entity = cx.entity().downgrade();
|
|
let inner = cx.new(|_| Settings::default());
|
|
let mut subscriptions = smallvec![];
|
|
|
|
subscriptions.push(
|
|
// Observe and automatically save settings on changes
|
|
cx.observe(&inner, |this, _inner, cx| {
|
|
this.save(cx);
|
|
}),
|
|
);
|
|
|
|
// Run at the end of current cycle
|
|
cx.defer(move |cx| {
|
|
entity.update(cx, |this, cx| this.load(cx)).ok();
|
|
});
|
|
|
|
Self {
|
|
inner,
|
|
_subscriptions: subscriptions,
|
|
}
|
|
}
|
|
|
|
/// Update settings
|
|
fn set_settings(&mut self, settings: Settings, cx: &mut Context<Self>) {
|
|
self.inner.update(cx, |this, cx| {
|
|
*this = settings;
|
|
cx.notify();
|
|
});
|
|
}
|
|
|
|
/// Edit the theme tuning
|
|
pub fn update_theme(edit: impl FnOnce(&mut ThemeSettings), cx: &mut App) {
|
|
Self::global(cx).update(cx, |this, cx| {
|
|
this.inner.update(cx, |inner, cx| {
|
|
edit(&mut inner.theme);
|
|
cx.notify();
|
|
});
|
|
});
|
|
}
|
|
|
|
pub fn apply_theme_style(cx: &mut App) {
|
|
Self::apply_theme_tuning(Self::get_theme(cx), cx);
|
|
}
|
|
|
|
fn apply_theme_tuning(tuning: ThemeSettings, cx: &mut App) {
|
|
{
|
|
let styled = Theme::global_mut(cx);
|
|
styled.font_size = px(tuning.font_size);
|
|
styled.focus_ring = tuning.focus_ring;
|
|
if let Some(radius) = tuning.radius {
|
|
styled.radius = px(radius);
|
|
}
|
|
if let Some(radius_lg) = tuning.radius_lg {
|
|
styled.radius_lg = px(radius_lg);
|
|
}
|
|
}
|
|
|
|
Theme::update(cx, |styled| {
|
|
let background = styled.background;
|
|
let foreground = styled.foreground;
|
|
let (hover_alpha, active_alpha) = if styled.is_dark() {
|
|
(0.08, 0.12)
|
|
} else {
|
|
(0.04, 0.06)
|
|
};
|
|
if styled.list_hover == background {
|
|
styled.list_hover = foreground.alpha(hover_alpha);
|
|
}
|
|
if styled.tab_active == background {
|
|
styled.tab_active = foreground.alpha(active_alpha);
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Load settings
|
|
fn load(&mut self, cx: &mut Context<Self>) {
|
|
let task: Task<Result<Settings, Error>> = cx.background_spawn(async move {
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
{
|
|
let path = config_dir().join(".settings");
|
|
if let Ok(content) = smol::fs::read_to_string(&path).await {
|
|
return Ok(serde_json::from_str(&content)?);
|
|
}
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
{
|
|
if let Some(content) = common::web_store::get(SETTINGS_KEY)? {
|
|
return Ok(serde_json::from_str(&content)?);
|
|
}
|
|
}
|
|
|
|
Err(anyhow!("Not found"))
|
|
});
|
|
|
|
cx.spawn(async move |this, cx| {
|
|
let mut settings = task.await.unwrap_or(Settings::default());
|
|
|
|
// Move settings still pointed at the old default file server over to the new one
|
|
if settings.file_server.host_str() == Some(LEGACY_FILE_SERVER) {
|
|
settings.file_server = Url::parse(DEFAULT_FILE_SERVER).unwrap();
|
|
}
|
|
|
|
// Update settings
|
|
this.update(cx, |this, cx| {
|
|
this.set_settings(settings, cx);
|
|
this.apply_theme(cx);
|
|
cx.refresh_windows();
|
|
})
|
|
.ok();
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
/// Save settings
|
|
pub fn save(&mut self, cx: &mut Context<Self>) {
|
|
let settings = self.inner.read(cx);
|
|
if let Ok(content) = serde_json::to_string(&settings) {
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
cx.background_spawn(async move {
|
|
let path = config_dir().join(".settings");
|
|
smol::fs::write(&path, content).await.ok();
|
|
})
|
|
.detach();
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
if let Err(e) = common::web_store::set(SETTINGS_KEY, &content) {
|
|
log::warn!("failed to persist settings: {e}");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Apply the persisted appearance mode and theme selection to the app
|
|
pub fn apply_theme(&mut self, cx: &mut Context<Self>) {
|
|
let appearance = self.inner.read(cx).appearance_mode;
|
|
match appearance {
|
|
AppearanceMode::System => Theme::sync_system_appearance(None, cx),
|
|
AppearanceMode::Light => Theme::change(ThemeMode::Light, None, cx),
|
|
AppearanceMode::Dark => Theme::change(ThemeMode::Dark, None, cx),
|
|
}
|
|
|
|
let (light, dark) = {
|
|
let inner = self.inner.read(cx);
|
|
(inner.theme_light.clone(), inner.theme_dark.clone())
|
|
};
|
|
apply_theme_selection(light.as_deref(), dark.as_deref(), cx);
|
|
|
|
let tuning = self.inner.read(cx).theme;
|
|
Self::apply_theme_tuning(tuning, cx);
|
|
}
|
|
|
|
/// Select a registered theme by name.
|
|
pub fn select_theme(name: &str, cx: &mut App) {
|
|
let Some(config) = registered_theme(name, cx) else {
|
|
log::warn!("theme is not registered: {name}");
|
|
return;
|
|
};
|
|
|
|
let dark = config.mode.is_dark();
|
|
|
|
if dark {
|
|
Self::update_theme_dark(Some(name.to_string()), cx);
|
|
Self::update_appearance_mode(AppearanceMode::Dark, cx);
|
|
} else {
|
|
Self::update_theme_light(Some(name.to_string()), cx);
|
|
Self::update_appearance_mode(AppearanceMode::Light, cx);
|
|
}
|
|
|
|
Theme::change(
|
|
if dark {
|
|
ThemeMode::Dark
|
|
} else {
|
|
ThemeMode::Light
|
|
},
|
|
None,
|
|
cx,
|
|
);
|
|
Self::reapply_theme(cx);
|
|
}
|
|
|
|
/// Select the theme applied in light appearance; `None` restores the default
|
|
pub fn set_theme_light(name: Option<String>, cx: &mut App) {
|
|
Self::update_theme_light(name, cx);
|
|
Self::reapply_theme(cx);
|
|
}
|
|
|
|
/// Select the theme applied in dark appearance; `None` restores the default
|
|
pub fn set_theme_dark(name: Option<String>, cx: &mut App) {
|
|
Self::update_theme_dark(name, cx);
|
|
Self::reapply_theme(cx);
|
|
}
|
|
|
|
/// Re-apply the selected themes and tuning from the current settings
|
|
fn reapply_theme(cx: &mut App) {
|
|
let (light, dark, tuning) = AppSettings::global(cx).read_with(cx, |this, cx| {
|
|
let inner = this.inner.read(cx);
|
|
(
|
|
inner.theme_light.clone(),
|
|
inner.theme_dark.clone(),
|
|
inner.theme,
|
|
)
|
|
});
|
|
|
|
apply_theme_selection(light.as_deref(), dark.as_deref(), cx);
|
|
Self::apply_theme_tuning(tuning, cx);
|
|
}
|
|
|
|
/// Check if decoupling encryption key is enabled
|
|
pub fn is_nip4e_enabled(&self, cx: &App) -> bool {
|
|
self.inner.read(cx).nip4e
|
|
}
|
|
|
|
/// The image to show behind chat and group panels, when enabled
|
|
pub fn panel_background_source(cx: &App) -> Option<ImageSource> {
|
|
if !Self::get_panel_background(cx) {
|
|
return None;
|
|
}
|
|
Some(match Self::get_panel_background_path(cx) {
|
|
Some(path) => path.into(),
|
|
None => DEFAULT_BACKGROUND.into(),
|
|
})
|
|
}
|
|
|
|
/// Check if the chat room is pinned
|
|
pub fn pinned_room(&self, id: u64, cx: &App) -> bool {
|
|
self.inner.read(cx).pinned_rooms.contains(&id)
|
|
}
|
|
|
|
/// Pin or unpin the chat room
|
|
pub fn toggle_pinned_room(&mut self, id: u64, cx: &mut Context<Self>) {
|
|
self.inner.update(cx, |this, cx| {
|
|
if let Some(index) = this.pinned_rooms.iter().position(|pinned| *pinned == id) {
|
|
this.pinned_rooms.remove(index);
|
|
} else {
|
|
this.pinned_rooms.push(id);
|
|
}
|
|
cx.notify();
|
|
});
|
|
}
|
|
|
|
/// Check if the group is pinned by its cache tag
|
|
pub fn pinned_group(&self, tag: &str, cx: &App) -> bool {
|
|
self.inner
|
|
.read(cx)
|
|
.pinned_groups
|
|
.iter()
|
|
.any(|pinned| pinned == tag)
|
|
}
|
|
|
|
/// Pin or unpin the group by its cache tag
|
|
pub fn toggle_pinned_group(&mut self, tag: &str, cx: &mut Context<Self>) {
|
|
self.inner.update(cx, |this, cx| {
|
|
if let Some(index) = this.pinned_groups.iter().position(|pinned| pinned == tag) {
|
|
this.pinned_groups.remove(index);
|
|
} else {
|
|
this.pinned_groups.push(tag.to_owned());
|
|
}
|
|
cx.notify();
|
|
});
|
|
}
|
|
}
|
|
|
|
pub fn init(cx: &mut App) {
|
|
AppSettings::set_global(cx.new(AppSettings::new), cx)
|
|
}
|
|
|
|
/// Register the bundled gpui-kit themes with the theme registry
|
|
pub fn init_themes(cx: &mut App) {
|
|
let assets = cx.asset_source().clone();
|
|
|
|
for path in assets.list("themes").unwrap_or_default() {
|
|
let Some(content) = assets.load(&path).unwrap_or_default() else {
|
|
log::warn!("bundled theme {path} is listed but missing");
|
|
continue;
|
|
};
|
|
|
|
let Ok(content) = std::str::from_utf8(&content) else {
|
|
log::warn!("bundled theme {path} is not valid UTF-8");
|
|
continue;
|
|
};
|
|
|
|
if let Err(error) = ThemeRegistry::global_mut(cx).load_themes_from_str(content) {
|
|
log::warn!("failed to load bundled theme {path} ({error})");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Read the persisted appearance mode synchronously.
|
|
fn persisted_settings() -> Option<Settings> {
|
|
let content = persisted_content();
|
|
content.and_then(|content| serde_json::from_str(&content).ok())
|
|
}
|
|
|
|
/// The persisted settings JSON, from the config file or browser storage
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn persisted_content() -> Option<String> {
|
|
let path = config_dir().join(".settings");
|
|
std::fs::read_to_string(path).ok()
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
fn persisted_content() -> Option<String> {
|
|
common::web_store::get(SETTINGS_KEY).ok().flatten()
|
|
}
|
|
|
|
pub fn persisted_appearance_mode() -> AppearanceMode {
|
|
persisted_settings()
|
|
.map(|settings| settings.appearance_mode)
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
/// Read the persisted theme tuning synchronously.
|
|
pub fn persisted_theme() -> ThemeSettings {
|
|
persisted_settings()
|
|
.map(|settings| settings.theme)
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
/// Read the persisted theme selection for light appearance.
|
|
pub fn persisted_theme_light() -> Option<String> {
|
|
persisted_settings().and_then(|settings| settings.theme_light)
|
|
}
|
|
|
|
/// Read the persisted theme selection for dark appearance.
|
|
pub fn persisted_theme_dark() -> Option<String> {
|
|
persisted_settings().and_then(|settings| settings.theme_dark)
|
|
}
|
|
|
|
/// The registered theme for a persisted theme name, if any
|
|
fn registered_theme(name: &str, cx: &App) -> Option<Rc<ThemeConfig>> {
|
|
ThemeRegistry::global(cx).themes().get(name).cloned()
|
|
}
|
|
|
|
/// Swap the selected themes into the light/dark slots and reload the active mode.
|
|
/// An unset or unknown theme falls back to the registry's default theme.
|
|
fn apply_theme_selection(light: Option<&str>, dark: Option<&str>, cx: &mut App) {
|
|
let light_config = light
|
|
.and_then(|name| registered_theme(name, cx))
|
|
.or_else(|| Some(ThemeRegistry::global(cx).default_light_theme().clone()));
|
|
let dark_config = dark
|
|
.and_then(|name| registered_theme(name, cx))
|
|
.or_else(|| Some(ThemeRegistry::global(cx).default_dark_theme().clone()));
|
|
|
|
{
|
|
let theme = Theme::global_mut(cx);
|
|
if let Some(config) = light_config {
|
|
theme.light_theme = config;
|
|
}
|
|
if let Some(config) = dark_config {
|
|
theme.dark_theme = config;
|
|
}
|
|
}
|
|
|
|
let mode = Theme::global(cx).mode;
|
|
Theme::change(mode, None, cx);
|
|
}
|
|
|
|
/// Apply the persisted appearance, theme selection and tuning synchronously.
|
|
pub fn apply_persisted_theme(cx: &mut App) {
|
|
match persisted_appearance_mode() {
|
|
AppearanceMode::System => Theme::sync_system_appearance(None, cx),
|
|
AppearanceMode::Light => Theme::change(ThemeMode::Light, None, cx),
|
|
AppearanceMode::Dark => Theme::change(ThemeMode::Dark, None, cx),
|
|
}
|
|
|
|
let light = persisted_theme_light();
|
|
let dark = persisted_theme_dark();
|
|
apply_theme_selection(light.as_deref(), dark.as_deref(), cx);
|
|
|
|
AppSettings::apply_theme_tuning(persisted_theme(), cx);
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
/// Settings written before theme tuning existed must keep loading.
|
|
#[test]
|
|
fn settings_without_theme_keep_defaults() {
|
|
let settings: Settings = serde_json::from_str(
|
|
r#"{
|
|
"appearance_mode": "Dark",
|
|
"hide_avatar": false,
|
|
"screening": true,
|
|
"wot_auto_trust": true,
|
|
"nip4e": false,
|
|
"trusted_relays": [],
|
|
"file_server": "https://nostr.download/"
|
|
}"#,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(settings.theme, ThemeSettings::default());
|
|
assert_eq!(settings.theme_light, None);
|
|
assert_eq!(settings.theme_dark, None);
|
|
}
|
|
|
|
/// The theme selection round-trips through serde.
|
|
#[test]
|
|
fn theme_selection_persists() {
|
|
let settings: Settings = serde_json::from_str(
|
|
r#"{
|
|
"appearance_mode": "Dark",
|
|
"hide_avatar": false,
|
|
"screening": true,
|
|
"wot_auto_trust": true,
|
|
"nip4e": false,
|
|
"trusted_relays": [],
|
|
"file_server": "https://nostr.download/",
|
|
"theme_light": "Solarized Light",
|
|
"theme_dark": "Tokyo Night"
|
|
}"#,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(settings.theme_light.as_deref(), Some("Solarized Light"));
|
|
assert_eq!(settings.theme_dark.as_deref(), Some("Tokyo Night"));
|
|
}
|
|
}
|