use std::sync::Arc;
use crate::{
app::theme::{ShadowStyle, ThemePalette, ThemeShadows},
node::{background_color::BackgroundColor, color::Color},
};
#[derive(Clone, Debug, PartialEq)]
pub struct BoxShadow {
pub offset_x: f32,
pub offset_y: f32,
pub blur: f32,
pub spread: f32,
pub color: BackgroundColor,
pub inset: bool,
}
impl BoxShadow {
pub fn new(offset_x: f32, offset_y: f32, blur: f32, color: impl Into<BackgroundColor>) -> Self {
Self {
offset_x,
offset_y,
blur,
spread: 0.0,
color: color.into(),
inset: false,
}
}
pub fn spread(mut self, spread: f32) -> Self {
self.spread = spread;
self
}
pub fn inset(mut self) -> Self {
self.inset = true;
self
}
pub(crate) fn resolve(&self, palette: &ThemePalette) -> Option<ResolvedBoxShadow> {
let color = self.color.resolve(palette)?;
let blur = sanitize(self.blur).max(0.0);
(color.a() > 0).then_some(ResolvedBoxShadow {
offset_x: sanitize(self.offset_x),
offset_y: sanitize(self.offset_y),
blur,
spread: sanitize(self.spread),
color,
inset: self.inset,
})
}
}
fn sanitize(value: f32) -> f32 {
if value.is_finite() { value } else { 0.0 }
}
#[derive(Clone, Debug, PartialEq)]
pub enum BoxShadowValue {
Theme(ShadowStyle),
Shadows(Arc<[BoxShadow]>),
}
impl BoxShadowValue {
pub fn none() -> Self {
Self::Shadows(Arc::from([]))
}
pub(crate) fn shadows<'a>(&'a self, theme: &'a ThemeShadows) -> &'a [BoxShadow] {
match self {
Self::Theme(style) => theme.try_get_ref(*style).unwrap_or(&[]),
Self::Shadows(shadows) => shadows,
}
}
}
impl From<ShadowStyle> for BoxShadowValue {
fn from(style: ShadowStyle) -> Self {
Self::Theme(style)
}
}
impl From<BoxShadow> for BoxShadowValue {
fn from(shadow: BoxShadow) -> Self {
Self::Shadows(Arc::from([shadow]))
}
}
impl From<Vec<BoxShadow>> for BoxShadowValue {
fn from(shadows: Vec<BoxShadow>) -> Self {
Self::Shadows(shadows.into())
}
}
impl<const N: usize> From<[BoxShadow; N]> for BoxShadowValue {
fn from(shadows: [BoxShadow; N]) -> Self {
Self::Shadows(Arc::from(shadows))
}
}
impl From<Arc<[BoxShadow]>> for BoxShadowValue {
fn from(shadows: Arc<[BoxShadow]>) -> Self {
Self::Shadows(shadows)
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ResolvedBoxShadow {
pub offset_x: f32,
pub offset_y: f32,
pub blur: f32,
pub spread: f32,
pub color: Color,
pub inset: bool,
}
impl ResolvedBoxShadow {
pub fn outset(&self) -> f32 {
if self.inset {
return 0.0;
}
let reach = self.spread + crate::layout::box_shadow::BLUR_EXTENT_SIGMAS * self.blur * 0.5;
(reach + self.offset_x.abs().max(self.offset_y.abs())).max(0.0)
}
}