use crate::Rgba;
use crate::model::border::{ResolvedPadding, ResolvedWidgetBorder, WidgetBorderSpec};
use crate::model::font::{FontSize, FontStyle};
use crate::model::{
DefaultsBorderSpec, FontSpec, IconSizes, LayoutTheme, ResolvedFontSpec, TextScale,
TextScaleEntry, ThemeDefaults,
};
use std::sync::Arc;
pub(crate) const DEFAULT_FONT_DPI: f32 = 96.0;
fn empty_arc_str() -> Arc<str> {
Arc::<str>::from("")
}
fn resolved_font_spec_sentinel() -> ResolvedFontSpec {
ResolvedFontSpec {
family: empty_arc_str(),
size: 0.0,
defined_size: None,
weight: 0,
style: FontStyle::Normal,
color: Rgba::TRANSPARENT,
}
}
fn resolved_widget_border_sentinel() -> ResolvedWidgetBorder {
ResolvedWidgetBorder {
color: Rgba::TRANSPARENT,
corner_radius: 0.0,
line_width: 0.0,
shadow_enabled: false,
padding: ResolvedPadding::default(),
}
}
fn padding_of(b: &WidgetBorderSpec) -> ResolvedPadding {
ResolvedPadding {
top: b.padding_top,
right: b.padding_right,
bottom: b.padding_bottom,
left: b.padding_left,
}
}
fn size_key(size: Option<FontSize>, [name, pt, px]: [&'static str; 3]) -> &'static str {
match size {
Some(FontSize::Pt(_)) => pt,
Some(FontSize::Px(_)) => px,
None => name,
}
}
fn stated_size(stated: Option<FontSize>, resolved: f32) -> f32 {
match stated {
Some(FontSize::Pt(v) | FontSize::Px(v)) => v,
None => resolved,
}
}
pub(crate) fn require<T: Clone>(
field: &Option<T>,
path: &str,
missing: &mut Vec<String>,
fallback: T,
) -> T {
match field {
Some(val) => val.clone(),
None => {
missing.push(path.to_string());
fallback
}
}
}
pub(crate) fn require_font(
font: &FontSpec,
prefix: &str,
dpi: f32,
missing: &mut Vec<String>,
) -> ResolvedFontSpec {
let family = require(
&font.family,
&format!("{prefix}.family"),
missing,
empty_arc_str(),
);
let size = font
.size
.map(|fs| fs.to_logical_px(dpi))
.unwrap_or_else(|| {
missing.push(format!("{prefix}.size"));
0.0
});
let weight_fallback: u16 = 0;
let weight = require(
&font.weight,
&format!("{prefix}.weight"),
missing,
weight_fallback,
);
let color = require(
&font.color,
&format!("{prefix}.color"),
missing,
Rgba::TRANSPARENT,
);
ResolvedFontSpec {
family,
size,
defined_size: font.size,
weight,
style: font.style.unwrap_or(FontStyle::Normal),
color,
}
}
pub(crate) fn require_font_opt(
font: &Option<FontSpec>,
prefix: &str,
dpi: f32,
missing: &mut Vec<String>,
) -> ResolvedFontSpec {
match font {
None => {
missing.push(prefix.to_string());
resolved_font_spec_sentinel()
}
Some(f) => require_font(f, prefix, dpi, missing),
}
}
pub(crate) fn require_text_scale_entry(
entry: &Option<crate::model::TextScaleEntry>,
prefix: &str,
dpi: f32,
missing: &mut Vec<String>,
) -> crate::model::resolved::ResolvedTextScaleEntry {
match entry {
None => {
missing.push(prefix.to_string());
crate::model::resolved::ResolvedTextScaleEntry {
size: 0.0,
weight: 0,
line_height: 0.0,
}
}
Some(e) => {
let size = e.size.map(|fs| fs.to_logical_px(dpi)).unwrap_or_else(|| {
missing.push(format!("{prefix}.size"));
0.0
});
let line_height = e
.line_height
.map(|fs| fs.to_logical_px(dpi))
.unwrap_or_else(|| {
missing.push(format!("{prefix}.line_height"));
0.0
});
let weight_fallback: u16 = 0;
let weight = require(
&e.weight,
&format!("{prefix}.weight"),
missing,
weight_fallback,
);
crate::model::resolved::ResolvedTextScaleEntry {
size,
weight,
line_height,
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum BorderKind {
Full,
Partial,
None,
}
const CORNER_RADIUS_KEY: &str = "corner_radius_px";
const LINE_WIDTH_KEY: &str = "line_width_px";
pub(crate) fn validate_border(
border: &Option<WidgetBorderSpec>,
prefix: &str,
kind: BorderKind,
missing: &mut Vec<String>,
) -> ResolvedWidgetBorder {
match kind {
BorderKind::None => match border {
Option::None => resolved_widget_border_sentinel(),
Some(b) => ResolvedWidgetBorder {
color: b.color.unwrap_or(Rgba::TRANSPARENT),
corner_radius: b.corner_radius.unwrap_or_default(),
line_width: b.line_width.unwrap_or_default(),
shadow_enabled: b.shadow_enabled.unwrap_or_default(),
padding: padding_of(b),
},
},
BorderKind::Full | BorderKind::Partial => match border {
Option::None => {
missing.push(prefix.to_string());
resolved_widget_border_sentinel()
}
Some(b) => {
let color = require(
&b.color,
&format!("{prefix}.color"),
missing,
Rgba::TRANSPARENT,
);
let zero_width: f32 = 0.0;
let line_width = require(
&b.line_width,
&format!("{prefix}.{LINE_WIDTH_KEY}"),
missing,
zero_width,
);
let (corner_radius, shadow_enabled) = if kind == BorderKind::Full {
let zero_radius: f32 = 0.0;
(
require(
&b.corner_radius,
&format!("{prefix}.{CORNER_RADIUS_KEY}"),
missing,
zero_radius,
),
require(
&b.shadow_enabled,
&format!("{prefix}.shadow_enabled"),
missing,
false,
),
)
} else {
(
b.corner_radius.unwrap_or_default(),
b.shadow_enabled.unwrap_or_default(),
)
};
ResolvedWidgetBorder {
color,
corner_radius,
line_width,
shadow_enabled,
padding: padding_of(b),
}
}
},
}
}
pub(crate) fn check_non_negative(
value: f32,
prefix: &str,
field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
if !value.is_finite() || value < 0.0 {
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{field}"),
value: value as f64,
min: Some(0.0),
max: None,
});
}
}
pub(crate) fn check_positive(
value: f32,
prefix: &str,
field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
if !value.is_finite() || value <= 0.0 {
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{field}"),
value: value as f64,
min: Some(f64::MIN_POSITIVE),
max: None,
});
}
}
pub(crate) fn check_range_f32(
value: f32,
min: f32,
max: f32,
prefix: &str,
field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
if !value.is_finite() || value < min || value > max {
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{field}"),
value: value as f64,
min: Some(min as f64),
max: Some(max as f64),
});
}
}
pub(crate) fn check_range_u16(
value: u16,
min: u16,
max: u16,
prefix: &str,
field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
if value < min || value > max {
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{field}"),
value: value as f64,
min: Some(min as f64),
max: Some(max as f64),
});
}
}
pub(crate) fn check_finite(
value: f32,
prefix: &str,
field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
if !value.is_finite() {
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{field}"),
value: value as f64,
min: None,
max: None,
});
}
}
pub(crate) fn check_min_max(
min_val: f32,
max_val: f32,
prefix: &str,
min_field: &str,
_max_field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
if min_val > max_val {
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{min_field}"),
value: min_val as f64,
min: None,
max: Some(max_val as f64),
});
}
}
pub(crate) fn check_font(
font: &ResolvedFontSpec,
prefix: &str,
field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
if !font.size.is_finite() || font.size <= 0.0 {
errors.push(crate::error::RangeViolation {
path: format!(
"{prefix}.{field}.{}",
size_key(font.defined_size, ["size", "size_pt", "size_px"])
),
value: stated_size(font.defined_size, font.size) as f64,
min: Some(f64::MIN_POSITIVE),
max: None,
});
}
if font.weight < 100 || font.weight > 900 {
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{field}.weight"),
value: font.weight as f64,
min: Some(100.0),
max: Some(900.0),
});
}
}
pub(crate) fn check_widget_border(
border: &ResolvedWidgetBorder,
prefix: &str,
field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
let padding = &border.padding;
let values = [
(CORNER_RADIUS_KEY, Some(border.corner_radius)),
(LINE_WIDTH_KEY, Some(border.line_width)),
("padding_top_px", padding.top),
("padding_right_px", padding.right),
("padding_bottom_px", padding.bottom),
("padding_left_px", padding.left),
];
for (key, value) in values {
if let Some(value) = value
&& (!value.is_finite() || value < 0.0)
{
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{field}.{key}"),
value: value as f64,
min: Some(0.0),
max: None,
});
}
}
}
pub(crate) fn check_layout(layout: &LayoutTheme) -> crate::Result<()> {
let key = LayoutTheme::toml_key;
let values = [
("widget_gap", layout.widget_gap),
("container_margin", layout.container_margin),
("window_margin", layout.window_margin),
("section_gap", layout.section_gap),
];
let mut errors = Vec::new();
for (field, value) in values {
if let Some(value) = value {
check_non_negative(value, "layout", key(field), &mut errors);
}
}
if errors.is_empty() {
Ok(())
} else {
Err(crate::Error::ResolutionInvalid { errors })
}
}
pub(crate) fn check_font_dpi(font_dpi: f32) -> crate::Result<()> {
let mut errors = Vec::new();
check_positive(font_dpi, "context", "font_dpi", &mut errors);
if errors.is_empty() {
Ok(())
} else {
Err(crate::Error::ResolutionInvalid { errors })
}
}
pub(crate) trait ValidateNested {
type Resolved;
fn validate_nested(
source: &Option<Self>,
prefix: &str,
dpi: f32,
missing: &mut Vec<String>,
) -> Self::Resolved
where
Self: Sized;
}
impl ValidateNested for FontSpec {
type Resolved = ResolvedFontSpec;
fn validate_nested(
source: &Option<Self>,
prefix: &str,
dpi: f32,
missing: &mut Vec<String>,
) -> ResolvedFontSpec {
require_font_opt(source, prefix, dpi, missing)
}
}
impl ValidateNested for WidgetBorderSpec {
type Resolved = ResolvedWidgetBorder;
fn validate_nested(
source: &Option<Self>,
prefix: &str,
_dpi: f32,
missing: &mut Vec<String>,
) -> ResolvedWidgetBorder {
validate_border(source, prefix, BorderKind::Full, missing)
}
}
macro_rules! validate_defaults {
(
$src:expr, $dpi:expr, $missing:expr;
font { $($font_field:ident),* $(,)? }
option_color { $($color_field:ident),* $(,)? }
option_f32 { $($f32_field:ident),* $(,)? }
border_required { $($br_field:ident : $br_fallback:expr),* $(,)? }
icon_sizes { $($is_field:ident),* $(,)? }
) => {{
use $crate::model::{DefaultsBorderSpec, IconSizes, ThemeDefaults};
use $crate::resolve::validate_helpers::{require, require_font};
$(
let $font_field = require_font(
&$src.defaults.$font_field,
&format!("defaults.{}", ThemeDefaults::toml_key(stringify!($font_field))),
$dpi,
$missing,
);
)*
$(
let $color_field = require(
&$src.defaults.$color_field,
&format!("defaults.{}", ThemeDefaults::toml_key(stringify!($color_field))),
$missing,
$crate::color::Rgba::TRANSPARENT,
);
)*
$(
let $f32_field = require(
&$src.defaults.$f32_field,
&format!("defaults.{}", ThemeDefaults::toml_key(stringify!($f32_field))),
$missing,
0.0_f32,
);
)*
$(
let $br_field = require(
&$src.defaults.border.$br_field,
&format!(
"defaults.border.{}",
DefaultsBorderSpec::toml_key(stringify!($br_field)),
),
$missing,
$br_fallback,
);
)*
$(
let $is_field = require(
&$src.defaults.icon_sizes.$is_field,
&format!("defaults.icon_sizes.{}", IconSizes::toml_key(stringify!($is_field))),
$missing,
0.0_f32,
);
)*
use $crate::model::border::ResolvedDefaultsBorder;
use $crate::model::resolved::{ResolvedDefaults, ResolvedIconSizes};
ResolvedDefaults {
$($font_field,)*
$($color_field,)*
$($f32_field,)*
border: ResolvedDefaultsBorder {
$($br_field,)*
},
icon_sizes: ResolvedIconSizes {
$($is_field,)*
},
}
}};
}
pub(crate) use validate_defaults;
macro_rules! validate_text_scale {
($src:expr, $dpi:expr, $missing:expr; $($field:ident),* $(,)?) => {{
use $crate::model::TextScale;
use $crate::resolve::validate_helpers::require_text_scale_entry;
$(
let $field = require_text_scale_entry(
&$src.text_scale.$field,
&format!("text_scale.{}", TextScale::toml_key(stringify!($field))),
$dpi,
$missing,
);
)*
$crate::model::resolved::ResolvedTextScale { $($field),* }
}};
}
pub(crate) use validate_text_scale;
pub(crate) fn check_defaults_ranges(
defaults: &crate::model::resolved::ResolvedDefaults,
text_scale: &crate::model::resolved::ResolvedTextScale,
stated_scale: &TextScale,
errors: &mut Vec<crate::error::RangeViolation>,
) {
let key = ThemeDefaults::toml_key;
let border_key = DefaultsBorderSpec::toml_key;
let icon_key = IconSizes::toml_key;
check_font(&defaults.font, "defaults", "font", errors);
check_font(&defaults.mono_font, "defaults", "mono_font", errors);
check_positive(defaults.line_height, "defaults", key("line_height"), errors);
check_non_negative(
defaults.border.corner_radius,
"defaults.border",
border_key("corner_radius"),
errors,
);
check_non_negative(
defaults.border.corner_radius_lg,
"defaults.border",
border_key("corner_radius_lg"),
errors,
);
check_non_negative(
defaults.border.line_width,
"defaults.border",
border_key("line_width"),
errors,
);
check_non_negative(
defaults.focus_ring_width,
"defaults",
key("focus_ring_width"),
errors,
);
check_finite(
defaults.focus_ring_offset,
"defaults",
key("focus_ring_offset"),
errors,
);
check_range_f32(
defaults.disabled_opacity,
0.0,
1.0,
"defaults",
key("disabled_opacity"),
errors,
);
check_range_f32(
defaults.border.opacity,
0.0,
1.0,
"defaults.border",
border_key("opacity"),
errors,
);
check_non_negative(
defaults.icon_sizes.toolbar,
"defaults.icon_sizes",
icon_key("toolbar"),
errors,
);
check_non_negative(
defaults.icon_sizes.small,
"defaults.icon_sizes",
icon_key("small"),
errors,
);
check_non_negative(
defaults.icon_sizes.large,
"defaults.icon_sizes",
icon_key("large"),
errors,
);
check_non_negative(
defaults.icon_sizes.dialog,
"defaults.icon_sizes",
icon_key("dialog"),
errors,
);
check_non_negative(
defaults.icon_sizes.panel,
"defaults.icon_sizes",
icon_key("panel"),
errors,
);
let entries = [
(
"text_scale.caption",
&text_scale.caption,
&stated_scale.caption,
),
(
"text_scale.section_heading",
&text_scale.section_heading,
&stated_scale.section_heading,
),
(
"text_scale.dialog_title",
&text_scale.dialog_title,
&stated_scale.dialog_title,
),
(
"text_scale.display",
&text_scale.display,
&stated_scale.display,
),
];
for (prefix, entry, stated) in entries {
let stated: Option<&TextScaleEntry> = stated.as_ref();
let stated_size_of = stated.and_then(|e| e.size);
check_positive(
stated_size(stated_size_of, entry.size),
prefix,
size_key(stated_size_of, ["size", "size_pt", "size_px"]),
errors,
);
let stated_line_height = stated.and_then(|e| e.line_height);
check_positive(
stated_size(stated_line_height, entry.line_height),
prefix,
size_key(
stated_line_height,
["line_height", "line_height_pt", "line_height_px"],
),
errors,
);
check_range_u16(entry.weight, 100, 900, prefix, "weight", errors);
}
}