viewy 2.0.8

A web UI toolkit that combine the advantages of a design system and an ui library.
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
146
147
148
149
150
151
152
153

use crate::node::Node;
use crate::{DefaultModifiers, Renderable};
use std::borrow::BorrowMut;

#[derive(Debug, Clone)]
pub enum SanitizationLevel {
    /// No sanitization is performed.
    None,
    /// Only basic HTML tags are allowed.
    /// Use this level if you need to render content issued from RichTextArea
    Basic,
    /// Default level.
    /// No HTML tags allowed, only text
    Strict,
}

/// Used to set the typographic style of a Text view.
#[derive(Debug, Clone)]
pub enum TextStyle {
    LargeTitle,
    H1,
    H2,
    H3,
    Headline,
    Subtitle1,
    Subtitle2,
    Subtitle3,
    Body,
    Article,
    Button,
    Label,
    Overline,
    Caption,
}

/// A view that displays one or more lines of read-only text.
#[derive(Debug, Clone)]
pub struct Text {
    node: Node,
    pub content: String,
    pub style: TextStyle,
    pub no_wrap: bool,
    pub sanitization_level: SanitizationLevel,
}

impl Text {
    pub fn new(content: &str, style: TextStyle) -> Self {
        Text {
            node: Node::default(),
            content: content.to_string(),
            style,
            no_wrap: false,
            sanitization_level: SanitizationLevel::Strict,
        }
    }
    pub fn bold(&mut self, is_bold: bool) -> &mut Self {
        if is_bold {
            self.node
                .node_style
                .push(("font-weight".to_string(), "bold".to_string()));
        } else {
            self.node
                .node_style
                .push(("font-weight".to_string(), "normal".to_string()));
        }
        self
    }
    pub fn uppercase(&mut self, is_uppercase: bool) -> &mut Self {
        if is_uppercase {
            self.node
                .node_style
                .push(("text-transform".to_string(), "uppercase".to_string()));
        } else {
            self.node
                .node_style
                .push(("text-transform".to_string(), "none".to_string()));
        }
        self
    }

    pub fn no_wrap(&mut self, is_no_wrap: bool) -> &mut Self {
        self.no_wrap = is_no_wrap;
        self
    }

    #[deprecated(since = "0.13.16", note = "Use sanitization_level instead")]
    pub fn disable_purification(&mut self) -> &mut Self {
        self.sanitization_level = SanitizationLevel::Basic;
        self
    }

    /// Define sanitization level
    pub fn sanitization_level(&mut self, level: SanitizationLevel) -> &mut Self {
        self.sanitization_level = level;
        self
    }

    pub fn text_overflow(&mut self) -> &mut Self {
        self.node
            .node_style
            .push(("text-overflow".to_string(), "ellipsis".to_string()));
        self
    }
    pub fn text_shadow(&mut self, rule: &str) -> &mut Self {
        self.node
            .node_style
            .push(("text-shadow".to_string(), rule.to_string()));
        self
    }

    pub fn text_decoration(&mut self, decoration: &str) -> &mut Self {
        self.node
            .node_style
            .push(("text-decoration".to_string(), decoration.to_string()));
        self
    }
}

impl std::ops::Deref for Text {
    type Target = Node;

    fn deref(&self) -> &Self::Target {
        &self.node
    }
}

impl std::ops::DerefMut for Text {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.node
    }
}

impl DefaultModifiers for Text {}

impl Renderable for Text {
    fn render(mut self) -> Node {
        let text_style = format!("text--{:?}", self.style).to_lowercase();
        self.add_class("text").add_class(text_style.as_str());

        match self.sanitization_level {
            SanitizationLevel::None => self.node.text = Some(self.content.to_string()),
            SanitizationLevel::Basic => self.node.text = Some(ammonia::clean(&self.content)),
            SanitizationLevel::Strict => {
                self.node.text = Some(ammonia::Builder::empty().clean(&self.content).to_string())
            }
        }

        if self.no_wrap {
            self.add_class("text--nowrap");
        }
        self.node
    }
}