plasmo 0.4.3

TUI-based renderer for Dioxus
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
146
147
148
149
150
151
152
153
154
155

use dioxus_native_core::{
    custom_element::CustomElement, node::OwnedAttributeDiscription, prelude::NodeType,
    real_dom::NodeImmutable,
};

use super::{
    checkbox::CheckBox, number::Number, password::Password, slider::Slider, textbox::TextBox,
    RinkWidget,
};
use crate::widgets::button::Button;

pub(crate) enum Input {
    Button(Button),
    CheckBox(CheckBox),
    TextBox(TextBox),
    Password(Password),
    Number(Number),
    Slider(Slider),
}

impl CustomElement for Input {
    const NAME: &'static str = "input";

    fn roots(&self) -> Vec<dioxus_native_core::NodeId> {
        match self {
            Input::Button(button) => button.roots(),
            Input::CheckBox(checkbox) => checkbox.roots(),
            Input::TextBox(textbox) => textbox.roots(),
            Input::Password(password) => password.roots(),
            Input::Number(number) => number.roots(),
            Input::Slider(slider) => slider.roots(),
        }
    }

    fn slot(&self) -> Option<dioxus_native_core::NodeId> {
        match self {
            Input::Button(button) => button.slot(),
            Input::CheckBox(checkbox) => checkbox.slot(),
            Input::TextBox(textbox) => textbox.slot(),
            Input::Password(password) => password.slot(),
            Input::Number(number) => number.slot(),
            Input::Slider(slider) => slider.slot(),
        }
    }

    fn create(mut root: dioxus_native_core::real_dom::NodeMut) -> Self {
        {
            // currently widgets are not allowed to have children
            let children = root.child_ids();
            let rdom = root.real_dom_mut();
            for child in children {
                if let Some(mut child) = rdom.get_mut(child) {
                    child.remove();
                }
            }
        }

        let node_type = root.node_type();
        let NodeType::Element(el) = &*node_type else {
            panic!("input must be an element")
        };
        let input_type = el
            .attributes
            .get(&OwnedAttributeDiscription {
                name: "type".to_string(),
                namespace: None,
            })
            .and_then(|value| value.as_text());
        match input_type
            .map(|type_| type_.trim().to_lowercase())
            .as_deref()
        {
            Some("button") => {
                drop(node_type);
                Input::Button(Button::create(root))
            }
            Some("checkbox") => {
                drop(node_type);
                Input::CheckBox(CheckBox::create(root))
            }
            Some("textbox") => {
                drop(node_type);
                Input::TextBox(TextBox::create(root))
            }
            Some("password") => {
                drop(node_type);
                Input::Password(Password::create(root))
            }
            Some("number") => {
                drop(node_type);
                Input::Number(Number::create(root))
            }
            Some("range") => {
                drop(node_type);
                Input::Slider(Slider::create(root))
            }
            _ => {
                drop(node_type);
                Input::TextBox(TextBox::create(root))
            }
        }
    }

    fn attributes_changed(
        &mut self,
        root: dioxus_native_core::real_dom::NodeMut,
        attributes: &dioxus_native_core::node_ref::AttributeMask,
    ) {
        match self {
            Input::Button(button) => {
                button.attributes_changed(root, attributes);
            }
            Input::CheckBox(checkbox) => {
                checkbox.attributes_changed(root, attributes);
            }
            Input::TextBox(textbox) => {
                textbox.attributes_changed(root, attributes);
            }
            Input::Password(password) => {
                password.attributes_changed(root, attributes);
            }
            Input::Number(number) => {
                number.attributes_changed(root, attributes);
            }
            Input::Slider(slider) => {
                slider.attributes_changed(root, attributes);
            }
        }
    }
}

impl RinkWidget for Input {
    fn handle_event(&mut self, event: &crate::Event, node: dioxus_native_core::real_dom::NodeMut) {
        match self {
            Input::Button(button) => {
                button.handle_event(event, node);
            }
            Input::CheckBox(checkbox) => {
                checkbox.handle_event(event, node);
            }
            Input::TextBox(textbox) => {
                textbox.handle_event(event, node);
            }
            Input::Password(password) => {
                password.handle_event(event, node);
            }
            Input::Number(number) => {
                number.handle_event(event, node);
            }
            Input::Slider(slider) => {
                slider.handle_event(event, node);
            }
        }
    }
}