//! Contains code related to the styling of widgets
use std::ops::Add;
pub use super::units::{KPositionType, LayoutType, Units};
use super::BoxShadow;
use bevy::prelude::Color;
use bevy::prelude::Component;
use bevy::prelude::ReflectComponent;
use bevy::prelude::Vec2;
use bevy::prelude::Vec3;
use bevy::prelude::Vec4;
use bevy::reflect::FromReflect;
use bevy::reflect::Reflect;
use bevy::window::CursorIcon;
use crate::cursor::PointerEvents;
use crate::render::material::MaterialHandle;
use super::AsRefOption;
pub use super::Corner;
pub use super::Edge;
use super::RenderCommand;
/// Just a wrapper around bevy's CursorIcon so we can define a default.
#[derive(Debug, Reflect, Clone, PartialEq, Eq)]
pub struct KCursorIcon(#[reflect(ignore)] pub CursorIcon);
impl Default for KCursorIcon {
fn default() -> Self {
Self(CursorIcon::Default)
}
}
/// The base container of all style properties
///
/// The default value for this enum is [`StyleProp::Unset`].
#[derive(Debug, Reflect, Clone, PartialEq, Eq)]
pub enum StyleProp<T: Default + Clone + Reflect + FromReflect> {
/// This prop is unset, meaning its actual value is not determined until style resolution,
/// wherein it will be set to the property's default value.
///
/// When [applying](Style::apply) styles, only style properties of this type may be
/// overwritten.
Unset,
/// Like [StyleProp::Unset], properties of this type wait until style resolution for their
/// actual values to be determined, wherein it will be set to the property's default value.
Default,
/// Properties of this type inherit their value from their parent (determined at style resolution).
Inherit,
/// Set a specific value for this property
Value(T),
}
impl<T> Default for StyleProp<T>
where
T: Default + Clone + Reflect + FromReflect,
{
fn default() -> Self {
Self::Unset
}
}
impl<T> StyleProp<T>
where
T: Default + Clone + Reflect + FromReflect,
{
/// Resolves this style property into a concrete value.
///
/// # Panics
///
/// Panics if the style property has been set to [`StyleProp::Inherit`] since it needs to
/// first be assigned the value of its parent before being resolved.
pub fn resolve(&self) -> T {
match self {
StyleProp::Unset => T::default(),
StyleProp::Default => T::default(),
StyleProp::Value(value) => value.clone(),
StyleProp::Inherit => panic!("All styles should be merged before resolving!"),
}
}
/// Returns the concrete value of this style property or the provided default.
///
/// If this style property is not [`StyleProp::Value`], then the provided default
/// will be returned.
pub fn resolve_or(&self, default: T) -> T {
if let Self::Value(value) = self {
value.clone()
} else {
default
}
}
/// Returns the concrete value of this style property as an Option<T> or None.
///
/// If this style property is not [`StyleProp::Value`], then the none
/// will be returned.
pub fn resolve_as_option(&self) -> Option<T> {
if let Self::Value(value) = self {
Some(value.clone())
} else {
None
}
}
/// Returns the concrete value of this style property or computes it from a closure.
///
/// If this style property is not [`StyleProp::Value`], then the return value will be
/// computed from the provided closure.
pub fn resolve_or_else<F: FnOnce() -> T>(&self, f: F) -> T {
if let Self::Value(value) = self {
value.clone()
} else {
f()
}
}
/// Returns the concrete value of this style property or the default value.
///
/// This is similar to the standard [`resolve`](Self::resolve) method, however, it
/// will _not_ panic on a [`StyleProp::Inherit`].
pub fn resolve_or_default(&self) -> T {
if let Self::Value(value) = self {
value.clone()
} else {
T::default()
}
}
/// Returns the first property to not be [unset](StyleProp::Unset)
///
/// If none found, returns [`StyleProp::Unset`]
pub fn select<'a>(props: &'_ [&'a StyleProp<T>]) -> &'a Self {
for prop in props {
if !matches!(prop, StyleProp::Unset) {
return prop;
}
}
&StyleProp::Unset
}
}
impl<T: Default + Clone + Reflect + FromReflect> From<T> for StyleProp<T> {
fn from(value: T) -> Self {
StyleProp::Value(value)
}
}
/// A macro that simply wraps the definition struct of [`Style`], allowing
/// some methods to be automatically defined. Otherwise, there would be a _lot_ of
/// copying and pasting, resulting in fragile code.
macro_rules! define_styles {
(
// #[derive(...)]
// #[cfg(...)]
$(#[$attr: meta])*
// pub struct Styles { ... }
$vis: vis struct $name: ident {
// pub field_1: StyleProp<f32>,
// #[cfg(...)]
// field_2: StyleProp<Color>,
$(
$(#[$field_attr: meta])*
$field_vis: vis $field: ident : $field_type: ty
),*
// (Optional trailing comma)
$(,)?
}
) => {
$(#[$attr])*
$vis struct $name {
$(
$(#[$field_attr])*
$field_vis $field: $field_type
),*
}
impl $name {
/// Returns a `Style` object where all fields are set to [`StyleProp::Default`]
///
/// This should only be used when default properties are required or desired. Otherwise, you
/// may be better off using `Style::default` (which sets all properties to [`StyleProp::Unset`]).
pub fn new_default() -> Self {
Self {
$($field: StyleProp::Default),*
}
}
/// If any field is set to [`StyleProp::Inherit`], its value will be taken from `other`
pub fn inherit(&mut self, other: &Self) {
$(
if matches!(self.$field, StyleProp::Inherit) {
self.$field = other.$field.clone();
}
)*
}
/// Applies a `Style` over this one
///
/// Values from `other` are applied to any field in this one that is marked as [`StyleProp::Unset`]
pub fn apply<T: AsRefOption<KStyle>>(&mut self, other: T) {
if let Some(other) = other.as_ref_option() {
$(
if matches!(self.$field, StyleProp::Unset) {
self.$field = other.$field.clone();
}
)*
}
}
/// Applies the given style and returns the updated style
///
/// This is simply a builder-like wrapper around the [`Style::apply`] method.
pub fn with_style<T: AsRefOption<KStyle>>(mut self, other: T) -> Self {
self.apply(other);
self
}
}
};
}
define_styles! {
/// A struct used to define the look of a widget
///
/// # Example
///
/// All fields are `pub`, so you can simply define your styles like:
///
/// ```
/// # use kayak_core::styles::{Style, StyleProp, Units};
/// let style = Style {
/// width: StyleProp::Value(Units::Pixels(100.0)),
/// // Or using `into()` to convert to `StyleProp`
/// // width: Units::Pixels(100.0).into(),
/// ..Default::default()
/// };
/// ```
///
/// You can also create styles using other styles in a builder-like syntax:
///
/// ```
/// # use kayak_core::styles::{Style, StyleProp, Units};
/// let style_a = Style {
/// width: Units::Pixels(100.0).into(),
/// ..Default::default()
/// };
/// let style_b = Style {
/// height: Units::Pixels(100.0).into(),
/// ..Default::default()
/// };
///
/// let style = Style::default() // <- Initializes all fields as `StyleProp::Unset`
/// // Applied first (sets any `StyleProp::Unset` fields)
/// .with_style(&style_a)
/// // Applied second (sets any remaining `StyleProp::Unset` fields)
/// .with_style(&style_b);
/// ```
#[derive(Component, Reflect, Debug, Default, Clone, PartialEq)]
#[reflect(Component)]
pub struct KStyle {
/// The background color of this widget
///
/// Only applies to widgets marked [`RenderCommand::Quad`]
pub background_color : StyleProp<Color>,
/// The color of the border around this widget
///
/// Currently, this controls all border sides.
///
/// Only applies to widgets marked [`RenderCommand::Quad`]
pub border_color: StyleProp<Color>,
/// The radius of the corners (in pixels)
///
/// The order is (Top, Right, Bottom, Left).
///
/// Only applies to widgets marked [`RenderCommand::Quad`] and [`RenderCommand::Image`]
pub border_radius: StyleProp<Corner<f32>>,
/// The widths of the borders (in pixels)
///
/// The order is (Top, Right, Bottom, Left).
///
/// Only applies to widgets marked [`RenderCommand::Quad`]
pub border: StyleProp<Edge<f32>>,
/// The distance between the bottom edge of this widget and the bottom edge of its containing widget
pub bottom: StyleProp<Units>,
/// The text color for this widget
///
/// This property defaults to [`StyleProp::Inherit`] meaning that setting this field to some value will
/// cause all descendents to receive that value, up to the next set value.
///
/// Only applies to widgets marked [`RenderCommand::Text`]
pub color: StyleProp<Color>,
/// The spacing between child widgets along the horizontal axis
pub col_between: StyleProp<Units>,
/// The cursor icon to display when hovering this widget
#[reflect(ignore)]
pub cursor: StyleProp<KCursorIcon>,
/// The font name for this widget
///
/// Only applies to [`RenderCommand::Text`]
pub font: StyleProp<String>,
/// The font size for this widget, in pixels
///
/// Only applies to [`RenderCommand::Text`]
pub font_size: StyleProp<f32>,
/// The height of this widget
pub height: StyleProp<Units>,
/// The layout method for children of this widget
pub layout_type: StyleProp<LayoutType>,
/// The distance between the left edge of this widget and the left edge of its containing widget
pub left: StyleProp<Units>,
/// The line height for this widget, in pixels
///
/// Only applies to [`RenderCommand::Text`]
pub line_height: StyleProp<f32>,
/// The maximum height of this widget
pub max_height: StyleProp<Units>,
/// The maximum width of this widget
pub max_width: StyleProp<Units>,
/// The minimum height of this widget
pub min_height: StyleProp<Units>,
/// The minimum width of this widget
pub min_width: StyleProp<Units>,
/// The positional offset from this widget's default position
///
/// This property has lower precedence than its more specific counterparts
/// ([`top`](Self::top), [`right`](Self::right), [`bottom`](Self::bottom), and [`left`](Self::left)),
/// allowing it to be overridden.
///
/// For widgets with a [`position_type`](Self::position_type) of [`PositionType`](PositionType::ParentDirected)
/// this acts like margin around the widget. For [`PositionType`](PositionType::SelfDirected) this
/// acts as the actual position from the parent.
pub offset: StyleProp<Edge<Units>>,
/// The inner padding between the edges of this widget and its children
///
/// This property has lower precedence than its more specific counterparts
/// ([`padding_top`](Self::padding_top), [`padding_right`](Self::padding_right),
/// [`padding_bottom`](Self::padding_bottom), and [`padding_left`](Self::padding_left)), allowing it
/// to be overridden.
///
/// A child with their own padding properties set to anything other than [`Units::Auto`] will
/// override the padding set by this widget.
pub padding: StyleProp<Edge<Units>>,
/// The inner padding between the bottom edge of this widget and its children
///
/// A child with their own `bottom` property set to anything other than `Units::Auto` will
/// override the padding set by this widget
pub padding_bottom: StyleProp<Units>,
/// The inner padding between the left edge of this widget and its children
///
/// A child with their own `left` property set to anything other than `Units::Auto` will
/// override the padding set by this widget
pub padding_left: StyleProp<Units>,
/// The inner padding between the right edge of this widget and its children
///
/// A child with their own `right` property set to anything other than `Units::Auto` will
/// override the padding set by this widget
pub padding_right: StyleProp<Units>,
/// The inner padding between the top edge of this widget and its children
///
/// A child with their own `top` property set to anything other than `Units::Auto` will
/// override the padding set by this widget
pub padding_top: StyleProp<Units>,
/// Controls how the pointer interacts with the widget
///
/// This can be used to block pointer events on itself and/or its children if needed, allowing
/// the event to "pass through" to widgets below.
pub pointer_events: StyleProp<PointerEvents>,
/// The position type of the widget relative to its parent
pub position_type: StyleProp<KPositionType>,
/// The render method for this widget
///
/// This controls what actually gets rendered and how it's rendered.
pub render_command: StyleProp<RenderCommand>,
/// The distance between the right edge of this widget and the right edge of its containing widget
pub right: StyleProp<Units>,
/// The spacing between child widgets along the vertical axis
pub row_between: StyleProp<Units>,
/// The distance between the top edge of this widget and the top edge of its containing widget
pub top: StyleProp<Units>,
/// The width of this widget
pub width: StyleProp<Units>,
/// The z-index relative to it's parent.
pub z_index: StyleProp<i32>,
/// The list of rows when using the grid layout
///
/// This is specified in the parent widget and the children have to specify their `row_index`.
pub grid_rows: StyleProp<Vec<Units>>,
/// The list of columns when using the grid layout
///
/// This is specified in the parent widget and the children have to specify their `col_index`.
pub grid_cols: StyleProp<Vec<Units>>,
/// The row index of this widget when using the grid layout
///
/// This references the `grid_rows` property of the parent widget.
pub row_index: StyleProp<usize>,
/// The column index of this widget when using the grid layout
///
/// This references the `grid_cols` property of the parent widget.
pub col_index: StyleProp<usize>,
/// The number rows that this widget spans when using the grid layout
///
/// Specified in the child widget.
pub row_span: StyleProp<usize>,
/// The number columns that this widget spans when using the grid layout
///
/// Specified in the child widget.
pub col_span: StyleProp<usize>,
/// The opacity of the widget and it's children
///
/// This is also known as grouped opacity
/// WARNING! This splits the widget and it's children into a new render pass. So use it sparingly!!!
pub opacity: StyleProp<f32>,
/// Box shadow
/// Currently only applied to quads
pub box_shadow: StyleProp<Vec<BoxShadow>>,
/// Overrides the default renderer with a custom material
#[reflect(ignore)]
pub material: StyleProp<MaterialHandle>,
}
}
impl KStyle {
/// Returns a `Style` object where all fields are set to their own initial values
///
/// This is the actual "default" to apply over any field marked as [`StyleProp::Unset`] before
/// resolving the style.
pub fn initial() -> Self {
Self {
background_color: StyleProp::Default,
border: StyleProp::Default,
border_color: StyleProp::Default,
border_radius: StyleProp::Default,
bottom: StyleProp::Default,
color: StyleProp::Inherit,
cursor: StyleProp::Inherit,
col_between: StyleProp::Default,
font: StyleProp::Inherit,
font_size: StyleProp::Inherit,
height: StyleProp::Default,
layout_type: StyleProp::Default,
line_height: StyleProp::Inherit,
left: StyleProp::Default,
max_height: StyleProp::Default,
max_width: StyleProp::Default,
min_height: StyleProp::Default,
min_width: StyleProp::Default,
offset: StyleProp::Default,
padding: StyleProp::Default,
padding_bottom: StyleProp::Default,
padding_left: StyleProp::Default,
padding_right: StyleProp::Default,
padding_top: StyleProp::Default,
pointer_events: StyleProp::Default,
position_type: StyleProp::Default,
render_command: StyleProp::Value(RenderCommand::Layout),
right: StyleProp::Default,
row_between: StyleProp::Default,
top: StyleProp::Default,
width: StyleProp::Default,
z_index: StyleProp::Default,
grid_rows: StyleProp::Default,
grid_cols: StyleProp::Default,
row_index: StyleProp::Default,
col_index: StyleProp::Default,
row_span: StyleProp::Default,
col_span: StyleProp::Default,
opacity: StyleProp::Value(1.0),
box_shadow: StyleProp::Default,
material: StyleProp::Default,
}
}
pub fn lerp(&self, b: &Self, x: f32) -> Self {
let mut new_styles = self.clone(); // Default to A styles.
new_styles.background_color = if let StyleProp::Value(color_a) = self.background_color {
if let StyleProp::Value(color_b) = b.background_color {
StyleProp::Value(hsv_lerp(&color_a, &color_b, x))
} else {
StyleProp::Value(color_a)
}
} else {
self.background_color.clone()
};
new_styles.border = if let StyleProp::Value(border_a) = self.border {
if let StyleProp::Value(border_b) = b.border {
StyleProp::Value(Edge::new(
lerp(border_a.top, border_b.top, x),
lerp(border_a.right, border_b.right, x),
lerp(border_a.bottom, border_b.bottom, x),
lerp(border_a.left, border_b.left, x),
))
} else {
StyleProp::Value(border_a)
}
} else {
self.border.clone()
};
new_styles.border_color = if let StyleProp::Value(color_a) = self.border_color {
if let StyleProp::Value(color_b) = b.border_color {
StyleProp::Value(lerp_lch(color_a, color_b, x))
} else {
StyleProp::Value(color_a)
}
} else {
self.border_color.clone()
};
new_styles.border_radius = if let StyleProp::Value(border_a) = self.border_radius {
if let StyleProp::Value(border_b) = b.border_radius {
StyleProp::Value(Corner::new(
lerp(border_a.top_left, border_b.top_left, x),
lerp(border_a.top_right, border_b.top_right, x),
lerp(border_a.bottom_left, border_b.bottom_left, x),
lerp(border_a.bottom_right, border_b.bottom_right, x),
))
} else {
StyleProp::Value(border_a)
}
} else {
self.border_radius.clone()
};
new_styles.bottom = lerp_units(&self.bottom, &b.bottom, x);
new_styles.color = if let StyleProp::Value(color_a) = self.color {
if let StyleProp::Value(color_b) = b.color {
StyleProp::Value(hsv_lerp(&color_a, &color_b, x))
} else {
StyleProp::Value(color_a)
}
} else {
self.color.clone()
};
new_styles.font_size = lerp_f32(&new_styles.font_size, &b.font_size, x);
new_styles.height = lerp_units(&self.height, &b.height, x);
new_styles.line_height = lerp_f32(&new_styles.line_height, &b.line_height, x);
new_styles.left = lerp_units(&self.left, &b.left, x);
new_styles.max_height = lerp_units(&self.max_height, &b.max_height, x);
new_styles.max_width = lerp_units(&self.max_width, &b.max_width, x);
new_styles.min_height = lerp_units(&self.min_height, &b.min_height, x);
new_styles.min_width = lerp_units(&self.min_width, &b.min_width, x);
new_styles.offset = if let StyleProp::Value(edge_a) = self.offset {
if let StyleProp::Value(edge_b) = b.offset {
StyleProp::Value(Edge::new(
get_value(lerp_units(
&StyleProp::Value(edge_a.top),
&StyleProp::Value(edge_b.top),
x,
)),
get_value(lerp_units(
&StyleProp::Value(edge_a.right),
&StyleProp::Value(edge_b.right),
x,
)),
get_value(lerp_units(
&StyleProp::Value(edge_a.bottom),
&StyleProp::Value(edge_b.bottom),
x,
)),
get_value(lerp_units(
&StyleProp::Value(edge_a.left),
&StyleProp::Value(edge_b.left),
x,
)),
))
} else {
StyleProp::Value(edge_a)
}
} else {
self.offset.clone()
};
new_styles.padding = if let StyleProp::Value(edge_a) = self.padding {
if let StyleProp::Value(edge_b) = b.padding {
StyleProp::Value(Edge::new(
get_value(lerp_units(
&StyleProp::Value(edge_a.top),
&StyleProp::Value(edge_b.top),
x,
)),
get_value(lerp_units(
&StyleProp::Value(edge_a.right),
&StyleProp::Value(edge_b.right),
x,
)),
get_value(lerp_units(
&StyleProp::Value(edge_a.bottom),
&StyleProp::Value(edge_b.bottom),
x,
)),
get_value(lerp_units(
&StyleProp::Value(edge_a.left),
&StyleProp::Value(edge_b.left),
x,
)),
))
} else {
StyleProp::Value(edge_a)
}
} else {
self.padding.clone()
};
new_styles.padding_bottom = lerp_units(&self.padding_bottom, &b.padding_bottom, x);
new_styles.padding_left = lerp_units(&self.padding_left, &b.padding_left, x);
new_styles.padding_right = lerp_units(&self.padding_right, &b.padding_right, x);
new_styles.padding_top = lerp_units(&self.padding_top, &b.padding_top, x);
new_styles.right = lerp_units(&self.right, &b.right, x);
new_styles.top = lerp_units(&self.top, &b.top, x);
new_styles.width = lerp_units(&self.width, &b.width, x);
new_styles.opacity = lerp_f32(&self.opacity, &b.opacity, x);
new_styles
}
}
fn get_value<T: Default + Clone + FromReflect>(a: StyleProp<T>) -> T {
match a {
StyleProp::Value(v) => v,
_ => {
panic!("Unexpected lack of value!");
}
}
}
fn lerp_f32(prop_a: &StyleProp<f32>, prop_b: &StyleProp<f32>, x: f32) -> StyleProp<f32> {
if let StyleProp::Value(f_a) = prop_a {
if let StyleProp::Value(f_b) = prop_b {
StyleProp::Value(lerp(*f_a, *f_b, x))
} else {
StyleProp::Value(*f_a)
}
} else {
prop_a.clone()
}
}
fn lerp_units(prop_a: &StyleProp<Units>, prop_b: &StyleProp<Units>, x: f32) -> StyleProp<Units> {
if let StyleProp::Value(unit_a) = prop_a {
if let StyleProp::Value(unit_b) = prop_b {
StyleProp::Value(match (unit_a, unit_b) {
(Units::Pixels(a), Units::Pixels(b)) => Units::Pixels(lerp(*a, *b, x)),
(Units::Percentage(a), Units::Percentage(b)) => Units::Percentage(lerp(*a, *b, x)),
(Units::Stretch(a), Units::Stretch(b)) => Units::Stretch(lerp(*a, *b, x)),
_ => {
bevy::prelude::warn!(
"Cannot lerp between non-matching units! Unit_A: {:?}, Unit_B: {:?}",
unit_a,
unit_b
);
*unit_a
}
})
} else {
StyleProp::Value(*unit_a)
}
} else {
prop_a.clone()
}
}
fn lerp_ang(a: f32, b: f32, x: f32) -> f32 {
let ang = ((((a - b) % std::f32::consts::TAU) + std::f32::consts::PI * 3.)
% std::f32::consts::TAU)
- std::f32::consts::PI;
ang * x + b
}
/// Linear interpolation between two colors in Lch space
fn lerp_lch(a: Color, b: Color, x: f32) -> Color {
let [a_r, a_g, a_b, a_a] = a.as_lcha_f32();
let [b_r, b_g, b_b, b_a] = b.as_lcha_f32();
let hue = lerp_ang(a_b, b_b, x);
let a_xy = Vec2::new(a_r, a_g);
let b_xy = Vec2::new(b_r, b_g);
let xy = b_xy.lerp(a_xy, x);
let alpha = lerp(a_a, b_a, x);
Color::Lcha {
lightness: xy.x,
chroma: xy.y,
hue,
alpha,
}
.as_rgba()
}
fn rgb_to_hsv(from: &Color) -> Vec3 {
// xyz <-> hsv
let r = from.r();
let g = from.g();
let b = from.b();
let mut res = Vec3::ZERO;
let min = r.min(g).min(b);
let max = r.max(g).max(b);
// Value
res.z = max;
let delta = max - min;
// calc Saturation
if max != 0.0 {
res.y = delta / max;
} else {
res.x = -1.0;
res.y = 0.0;
return res;
}
// calc Hue
if r == max {
// between Yellow & Magenta
res.x = (g - b) / delta;
} else if g == max {
// cyan to yellow
res.x = 2.0 + (b - r) / delta;
} else {
// b == max // Megnta to cyan
res.x = 4.0 + (r - g) / delta;
}
res.x *= 60.0; // Convert to degrees
if res.x < 0.0 {
res.x += 360.0; // Unwrap angle in case of negative
}
res
}
fn hsv_to_rgb(from: &Vec3) -> Color {
let h = from.x;
let s = from.y;
let v = from.z;
// Calc base values
let c = s * v;
let x = c * (1.0 - (((h / 60.0) % 2.0) - 1.0).abs());
let m = v - c;
let mut res = Vec4::new(0.0, 0.0, 0.0, 1.0);
if (0.0..60.0).contains(&h) {
res.x = c;
res.y = x;
res.z = 0.0;
} else if (60.0..120.0).contains(&h) {
res.x = x;
res.y = c;
res.z = 0.0;
} else if (120.0..180.0).contains(&h) {
res.x = 0.0;
res.y = c;
res.z = x;
} else if (180.0..240.0).contains(&h) {
res.x = 0.0;
res.y = x;
res.z = c;
} else if (240.0..300.0).contains(&h) {
res.x = x;
res.y = 0.0;
res.z = c;
} else {
res.x = c;
res.y = 0.0;
res.z = x;
}
res += Vec4::new(m, m, m, 0.0);
Color::rgba_from_array(res)
}
fn hsv_lerp(from: &Color, to: &Color, amount: f32) -> Color {
let from_a = from.a();
let to_a = to.a();
let from = rgb_to_hsv(from);
let to = rgb_to_hsv(to);
let mut res = from.lerp(to, amount);
if from.x < 0.0 {
res.x = to.x;
}
let mut color = hsv_to_rgb(&res);
color.set_a(lerp(from_a, to_a, amount).clamp(0.0, 1.0));
color
}
pub(crate) fn lerp(a: f32, b: f32, x: f32) -> f32 {
a * (1.0 - x) + b * x
}
impl Add for KStyle {
type Output = KStyle;
/// Defines the `+` operator for [`Style`]. This is a convenience wrapper of the `self.with_style()` method and useful for concatenating many small `Style` variables.
/// Similar to `with_style()` In a `StyleA + StyleB` operation, values from `StyleB` are applied to any field of StyleA that are marked as [`StyleProp::Unset`].
///
/// Note: since the changes are applied only to unset fields, addition is *not* commutative. This means StyleA + StyleB != StyleB + StyleA for most cases.
fn add(self, other: KStyle) -> KStyle {
self.with_style(other)
}
}
#[cfg(test)]
mod tests {
use super::{Edge, KStyle, StyleProp, Units};
#[test]
fn styles_should_equal() {
let mut a = KStyle::default();
let mut b = KStyle::default();
assert_eq!(a, b);
a.height = StyleProp::Default;
b.height = StyleProp::Inherit;
assert_ne!(a, b);
}
#[test]
fn style_should_inherit_property() {
let border = Edge::new(1.0, 2.0, 3.0, 4.0);
let parent = KStyle {
border: StyleProp::Value(border),
..Default::default()
};
let mut child = KStyle {
border: StyleProp::Inherit,
..Default::default()
};
child.inherit(&parent);
assert_eq!(border, child.border.resolve());
}
#[test]
#[should_panic]
fn style_should_panic_on_resolve_inherit_property() {
let style = KStyle {
color: StyleProp::Inherit,
..Default::default()
};
let _ = style.color.resolve();
}
#[test]
fn style_should_apply_styles_on_unset_property() {
let mut base_style = KStyle::default();
let other_style = KStyle {
width: StyleProp::Value(Units::Pixels(123.0)),
..Default::default()
};
assert_ne!(base_style.width, other_style.width);
base_style.apply(&other_style);
assert_eq!(base_style.width, other_style.width);
}
#[test]
fn style_should_not_apply_styles_on_non_unset_property() {
let mut base_style = KStyle {
width: StyleProp::Default,
..Default::default()
};
let other_style = KStyle {
width: StyleProp::Value(Units::Pixels(123.0)),
..Default::default()
};
assert_ne!(base_style.width, other_style.width);
base_style.apply(&other_style);
assert_ne!(base_style.width, other_style.width);
}
#[test]
fn style_should_apply_option_style() {
let mut base_style = KStyle::default();
let other_style = Some(KStyle {
width: StyleProp::Value(Units::Pixels(123.0)),
..Default::default()
});
assert_ne!(base_style.width, other_style.as_ref().unwrap().width);
base_style.apply(&other_style);
assert_eq!(base_style.width, other_style.as_ref().unwrap().width);
base_style.apply(None);
assert_eq!(base_style.width, other_style.as_ref().unwrap().width);
}
#[test]
fn style_should_not_apply_none() {
let expected = KStyle::default();
let mut base_style = expected.clone();
assert_eq!(expected, base_style);
base_style.apply(None);
assert_eq!(expected, base_style);
}
#[test]
fn styles_should_be_buildable() {
let expected_left = StyleProp::Default;
let expected_width = StyleProp::Value(Units::Stretch(1.0));
let expected_height = StyleProp::Inherit;
let expected = KStyle {
left: expected_left.clone(),
width: expected_width.clone(),
height: expected_height.clone(),
..Default::default()
};
let style = KStyle::default()
// Pass ownership
.with_style(KStyle {
height: expected_height,
..Default::default()
})
// Pass ownership of option
.with_style(Some(KStyle {
left: expected_left,
..Default::default()
}))
// Pass reference
.with_style(&KStyle {
width: expected_width,
..Default::default()
});
assert_eq!(expected, style);
}
#[test]
fn styles_should_add() {
let expected_left = StyleProp::Default;
let expected_width = StyleProp::Value(Units::Stretch(1.0));
let expected_height = StyleProp::Inherit;
let expected = KStyle {
left: expected_left.clone(),
width: expected_width.clone(),
height: expected_height.clone(),
..Default::default()
};
let style_a = KStyle::default();
let style_b = KStyle {
height: expected_height,
..Default::default()
};
let style_c = KStyle {
left: expected_left,
..Default::default()
};
let style_d = KStyle {
width: expected_width,
..Default::default()
};
assert_eq!(expected, style_a + style_b + style_c + style_d);
}
#[test]
fn value_should_convert_to_property() {
let expected_width = Units::Pixels(123.0);
let expected = StyleProp::Value(expected_width);
let property: StyleProp<_> = expected_width.into();
assert_eq!(expected, property);
}
#[test]
fn value_should_resolve_with_given_value() {
let expected: f32 = 123.0;
let property = StyleProp::Default;
assert_eq!(expected, property.resolve_or(expected));
assert_eq!(expected, property.resolve_or_else(|| expected));
assert_eq!(f32::default(), property.resolve_or_default());
}
}