use std::sync::Arc;
#[cfg(feature = "form")]
#[allow(deprecated)]
use super::FormTheme;
use super::{
CodeScheme, Density, ThemeBlurs, ThemeBorderSizes, ThemeBreakpoints, ThemeCaret, ThemeControlSizes, ThemeDensities,
ThemeDurations, ThemeEasings, ThemeFocusRing, ThemeIconSizes, ThemeIcons, ThemeInner, ThemeOpacities, ThemePalette,
ThemeRadii, ThemeShadows, ThemeSpacing, ThemeTypography,
};
#[cfg(feature = "markdown")]
use super::{ThemeMarkdown, ThemeTextMarks};
use crate::{app::window::Appearance, layout::scrollbar::ScrollBarStyle};
#[derive(Clone)]
#[non_exhaustive]
pub struct ThemeDefinition {
pub light: ThemePalette,
pub dark: Option<ThemePalette>,
pub typography: ThemeTypography,
pub radii: ThemeRadii,
pub spacing: ThemeSpacing,
pub border_sizes: ThemeBorderSizes,
pub shadows: ThemeShadows,
pub breakpoints: ThemeBreakpoints,
pub caret: ThemeCaret,
pub scrollbar: ScrollBarStyle,
pub control_sizes: ThemeControlSizes,
pub icon_sizes: ThemeIconSizes,
pub densities: ThemeDensities,
pub density: Density,
pub durations: ThemeDurations,
pub easings: ThemeEasings,
pub opacities: ThemeOpacities,
pub blurs: ThemeBlurs,
pub focus_ring: ThemeFocusRing,
pub icons: ThemeIcons,
pub code: CodeScheme,
pub code_dark: Option<CodeScheme>,
pub ui: crate::ui::UiDefinition,
#[cfg(feature = "markdown")]
pub markdown: ThemeMarkdown,
#[cfg(feature = "markdown")]
pub text_marks: ThemeTextMarks,
#[cfg(feature = "form")]
#[deprecated(
since = "0.63.0",
note = "the form controls are the design system's components: their recipes are in `ui`, \
`UiDefinition::patch::<ui::Field>(..)` and those of `ui::Input`, `ui::Textarea`, `ui::Checkbox`, \
`ui::Slider` and `ui::Button`"
)]
#[allow(deprecated)]
pub form: FormTheme,
}
fn legacy_scrollbar() -> ScrollBarStyle {
let bar = ScrollBarStyle::default();
if bar.thumb_color != ScrollBarStyle::THEME_THUMB {
return bar;
}
ScrollBarStyle {
thumb_color: ScrollBarStyle::LEGACY_THUMB,
..bar
}
}
fn design_scrollbar() -> ScrollBarStyle {
if cfg!(target_os = "ios") {
return ScrollBarStyle::default();
}
ScrollBarStyle {
thumb_inset: 1.0,
thumb_radius: 3.0,
thumb_hovered_color: Some(crate::node::BackgroundColor::Palette(
super::PaletteColor::MutedForeground,
)),
..ScrollBarStyle::default()
}
}
impl ThemeDefinition {
pub fn neutral() -> Self {
Self {
light: ThemePalette::light(),
dark: Some(ThemePalette::dark()),
typography: ThemeTypography::default(),
radii: ThemeRadii::default(),
spacing: ThemeSpacing::default(),
border_sizes: ThemeBorderSizes::default(),
shadows: ThemeShadows::default(),
breakpoints: ThemeBreakpoints::default(),
caret: ThemeCaret::default(),
scrollbar: design_scrollbar(),
control_sizes: ThemeControlSizes::default(),
icon_sizes: ThemeIconSizes::default(),
densities: ThemeDensities::default(),
density: Density::Default,
durations: ThemeDurations::default(),
easings: ThemeEasings::default(),
opacities: ThemeOpacities::default(),
blurs: ThemeBlurs::default(),
focus_ring: ThemeFocusRing::default(),
icons: ThemeIcons::lurq(),
code: CodeScheme::lurq(),
code_dark: None,
ui: crate::ui::UiDefinition::new(),
#[cfg(feature = "markdown")]
markdown: ThemeMarkdown::default(),
#[cfg(feature = "markdown")]
text_marks: ThemeTextMarks::default(),
#[cfg(feature = "form")]
#[allow(deprecated)]
form: FormTheme::default(),
}
}
pub fn legacy() -> Self {
Self {
light: ThemePalette::legacy(),
dark: None,
typography: ThemeTypography::legacy(),
radii: ThemeRadii::legacy(),
shadows: ThemeShadows::legacy(),
scrollbar: legacy_scrollbar(),
caret: ThemeCaret::legacy(),
ui: crate::ui::UiDefinition::legacy(),
..Self::neutral()
}
}
pub fn bare() -> Self {
Self {
ui: crate::ui::UiDefinition::bare(),
caret: ThemeCaret::legacy(),
code: CodeScheme::new(),
..Self::neutral()
}
}
pub fn palette(&self, appearance: Appearance) -> &ThemePalette {
match (appearance, &self.dark) {
(Appearance::Dark, Some(dark)) => dark,
_ => &self.light,
}
}
}
impl Default for ThemeDefinition {
fn default() -> Self {
Self::neutral()
}
}
impl ThemeInner {
pub(super) fn apply(&mut self, definition: ThemeDefinition) {
self.palette = definition.palette(self.appearance).clone();
self.palettes = definition.dark.map(|dark| (definition.light.clone(), dark));
if self.palettes.is_none() {
self.palette = definition.light;
}
self.base_typography = definition.typography;
self.adjust_typography();
self.radii = definition.radii;
self.spacing = definition.spacing;
self.border_sizes = definition.border_sizes;
self.shadows = Arc::new(definition.shadows);
self.breakpoints = definition.breakpoints;
self.caret = definition.caret;
self.scrollbar = definition.scrollbar;
self.control_sizes = definition.control_sizes;
self.icon_sizes = definition.icon_sizes;
self.densities = definition.densities;
self.density = definition.density;
self.durations = definition.durations;
self.easings = definition.easings;
self.opacities = definition.opacities;
self.blurs = definition.blurs;
self.focus_ring = definition.focus_ring;
self.icons = definition.icons;
self.code = super::code::ThemeCode {
light: Arc::new(definition.code),
dark: definition.code_dark.map(Arc::new),
};
self.ui = definition.ui;
#[cfg(feature = "markdown")]
{
self.markdown = definition.markdown;
self.text_marks = Arc::new(definition.text_marks);
}
#[cfg(feature = "form")]
#[allow(deprecated)]
{
self.form = definition.form;
}
}
pub(super) fn definition(&self) -> ThemeDefinition {
let (light, dark) = match &self.palettes {
Some((light, dark)) => (light.clone(), Some(dark.clone())),
None => (self.palette.clone(), None),
};
ThemeDefinition {
light,
dark,
typography: self.base_typography.clone(),
radii: self.radii.clone(),
spacing: self.spacing.clone(),
border_sizes: self.border_sizes.clone(),
shadows: (*self.shadows).clone(),
breakpoints: self.breakpoints,
caret: self.caret,
scrollbar: self.scrollbar.clone(),
control_sizes: self.control_sizes.clone(),
icon_sizes: self.icon_sizes.clone(),
densities: self.densities.clone(),
density: self.density,
durations: self.durations.clone(),
easings: self.easings.clone(),
opacities: self.opacities.clone(),
blurs: self.blurs.clone(),
focus_ring: self.focus_ring.clone(),
icons: self.icons.clone(),
code: (*self.code.light).clone(),
code_dark: self.code.dark.as_deref().cloned(),
ui: self.ui.clone(),
#[cfg(feature = "markdown")]
markdown: self.markdown.clone(),
#[cfg(feature = "markdown")]
text_marks: (*self.text_marks).clone(),
#[cfg(feature = "form")]
#[allow(deprecated)]
form: self.form.clone(),
}
}
}