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

use taffy::style::FlexDirection;

use crate::{
    context::UpdateCx,
    id::ViewId,
    style::{Style, StyleClassRef},
    view::{IntoView, View},
    view_tuple::ViewTuple,
};

/// A collection of static views. See [`stack`] and [`stack_from_iter`].
///
/// The children of a stack can still get reactive updates.
pub struct Stack {
    id: ViewId,
    direction: Option<FlexDirection>,
}

pub(crate) fn create_stack(
    children: Vec<Box<dyn View>>,
    direction: Option<FlexDirection>,
) -> Stack {
    let id = ViewId::new();
    id.set_children(children);

    Stack { id, direction }
}

/// A basic stack that is built from a tuple of views which remains static and always contains the same elements in the same order.
///
/// The children of a stack can still get reactive updates.
/// See also [`v_stack`] and [`h_stack`].
///
/// ## Example
/// ```rust
/// use floem::views::*;
/// stack((
///    text("first element"),
///     stack((
///        text("new stack"),
///        empty(),
///     )),
/// ));
/// ```
pub fn stack<VT: ViewTuple + 'static>(children: VT) -> Stack {
    create_stack(children.into_views(), None)
}

/// A stack which defaults to `FlexDirection::Row`. See also [`v_stack`].
pub fn h_stack<VT: ViewTuple + 'static>(children: VT) -> Stack {
    create_stack(children.into_views(), Some(FlexDirection::Row))
}

/// A stack which defaults to `FlexDirection::Column`. See also [`h_stack`].
pub fn v_stack<VT: ViewTuple + 'static>(children: VT) -> Stack {
    create_stack(children.into_views(), Some(FlexDirection::Column))
}

fn from_iter<V>(iterator: impl IntoIterator<Item = V>, direction: Option<FlexDirection>) -> Stack
where
    V: IntoView + 'static,
{
    create_stack(
        iterator
            .into_iter()
            .map(|v| -> Box<dyn View> { v.into_any() })
            .collect(),
        direction,
    )
}

/// Creates a stack from an iterator of views. See also [`v_stack_from_iter`] and [`h_stack_from_iter`].
///
/// ## Example
/// ```rust
/// use floem::views::*;
/// stack_from_iter(vec![1,1,2,2,3,4,5,6,7,8,9].iter().map(|val| text(val)));
/// ```
pub fn stack_from_iter<V>(iterator: impl IntoIterator<Item = V>) -> Stack
where
    V: IntoView + 'static,
{
    from_iter(iterator, None)
}

/// Creates a stack from an iterator of views. It defaults to `FlexDirection::Row`. See also [`v_stack_from_iter`].
pub fn h_stack_from_iter<V>(iterator: impl IntoIterator<Item = V>) -> Stack
where
    V: IntoView + 'static,
{
    from_iter(iterator, Some(FlexDirection::Row))
}

/// Creates a stack from an iterator of views. It defaults to `FlexDirection::Column`.See also [`h_stack_from_iter`].
pub fn v_stack_from_iter<V>(iterator: impl IntoIterator<Item = V>) -> Stack
where
    V: IntoView + 'static,
{
    from_iter(iterator, Some(FlexDirection::Column))
}

impl View for Stack {
    fn id(&self) -> ViewId {
        self.id
    }

    fn view_style(&self) -> Option<crate::style::Style> {
        self.direction
            .map(|direction| Style::new().flex_direction(direction))
    }

    fn debug_name(&self) -> std::borrow::Cow<'static, str> {
        match self.direction {
            Some(FlexDirection::Column) => "Vertical Stack".into(),
            Some(FlexDirection::Row) => "Horizontal Stack".into(),
            _ => "Stack".into(),
        }
    }

    fn update(&mut self, _cx: &mut UpdateCx, state: Box<dyn std::any::Any>) {
        if let Ok(state) = state.downcast::<Vec<Box<dyn View>>>() {
            self.id.set_children(*state);
            self.id.request_all();
        }
    }
}

impl Stack {
    pub fn add_class_by_idx(self, class: impl Fn(usize) -> StyleClassRef) -> Self {
        for (index, child) in self.id.children().into_iter().enumerate() {
            let style_class = class(index);
            child.add_class(style_class);
        }
        self
    }
}

pub trait StackExt {
    fn stack(self, direction: FlexDirection) -> Stack;
    fn v_stack(self) -> Stack
    where
        Self: Sized,
    {
        StackExt::stack(self, FlexDirection::Column)
    }
    fn h_stack(self) -> Stack
    where
        Self: Sized,
    {
        StackExt::stack(self, FlexDirection::Row)
    }
}
impl<V: IntoView + 'static, T: IntoIterator<Item = V> + 'static> StackExt for T {
    fn stack(self, direction: FlexDirection) -> Stack {
        from_iter(self, Some(direction))
    }
}