use crate::Rgba;
use native_theme_derive::ThemeFields;
use serde::{Deserialize, Serialize};
#[serde_with::skip_serializing_none]
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, ThemeFields)]
#[serde(default)]
pub struct DefaultsBorderSpec {
pub color: Option<Rgba>,
#[serde(rename = "corner_radius_px")]
pub corner_radius: Option<f32>,
#[serde(rename = "corner_radius_lg_px")]
pub corner_radius_lg: Option<f32>,
#[serde(rename = "line_width_px")]
pub line_width: Option<f32>,
pub opacity: Option<f32>,
pub shadow_enabled: Option<bool>,
}
impl_merge!(DefaultsBorderSpec {
option { color, corner_radius, corner_radius_lg, line_width, opacity, shadow_enabled }
});
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, ThemeFields)]
#[serde(try_from = "WidgetBorderSpecRaw", into = "WidgetBorderSpecRaw")]
#[theme_layer(
fields = "color, corner_radius_px, line_width_px, shadow_enabled, padding_top_px, padding_right_px, padding_bottom_px, padding_left_px, padding_horizontal_px, padding_vertical_px"
)]
pub struct WidgetBorderSpec {
pub color: Option<Rgba>,
pub corner_radius: Option<f32>,
pub line_width: Option<f32>,
pub shadow_enabled: Option<bool>,
pub padding_top: Option<f32>,
pub padding_right: Option<f32>,
pub padding_bottom: Option<f32>,
pub padding_left: Option<f32>,
}
#[serde_with::skip_serializing_none]
#[derive(Default, Serialize, Deserialize)]
#[serde(default)]
struct WidgetBorderSpecRaw {
color: Option<Rgba>,
corner_radius_px: Option<f32>,
line_width_px: Option<f32>,
shadow_enabled: Option<bool>,
padding_top_px: Option<f32>,
padding_right_px: Option<f32>,
padding_bottom_px: Option<f32>,
padding_left_px: Option<f32>,
padding_horizontal_px: Option<f32>,
padding_vertical_px: Option<f32>,
}
fn expand_axis(
axis: (&str, Option<f32>),
first: (&str, Option<f32>),
second: (&str, Option<f32>),
) -> Result<(Option<f32>, Option<f32>), String> {
let Some(v) = axis.1 else {
return Ok((first.1, second.1));
};
for side in [first, second] {
if side.1.is_some() {
return Err(format!(
"border: set `{}` or `{}`, not both",
axis.0, side.0
));
}
}
Ok((Some(v), Some(v)))
}
impl TryFrom<WidgetBorderSpecRaw> for WidgetBorderSpec {
type Error = String;
fn try_from(raw: WidgetBorderSpecRaw) -> Result<Self, Self::Error> {
let (padding_left, padding_right) = expand_axis(
("padding_horizontal_px", raw.padding_horizontal_px),
("padding_left_px", raw.padding_left_px),
("padding_right_px", raw.padding_right_px),
)?;
let (padding_top, padding_bottom) = expand_axis(
("padding_vertical_px", raw.padding_vertical_px),
("padding_top_px", raw.padding_top_px),
("padding_bottom_px", raw.padding_bottom_px),
)?;
Ok(WidgetBorderSpec {
color: raw.color,
corner_radius: raw.corner_radius_px,
line_width: raw.line_width_px,
shadow_enabled: raw.shadow_enabled,
padding_top,
padding_right,
padding_bottom,
padding_left,
})
}
}
impl From<WidgetBorderSpec> for WidgetBorderSpecRaw {
fn from(b: WidgetBorderSpec) -> Self {
WidgetBorderSpecRaw {
color: b.color,
corner_radius_px: b.corner_radius,
line_width_px: b.line_width,
shadow_enabled: b.shadow_enabled,
padding_top_px: b.padding_top,
padding_right_px: b.padding_right,
padding_bottom_px: b.padding_bottom,
padding_left_px: b.padding_left,
padding_horizontal_px: None,
padding_vertical_px: None,
}
}
}
impl_merge!(WidgetBorderSpec {
option {
color, corner_radius, line_width, shadow_enabled,
padding_top, padding_right, padding_bottom, padding_left
}
});
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct ResolvedPadding {
pub top: Option<f32>,
pub right: Option<f32>,
pub bottom: Option<f32>,
pub left: Option<f32>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ResolvedDefaultsBorder {
pub color: Rgba,
pub corner_radius: f32,
pub corner_radius_lg: f32,
pub line_width: f32,
pub opacity: f32,
pub shadow_enabled: bool,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ResolvedWidgetBorder {
pub color: Rgba,
pub corner_radius: f32,
pub line_width: f32,
pub shadow_enabled: bool,
#[serde(default)]
pub padding: ResolvedPadding,
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
#[test]
fn defaults_border_spec_default_is_empty() {
assert!(DefaultsBorderSpec::default().is_empty());
}
#[test]
fn defaults_border_spec_not_empty_when_color_set() {
let bs = DefaultsBorderSpec {
color: Some(Rgba::rgb(100, 100, 100)),
..Default::default()
};
assert!(!bs.is_empty());
}
#[test]
fn defaults_border_spec_toml_round_trip_full() {
let bs = DefaultsBorderSpec {
color: Some(Rgba::rgb(200, 200, 200)),
corner_radius: Some(4.0),
corner_radius_lg: Some(8.0),
line_width: Some(1.0),
opacity: Some(0.15),
shadow_enabled: Some(true),
};
let toml_str = toml::to_string(&bs).unwrap();
let deserialized: DefaultsBorderSpec = toml::from_str(&toml_str).unwrap();
assert_eq!(deserialized, bs);
}
#[test]
fn defaults_border_spec_toml_round_trip_partial() {
let bs = DefaultsBorderSpec {
color: Some(Rgba::rgb(100, 100, 100)),
corner_radius: Some(8.0),
corner_radius_lg: None,
line_width: None,
opacity: None,
shadow_enabled: None,
};
let toml_str = toml::to_string(&bs).unwrap();
let deserialized: DefaultsBorderSpec = toml::from_str(&toml_str).unwrap();
assert_eq!(deserialized, bs);
assert!(deserialized.corner_radius_lg.is_none());
assert!(deserialized.line_width.is_none());
assert!(deserialized.opacity.is_none());
assert!(deserialized.shadow_enabled.is_none());
}
#[test]
fn defaults_border_spec_merge_overlay_wins() {
let mut base = DefaultsBorderSpec {
color: Some(Rgba::rgb(100, 100, 100)),
corner_radius: Some(4.0),
..Default::default()
};
let overlay = DefaultsBorderSpec {
color: Some(Rgba::rgb(200, 200, 200)),
..Default::default()
};
base.merge(&overlay);
assert_eq!(base.color, Some(Rgba::rgb(200, 200, 200)));
assert_eq!(base.corner_radius, Some(4.0));
}
#[test]
fn widget_border_spec_default_is_empty() {
assert!(WidgetBorderSpec::default().is_empty());
}
#[test]
fn widget_border_spec_not_empty_when_color_set() {
let bs = WidgetBorderSpec {
color: Some(Rgba::rgb(100, 100, 100)),
..Default::default()
};
assert!(!bs.is_empty());
}
#[test]
fn widget_border_spec_toml_round_trip_full() {
let bs = WidgetBorderSpec {
color: Some(Rgba::rgb(200, 200, 200)),
corner_radius: Some(4.0),
line_width: Some(1.0),
shadow_enabled: Some(true),
padding_top: Some(5.0),
padding_right: Some(6.0),
padding_bottom: Some(7.0),
padding_left: Some(8.0),
};
let toml_str = toml::to_string(&bs).unwrap();
let deserialized: WidgetBorderSpec = toml::from_str(&toml_str).unwrap();
assert_eq!(deserialized, bs);
}
#[test]
fn widget_border_spec_toml_round_trip_partial() {
let bs = WidgetBorderSpec {
color: Some(Rgba::rgb(100, 100, 100)),
corner_radius: Some(8.0),
line_width: None,
shadow_enabled: None,
padding_top: None,
padding_right: None,
padding_bottom: None,
padding_left: None,
};
let toml_str = toml::to_string(&bs).unwrap();
let deserialized: WidgetBorderSpec = toml::from_str(&toml_str).unwrap();
assert_eq!(deserialized, bs);
assert!(deserialized.line_width.is_none());
assert!(deserialized.shadow_enabled.is_none());
assert!(deserialized.padding_top.is_none());
assert!(deserialized.padding_right.is_none());
assert!(deserialized.padding_bottom.is_none());
assert!(deserialized.padding_left.is_none());
}
#[test]
fn widget_border_spec_merge_overlay_wins() {
let mut base = WidgetBorderSpec {
color: Some(Rgba::rgb(100, 100, 100)),
corner_radius: Some(4.0),
..Default::default()
};
let overlay = WidgetBorderSpec {
color: Some(Rgba::rgb(200, 200, 200)),
..Default::default()
};
base.merge(&overlay);
assert_eq!(base.color, Some(Rgba::rgb(200, 200, 200)));
assert_eq!(base.corner_radius, Some(4.0));
}
#[test]
fn padding_horizontal_shorthand_sets_left_and_right_only() {
let bs: WidgetBorderSpec = toml::from_str("padding_horizontal_px = 10").unwrap();
assert_eq!(bs.padding_left, Some(10.0));
assert_eq!(bs.padding_right, Some(10.0));
assert_eq!(bs.padding_top, None);
assert_eq!(bs.padding_bottom, None);
}
#[test]
fn padding_vertical_shorthand_states_a_zero() {
let bs: WidgetBorderSpec = toml::from_str("padding_vertical_px = 0.0").unwrap();
assert_eq!(bs.padding_top, Some(0.0));
assert_eq!(bs.padding_bottom, Some(0.0));
assert_eq!(bs.padding_left, None);
assert_eq!(bs.padding_right, None);
}
#[test]
fn an_axis_key_with_one_of_its_sides_is_rejected_naming_the_table_and_both_keys() {
let src = "[light.button.border]\npadding_horizontal_px = 10\npadding_left_px = 4\n";
let err = toml::from_str::<toml::Table>(src)
.ok()
.and_then(|t| t.get("light").cloned())
.and_then(|l| l.get("button").cloned())
.and_then(|b| b.get("border").cloned())
.map(|border| border.try_into::<WidgetBorderSpec>())
.expect("the table parses as TOML")
.expect_err("an axis key with one of its sides must be rejected")
.to_string();
assert!(err.contains("padding_horizontal_px"), "{err}");
assert!(err.contains("padding_left_px"), "{err}");
let theme = format!("name = \"T\"\n{src}");
let err = crate::Theme::from_toml(&theme)
.expect_err("the theme must not load")
.to_string();
assert!(err.contains("padding_horizontal_px"), "{err}");
assert!(err.contains("padding_left_px"), "{err}");
assert!(err.contains("light.button.border"), "{err}");
}
#[test]
fn the_vertical_axis_key_with_a_side_is_rejected_too() {
let err =
toml::from_str::<WidgetBorderSpec>("padding_vertical_px = 2\npadding_bottom_px = 3")
.expect_err("rejected")
.to_string();
assert!(err.contains("padding_vertical_px"), "{err}");
assert!(err.contains("padding_bottom_px"), "{err}");
}
#[test]
fn serialisation_writes_sides_never_the_shorthand() {
let bs: WidgetBorderSpec =
toml::from_str("padding_horizontal_px = 10\npadding_top_px = 3").unwrap();
let out = toml::to_string(&bs).unwrap();
assert!(out.contains("padding_left_px = 10"), "{out}");
assert!(out.contains("padding_right_px = 10"), "{out}");
assert!(out.contains("padding_top_px = 3"), "{out}");
assert!(!out.contains("padding_horizontal_px"), "{out}");
assert!(!out.contains("padding_bottom_px"), "{out}");
let back: WidgetBorderSpec = toml::from_str(&out).unwrap();
assert_eq!(back, bs);
}
#[test]
fn a_readers_left_side_over_a_presets_shorthand_wins_for_left_only() {
let mut preset: WidgetBorderSpec = toml::from_str("padding_horizontal_px = 10").unwrap();
let reader = WidgetBorderSpec {
padding_left: Some(4.0),
..Default::default()
};
preset.merge(&reader);
assert_eq!(preset.padding_left, Some(4.0));
assert_eq!(preset.padding_right, Some(10.0));
assert_eq!(preset.padding_top, None);
assert_eq!(preset.padding_bottom, None);
}
#[test]
fn resolved_border_struct_literals_compile() {
let defaults = ResolvedDefaultsBorder {
color: Rgba::new(0, 0, 0, 0),
corner_radius: 0.0,
corner_radius_lg: 0.0,
line_width: 0.0,
opacity: 0.0,
shadow_enabled: false,
};
assert_eq!(defaults.corner_radius_lg, 0.0);
let widget = ResolvedWidgetBorder {
color: Rgba::new(0, 0, 0, 0),
corner_radius: 0.0,
line_width: 0.0,
shadow_enabled: false,
padding: ResolvedPadding {
top: None,
right: Some(0.0),
bottom: None,
left: Some(4.0),
},
};
assert_eq!(widget.padding.left, Some(4.0));
assert_eq!(widget.padding.top, None);
assert_eq!(ResolvedPadding::default().right, None);
}
#[test]
fn resolved_widget_border_without_padding_deserialises_unstated() {
let src =
"color = \"#000000\"\ncorner_radius = 2.0\nline_width = 1.0\nshadow_enabled = false\n";
let border: ResolvedWidgetBorder = toml::from_str(src).unwrap();
assert_eq!(border.padding, ResolvedPadding::default());
}
}