viewy 2.0.1

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

use std::borrow::BorrowMut;
use uuid::Uuid;

use crate::components::icons::IconPack;
use crate::components::{Alignment, Appendable, HStack, Icon, Text, TextStyle, View};
use crate::node::Node;
use crate::{DefaultModifiers, Renderable, scale};

#[derive(Debug, Clone)]
pub struct TabView {
    node: Node,
    tabs: Vec<TabViewItem>,
}

impl TabView {
    pub fn new() -> Self {
        Self {
            node: Default::default(),
            tabs: vec![],
        }
    }

    pub fn append_child(&mut self, child: TabViewItem) -> &mut Self {
        self.tabs.push(child);
        self
    }
}
impl std::ops::Deref for TabView {
    type Target = Node;

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

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

impl DefaultModifiers for TabView {}

impl Renderable for TabView {
    fn render(mut self) -> Node {
        self.add_class("tab-view");
        let mut tab_bar = HStack::new(Alignment::Stretch);
        tab_bar.add_class("tab-view__tab-container");

        let mut tabs_contents = View::new();
        tabs_contents.add_class("tab-view__content-container");

        for tabs in self.tabs {
            tab_bar.append_child({
                let mut tab = HStack::new(Alignment::Center);
                tab.gap(vec![scale(3)])
                    .set_attr("data-tabId", &tabs.id.to_string())
                    .add_class("tab-view__tab-container__tab")
                    .append_child(Text::new(&tabs.title, TextStyle::Label));
                if let Some(icon) = tabs.icon {
                    tab.prepend_child(Icon::new(icon).size(18).stroke_width(2));
                }
                if tabs.open {
                    tab.set_attr("data-is-open", "data-is-open")
                        .add_class("tab-view__tab-container__tab--active");
                }
                tab
            });
            tabs_contents.append_child({
                let mut tab_content = View::new();
                tab_content
                    .set_attr("data-tabId", &tabs.id.to_string())
                    .add_class("tab-view__content-container__content");
                tab_content.node.children = tabs.node.children;
                tab_content
            });
        }
        self.node.children.push(tab_bar.render());
        self.node.children.push(tabs_contents.render());

        self.node
    }
}

#[derive(Debug, Clone)]
pub struct TabViewItem {
    node: Node,
    pub id: Uuid,
    pub title: String,
    pub icon: Option<Box<dyn IconPack>>,
    pub open: bool,
}

impl TabViewItem {
    pub fn new(title: &str) -> TabViewItem {
        TabViewItem {
            node: Default::default(),
            id: Uuid::new_v4(),
            title: title.to_string(),
            icon: None,
            open: false,
        }
    }

    /// If set to true, this tab will be opened by default
    pub fn open(&mut self, is_open: bool) -> &mut Self {
        self.open = is_open;
        self
    }

    /// Define the icon displayed on the left of the tab
    pub fn icon<T>(&mut self, icon: T) -> &mut Self
    where
        T: 'static + IconPack,
    {
        self.icon = Some(Box::new(icon));
        self
    }
}
impl std::ops::Deref for TabViewItem {
    type Target = Node;

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

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

impl DefaultModifiers for TabViewItem {}

impl Appendable for TabViewItem {}

impl Renderable for TabViewItem {
    fn render(mut self) -> Node {
        self.add_class("tab-view-item");

        self.node
    }
}