silex_css 0.1.0-beta.9

Next Generation High-Performance Rust Web Framework based on fine-grained reactivity and no-virtual-DOM architecture.
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
143
144
145

use crate::types::{ValidFor, props};
use std::fmt::{Display, Write};

// ==========================================
// 复杂属性 DSL (Complex Properties)
// ==========================================

// --- Transform ---

#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransformValue(pub String);
impl Display for TransformValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}
impl ValidFor<props::Transform> for TransformValue {}

#[derive(Clone, Debug, PartialEq, Default)]
pub struct TransformBuilder {
    parts: Vec<String>,
}

impl TransformBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn translate<X: Display, Y: Display>(mut self, x: X, y: Y) -> Self {
        self.parts.push(format!("translate({}, {})", x, y));
        self
    }

    pub fn translate_x<V: Display>(mut self, v: V) -> Self {
        self.parts.push(format!("translateX({})", v));
        self
    }

    pub fn translate_y<V: Display>(mut self, v: V) -> Self {
        self.parts.push(format!("translateY({})", v));
        self
    }

    pub fn rotate<A: Display>(mut self, angle: A) -> Self {
        self.parts.push(format!("rotate({})", angle));
        self
    }

    pub fn scale<S: Display>(mut self, s: S) -> Self {
        self.parts.push(format!("scale({})", s));
        self
    }

    pub fn scale_x_y<X: Display, Y: Display>(mut self, x: X, y: Y) -> Self {
        self.parts.push(format!("scale({}, {})", x, y));
        self
    }

    pub fn skew<X: Display, Y: Display>(mut self, x: X, y: Y) -> Self {
        self.parts.push(format!("skew({}, {})", x, y));
        self
    }

    pub fn build(self) -> TransformValue {
        let mut val = String::new();
        for (i, part) in self.parts.iter().enumerate() {
            if i > 0 {
                val.push(' ');
            }
            val.push_str(part);
        }
        TransformValue(val)
    }
}

impl Display for TransformBuilder {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for (i, part) in self.parts.iter().enumerate() {
            if i > 0 {
                f.write_char(' ')?;
            }
            f.write_str(part)?;
        }
        Ok(())
    }
}

impl ValidFor<props::Transform> for TransformBuilder {}

pub fn transform() -> TransformBuilder {
    TransformBuilder::new()
}

// --- Grid Template Areas ---

#[derive(Clone, Debug, Default, PartialEq)]
pub struct GridTemplateAreasValue(pub String);
impl Display for GridTemplateAreasValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}
impl ValidFor<props::GridTemplateAreas> for GridTemplateAreasValue {}

pub fn grid_template_areas<I, S>(areas: I) -> GridTemplateAreasValue
where
    I: IntoIterator<Item = S>,
    S: AsRef<str>,
{
    let mut val = String::new();
    for (i, s) in areas.into_iter().enumerate() {
        if i > 0 {
            val.push(' ');
        }
        write!(val, "\"{}\"", s.as_ref()).unwrap();
    }
    GridTemplateAreasValue(val)
}

// --- Font Variation Settings ---

#[derive(Clone, Debug, Default, PartialEq)]
pub struct FontVariationSettingsValue(pub String);
impl Display for FontVariationSettingsValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}
impl ValidFor<props::FontVariationSettings> for FontVariationSettingsValue {}

pub fn font_variation_settings<I, K, V>(settings: I) -> FontVariationSettingsValue
where
    I: IntoIterator<Item = (K, V)>,
    K: Display,
    V: Display,
{
    let mut val = String::new();
    for (i, (k, v)) in settings.into_iter().enumerate() {
        if i > 0 {
            val.push_str(", ");
        }
        write!(val, "\"{}\" {}", k, v).unwrap();
    }
    FontVariationSettingsValue(val)
}