ferroui-view 0.4.0-preview.1

A declarative Rust API for FerroUI user interfaces without XAML: element builders generated for every control, an rsx! macro, signals that properties follow, keyed dynamic children
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! The conversions that keep setters short: what a setter of a property
//! takes besides the value of the property itself (see
//! [`IntoValue`](crate::builder::IntoValue)).
//!
//! | given                         | property value                     |
//! |-------------------------------|------------------------------------|
//! | `T`                           | `Option<T>`                        |
//! | `&str`, `&String`             | `String`, `Option<String>`         |
//! | an integer, `f64`             | `Option<String>` (its text)        |
//! | an integer, `f32`             | `f64`                              |
//! | `f64`, `(f64, f64)`, `(f64, f64, f64, f64)` | `Thickness`          |
//! | `f64`                         | `CornerRadius`                     |
//! | `Color`, a color name or `#rgb` text | `Option<Rc<dyn IBrush>>`    |
//! | `&str`                        | `Option<BoxedValue>` (text content)|
//!
//! A color text that does not parse panics with the text: it is a mistake
//! in the source, like an attribute XAML does not compile.

use crate::builder::{FromValue, IntoValue};
use ferroui_base::media::immutable::ImmutableSolidColorBrush;
use ferroui_base::media::{Brush, Color, IBrush};
use ferroui_base::{BoxedValue, CornerRadius, PropertyValue, Thickness};
use std::rc::Rc;

impl<T: PropertyValue> IntoValue<Option<T>> for T {
    fn into_value(self) -> Option<T> {
        Some(self)
    }
}

impl<T: Clone> FromValue<Option<T>> for T {
    fn from_value(value: &Option<T>) -> Option<Self> {
        value.clone()
    }
}

impl IntoValue<String> for &str {
    fn into_value(self) -> String {
        self.to_string()
    }
}

impl IntoValue<Option<String>> for &str {
    fn into_value(self) -> Option<String> {
        Some(self.to_string())
    }
}

impl IntoValue<Option<String>> for &String {
    fn into_value(self) -> Option<String> {
        Some(self.clone())
    }
}

impl IntoValue<Option<BoxedValue>> for &str {
    fn into_value(self) -> Option<BoxedValue> {
        Some(Rc::new(self.to_string()))
    }
}

impl IntoValue<Option<BoxedValue>> for String {
    fn into_value(self) -> Option<BoxedValue> {
        Some(Rc::new(self))
    }
}

macro_rules! number_to_text {
    ($($t:ty),*) => {$(
        impl IntoValue<Option<String>> for $t {
            fn into_value(self) -> Option<String> {
                Some(self.to_string())
            }
        }
        impl IntoValue<Option<BoxedValue>> for $t {
            fn into_value(self) -> Option<BoxedValue> {
                Some(Rc::new(self.to_string()))
            }
        }
    )*};
}

number_to_text!(i8, i16, i32, i64, isize, u8, u16, u32, u64, usize, f32, f64);

macro_rules! number_to_f64 {
    ($($t:ty),*) => {$(
        impl IntoValue<f64> for $t {
            fn into_value(self) -> f64 {
                f64::from(self)
            }
        }
    )*};
}

number_to_f64!(i8, i16, i32, u8, u16, u32, f32);

impl IntoValue<Thickness> for f64 {
    fn into_value(self) -> Thickness {
        Thickness::uniform(self)
    }
}

impl IntoValue<Thickness> for i32 {
    fn into_value(self) -> Thickness {
        Thickness::uniform(f64::from(self))
    }
}

impl IntoValue<Thickness> for (f64, f64) {
    fn into_value(self) -> Thickness {
        Thickness::symmetric(self.0, self.1)
    }
}

impl IntoValue<Thickness> for (f64, f64, f64, f64) {
    fn into_value(self) -> Thickness {
        Thickness::new(self.0, self.1, self.2, self.3)
    }
}

impl IntoValue<CornerRadius> for f64 {
    fn into_value(self) -> CornerRadius {
        CornerRadius::uniform(self)
    }
}

impl IntoValue<CornerRadius> for i32 {
    fn into_value(self) -> CornerRadius {
        CornerRadius::uniform(f64::from(self))
    }
}

impl IntoValue<Option<Rc<dyn IBrush>>> for Color {
    fn into_value(self) -> Option<Rc<dyn IBrush>> {
        Some(Rc::new(ImmutableSolidColorBrush::new(self)))
    }
}

impl IntoValue<Option<Rc<dyn IBrush>>> for &str {
    fn into_value(self) -> Option<Rc<dyn IBrush>> {
        Some(Brush::parse(self).unwrap_or_else(|_| panic!("`{self}` is not a color")))
    }
}