use crate::Rgba;
use crate::model::border::{ResolvedPadding, ResolvedWidgetBorder, WidgetBorderSpec};
use crate::model::font::FontStyle;
use crate::model::{FontSpec, ResolvedFontSpec};
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,
}
}
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) => {
let family = require(
&f.family,
&format!("{prefix}.family"),
missing,
empty_arc_str(),
);
let size = f.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(
&f.weight,
&format!("{prefix}.weight"),
missing,
weight_fallback,
);
let color = require(
&f.color,
&format!("{prefix}.color"),
missing,
Rgba::TRANSPARENT,
);
ResolvedFontSpec {
family,
size,
defined_size: f.size,
weight,
style: f.style.unwrap_or(FontStyle::Normal),
color,
}
}
}
}
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,
}
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"),
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"),
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_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_padding(
padding: &ResolvedPadding,
prefix: &str,
field: &str,
errors: &mut Vec<crate::error::RangeViolation>,
) {
let sides = [
("padding_top", padding.top),
("padding_right", padding.right),
("padding_bottom", padding.bottom),
("padding_left", padding.left),
];
for (side, value) in sides {
if let Some(value) = value
&& (!value.is_finite() || value < 0.0)
{
errors.push(crate::error::RangeViolation {
path: format!("{prefix}.{field}.{side}"),
value: value as f64,
min: Some(0.0),
max: None,
});
}
}
}
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::resolve::validate_helpers::{require, require_font};
$(
let $font_field = require_font(
&$src.defaults.$font_field,
concat!("defaults.", stringify!($font_field)),
$dpi,
$missing,
);
)*
$(
let $color_field = require(
&$src.defaults.$color_field,
concat!("defaults.", stringify!($color_field)),
$missing,
$crate::color::Rgba::TRANSPARENT,
);
)*
$(
let $f32_field = require(
&$src.defaults.$f32_field,
concat!("defaults.", stringify!($f32_field)),
$missing,
0.0_f32,
);
)*
$(
let $br_field = require(
&$src.defaults.border.$br_field,
concat!("defaults.border.", stringify!($br_field)),
$missing,
$br_fallback,
);
)*
$(
let $is_field = require(
&$src.defaults.icon_sizes.$is_field,
concat!("defaults.icon_sizes.", 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::resolve::validate_helpers::require_text_scale_entry;
$(
let $field = require_text_scale_entry(
&$src.text_scale.$field,
concat!("text_scale.", 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,
errors: &mut Vec<crate::error::RangeViolation>,
) {
check_positive(defaults.font.size, "defaults.font", "size", errors);
check_range_u16(
defaults.font.weight,
100,
900,
"defaults.font",
"weight",
errors,
);
check_positive(
defaults.mono_font.size,
"defaults.mono_font",
"size",
errors,
);
check_range_u16(
defaults.mono_font.weight,
100,
900,
"defaults.mono_font",
"weight",
errors,
);
check_positive(defaults.line_height, "defaults", "line_height", errors);
check_non_negative(
defaults.border.corner_radius,
"defaults.border",
"corner_radius",
errors,
);
check_non_negative(
defaults.border.corner_radius_lg,
"defaults.border",
"corner_radius_lg",
errors,
);
check_non_negative(
defaults.border.line_width,
"defaults.border",
"line_width",
errors,
);
check_non_negative(
defaults.focus_ring_width,
"defaults",
"focus_ring_width",
errors,
);
check_range_f32(
defaults.disabled_opacity,
0.0,
1.0,
"defaults",
"disabled_opacity",
errors,
);
check_range_f32(
defaults.border.opacity,
0.0,
1.0,
"defaults.border",
"opacity",
errors,
);
check_non_negative(
defaults.icon_sizes.toolbar,
"defaults.icon_sizes",
"toolbar",
errors,
);
check_non_negative(
defaults.icon_sizes.small,
"defaults.icon_sizes",
"small",
errors,
);
check_non_negative(
defaults.icon_sizes.large,
"defaults.icon_sizes",
"large",
errors,
);
check_non_negative(
defaults.icon_sizes.dialog,
"defaults.icon_sizes",
"dialog",
errors,
);
check_non_negative(
defaults.icon_sizes.panel,
"defaults.icon_sizes",
"panel",
errors,
);
check_positive(
text_scale.caption.size,
"text_scale.caption",
"size",
errors,
);
check_positive(
text_scale.caption.line_height,
"text_scale.caption",
"line_height",
errors,
);
check_range_u16(
text_scale.caption.weight,
100,
900,
"text_scale.caption",
"weight",
errors,
);
check_positive(
text_scale.section_heading.size,
"text_scale.section_heading",
"size",
errors,
);
check_positive(
text_scale.section_heading.line_height,
"text_scale.section_heading",
"line_height",
errors,
);
check_range_u16(
text_scale.section_heading.weight,
100,
900,
"text_scale.section_heading",
"weight",
errors,
);
check_positive(
text_scale.dialog_title.size,
"text_scale.dialog_title",
"size",
errors,
);
check_positive(
text_scale.dialog_title.line_height,
"text_scale.dialog_title",
"line_height",
errors,
);
check_range_u16(
text_scale.dialog_title.weight,
100,
900,
"text_scale.dialog_title",
"weight",
errors,
);
check_positive(
text_scale.display.size,
"text_scale.display",
"size",
errors,
);
check_positive(
text_scale.display.line_height,
"text_scale.display",
"line_height",
errors,
);
check_range_u16(
text_scale.display.weight,
100,
900,
"text_scale.display",
"weight",
errors,
);
}