tuix_widgets 0.2.0

Widgets for tuix
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

use crate::common::*;
use crate::widgets::{Label, Slider, SliderEvent, Textbox, TextboxEvent};

use crate::state::style::*;

#[derive(Clone)]
pub struct ValueSlider {
    pub slider: Entity,
    pub value: Entity,
    pub label: Entity,
    label_text: String,
}

impl ValueSlider {
    pub fn new(label_txt: &str) -> Self {
        ValueSlider {
            slider: Entity::null(),
            value: Entity::null(),
            label: Entity::null(),
            label_text: label_txt.to_string(),
        }
    }
}

impl Widget for ValueSlider {
    type Ret = Entity;
    fn on_build(&mut self, state: &mut State, entity: Entity) -> Self::Ret {
        entity
            .set_display(state, Display::Flexbox)
            .set_flex_direction(state, FlexDirection::Row);

        self.slider = Slider::new().build(state, entity, |builder| {
            builder.set_flex_grow(1.0).class("custom2")
        });
        self.value = Textbox::new("0.5").build(state, entity, |builder| {
            builder
                .set_flex_grow(0.0)
                .set_flex_basis(Units::Pixels(50.0))
                .set_margin_left(Units::Pixels(5.0))
        });
        self.label = Label::new(&self.label_text).build(state, self.slider, |builder| {
            builder
                .set_width(Units::Percentage(1.0))
                .set_height(Units::Percentage(1.0))
                .set_position(Position::Absolute)
                .set_text(&self.label_text)
                .set_padding_left(Units::Pixels(5.0))
                .set_hoverable(false)
        });

        state.style.insert_element(entity, "value_slider");

        entity
    }

    fn on_event(&mut self, state: &mut State, _entity: Entity, event: &mut Event) {
        if let Some(slider_event) = event.message.downcast::<SliderEvent>() {
            match slider_event {
                SliderEvent::ValueChanged(val) => {
                    if event.target == self.slider {
                        let val_str = format!("{:.*}", 5, &val.to_string());
                        state.insert_event(
                            Event::new(TextboxEvent::SetValue(val_str))
                                .target(self.value)
                                .propagate(Propagation::Direct),
                        );
                    }
                }

                _ => {}
            }
        }

        if let Some(textbox_event) = event.message.downcast::<TextboxEvent>() {
            match textbox_event {
                TextboxEvent::ValueChanged(text) => {
                    if event.target == self.value {
                        if let Ok(value) = text.parse::<f32>() {
                            let mut val = value;
                            if val <= 0.0 {
                                val = 0.0;
                            }
                            if val >= 1.0 {
                                val = 1.0;
                            }

                            let val_str = format!("{:.*}", 5, &val.to_string());
                            state.insert_event(
                                Event::new(TextboxEvent::SetValue(val_str))
                                    .target(self.value)
                                    .propagate(Propagation::Direct),
                            );

                            state.insert_event(
                                Event::new(SliderEvent::SetValue(val))
                                    .target(self.slider)
                                    .propagate(Propagation::Direct),
                            );
                        } else {
                            state.insert_event(
                                Event::new(TextboxEvent::ResetValue)
                                    .target(self.value)
                                    .propagate(Propagation::Direct),
                            );
                        }
                    }
                }

                _ => {}
            }
        }
    }
}