viewy 2.0.0

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

use std::borrow::BorrowMut;

use crate::DefaultModifiers;
use crate::Renderable;
use crate::components::{Alignment, Appendable, Text, TextStyle, VStack};
use crate::node::Node;

#[derive(Debug, Clone)]
pub struct TitleBar {
    node: Node,
    pub title: String,
    pub subtitle: Option<String>,
    pub is_sticky: bool,
    pub left_item: Option<Node>,
    pub right_item: Option<Node>,
    pub bottom_item: Option<Node>,
}
impl std::ops::Deref for TitleBar {
    type Target = Node;

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

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

impl TitleBar {
    pub fn new(title: &str) -> Self {
        TitleBar {
            node: Default::default(),
            title: title.to_string(),
            subtitle: None,
            is_sticky: true,
            left_item: None,
            right_item: None,
            bottom_item: None,
        }
    }

    pub fn subtitle(&mut self, subtitle: &str) -> &mut Self {
        self.subtitle = Some(subtitle.to_string());
        self
    }
    fn grid_areas(&mut self, schema: &str) -> &mut Self {
        self.node
            .node_style
            .push(("grid-template-areas".to_string(), schema.to_string()));
        self
    }

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

    pub fn left_item<T>(&mut self, item: T) -> &mut Self
    where
        T: Renderable,
    {
        self.left_item = Some(item.render());
        self
    }
    pub fn right_item<T>(&mut self, item: T) -> &mut Self
    where
        T: Renderable,
    {
        self.right_item = Some(item.render());
        self
    }
    pub fn bottom_item<T>(&mut self, item: T) -> &mut Self
    where
        T: Renderable,
    {
        self.bottom_item = Some(item.render());
        self
    }
}

impl Renderable for TitleBar {
    fn render(mut self) -> Node {
        let mut areas = String::new();
        if self.left_item.is_some() {
            areas.push_str("'left_item . right_item' 'title title title'");
        } else {
            areas.push_str("'title title right_item'");
        }
        if self.bottom_item.is_some() {
            areas.push_str("'bottom_item bottom_item bottom_item'");
        }
        self.add_class("titlebar").grid_areas(areas.as_str());

        if self.is_sticky {
            self.sticky_to_top(0);
        }

        self.node.children.push({
            if let Some(subtitle) = &self.subtitle {
                let mut stack = VStack::new(Alignment::Stretch);
                stack
                    .grid_area("title")
                    .append_child({ Text::new(self.title.as_str(), TextStyle::LargeTitle) })
                    .append_child({ Text::new(subtitle, TextStyle::H3) });
                stack.render()
            } else {
                let mut text = Text::new(self.title.as_str(), TextStyle::LargeTitle);
                text.grid_area("title");
                text.render()
            }
        });
        if let Some(mut left_item) = self.left_item {
            left_item
                .node_style
                .push(("grid-area".to_string(), "left_item".to_string()));
            self.node.children.push(left_item);
        }
        if let Some(mut right_item) = self.right_item {
            right_item
                .node_style
                .push(("grid-area".to_string(), "right_item".to_string()));
            self.node.children.push(right_item);
        }
        if let Some(mut bottom_item) = self.bottom_item {
            bottom_item
                .node_style
                .push(("grid-area".to_string(), "bottom_item".to_string()));
            self.node.children.push(bottom_item);
        }
        self.node
    }
}