floem 0.2.0

A native Rust UI library with fine-grained reactivity
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

use crate::{
    style_class,
    view::View,
    views::{self, container, empty, h_stack, Decorators},
    IntoView,
};
use floem_reactive::{SignalGet, SignalUpdate};

use super::{create_value_container_signals, value_container, ValueContainer};

style_class!(pub RadioButtonClass);
style_class!(pub RadioButtonDotClass);
style_class!(pub RadioButtonDotSelectedClass);
style_class!(pub LabeledRadioButtonClass);

fn radio_button_svg<T>(represented_value: T, actual_value: impl SignalGet<T> + 'static) -> impl View
where
    T: Eq + PartialEq + Clone + 'static,
{
    container(empty().class(RadioButtonDotClass).style(move |s| {
        s.apply_if(actual_value.get() != represented_value, |s| {
            s.display(taffy::style::Display::None)
        })
    }))
    .class(RadioButtonClass)
}

/// The `RadioButton` struct provides various methods to create and manage radio buttons.
///
/// # Related Functions
/// - [`radio_button`]
/// - [`labeled_radio_button`]
pub struct RadioButton;

impl RadioButton {
    /// Creates a new radio button with a closure that determines its selected state.
    ///
    /// This method is useful when you want a radio button whose state is determined by a closure.
    /// The state can be dynamically updated by the closure, and the radio button will reflect these changes.
    #[allow(clippy::new_ret_no_self)]
    pub fn new<T>(represented_value: T, actual_value: impl Fn() -> T + 'static) -> ValueContainer<T>
    where
        T: Eq + PartialEq + Clone + 'static,
    {
        let (inbound_signal, outbound_signal) = create_value_container_signals(actual_value);

        value_container(
            radio_button_svg(represented_value.clone(), inbound_signal.read_only())
                .keyboard_navigable()
                .on_click_stop(move |_| {
                    outbound_signal.set(represented_value.clone());
                }),
            move || outbound_signal.get(),
        )
    }

    /// Creates a new radio button with a signal that provides its selected state.
    ///
    /// Use this method when you have a signal that provides the current state of the radio button.
    /// The radio button will automatically update its state based on the signal.
    pub fn new_get<T>(
        represented_value: T,
        actual_value: impl SignalGet<T> + 'static,
    ) -> impl IntoView
    where
        T: Eq + PartialEq + Clone + 'static,
    {
        radio_button_svg(represented_value, actual_value).keyboard_navigable()
    }

    /// Creates a new radio button with a signal that provides and updates its selected state.
    ///
    /// This method is ideal when you need a radio button that not only reflects a signal's state but also updates it.
    /// Clicking the radio button will set the signal to the represented value.
    pub fn new_rw<T>(
        represented_value: T,
        actual_value: impl SignalGet<T> + SignalUpdate<T> + Copy + 'static,
    ) -> impl IntoView
    where
        T: Eq + PartialEq + Clone + 'static,
    {
        let cloneable_represented_value = represented_value.clone();

        radio_button_svg(cloneable_represented_value.clone(), actual_value)
            .keyboard_navigable()
            .on_click_stop(move |_| {
                actual_value.set(cloneable_represented_value.clone());
            })
    }

    /// Creates a new labeled radio button with a closure that determines its selected state.
    ///
    /// This method is useful when you want a labeled radio button whose state is determined by a closure.
    /// The label is also provided by a closure, allowing for dynamic updates.
    pub fn new_labeled<S: std::fmt::Display + 'static, T>(
        represented_value: T,
        actual_value: impl Fn() -> T + 'static,
        label: impl Fn() -> S + 'static,
    ) -> ValueContainer<T>
    where
        T: Eq + PartialEq + Clone + 'static,
    {
        let (inbound_signal, outbound_signal) = create_value_container_signals(actual_value);

        value_container(
            h_stack((
                radio_button_svg(represented_value.clone(), inbound_signal.read_only()),
                views::label(label),
            ))
            .class(LabeledRadioButtonClass)
            .style(|s| s.items_center())
            .keyboard_navigable()
            .on_click_stop(move |_| {
                outbound_signal.set(represented_value.clone());
            }),
            move || outbound_signal.get(),
        )
    }

    /// Creates a new labeled radio button with a signal that provides its selected state.
    ///
    /// Use this method when you have a signal that provides the current state of the radio button and you also want a label.
    /// The radio button and label will automatically update based on the signal.
    pub fn new_labeled_get<S: std::fmt::Display + 'static, T>(
        represented_value: T,
        actual_value: impl SignalGet<T> + 'static,
        label: impl Fn() -> S + 'static,
    ) -> impl IntoView
    where
        T: Eq + PartialEq + Clone + 'static,
    {
        h_stack((
            radio_button_svg(represented_value, actual_value),
            views::label(label),
        ))
        .class(LabeledRadioButtonClass)
        .style(|s| s.items_center())
        .keyboard_navigable()
    }

    /// Creates a new labeled radio button with a signal that provides and updates its selected state.
    ///
    /// This method is ideal when you need a labeled radio button that not only reflects a signal's state but also updates it.
    /// Clicking the radio button will set the signal to the represented value.
    pub fn new_labeled_rw<S: std::fmt::Display + 'static, T>(
        represented_value: T,
        actual_value: impl SignalGet<T> + SignalUpdate<T> + Copy + 'static,
        label: impl Fn() -> S + 'static,
    ) -> impl IntoView
    where
        T: Eq + PartialEq + Clone + 'static,
    {
        let cloneable_represented_value = represented_value.clone();

        h_stack((
            radio_button_svg(cloneable_represented_value.clone(), actual_value),
            views::label(label),
        ))
        .class(LabeledRadioButtonClass)
        .style(|s| s.items_center())
        .keyboard_navigable()
        .on_click_stop(move |_| {
            actual_value.set(cloneable_represented_value.clone());
        })
    }
}

/// Renders a radio button that appears as selected if the signal equals the given enum value.
/// Can be combined with a label and a stack with a click event (as in `examples/widget-gallery`).
pub fn radio_button<T>(
    represented_value: T,
    actual_value: impl Fn() -> T + 'static,
) -> ValueContainer<T>
where
    T: Eq + PartialEq + Clone + 'static,
{
    RadioButton::new(represented_value, actual_value)
}

/// Renders a radio button that appears as selected if the signal equals the given enum value.
pub fn labeled_radio_button<S: std::fmt::Display + 'static, T>(
    represented_value: T,
    actual_value: impl Fn() -> T + 'static,
    label: impl Fn() -> S + 'static,
) -> ValueContainer<T>
where
    T: Eq + PartialEq + Clone + 'static,
{
    RadioButton::new_labeled(represented_value, actual_value, label)
}