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

use std::any::Any;

use super::{Id, View};

pub fn remember<F, S, G, V>(make_state: F, make_view: G) -> Remember<F, S, G, V> {
    Remember::new(make_state, make_view)
}

pub struct Remember<F, S, G, V> {
    make_state: F,
    state: Option<S>,
    make_view: G,
    view: Option<V>,
}

impl<F, S, G, V> Remember<F, S, G, V> {
    pub fn new(make_state: F, make_view: G) -> Self {
        Self {
            make_state,
            state: None,
            make_view,
            view: None,
        }
    }
}

impl<T, A, F, S, G, V> View<T, A> for Remember<F, S, G, V>
where
    F: FnMut() -> S,
    G: FnMut(&mut S) -> V,
    V: View<S, A>,
{
    fn build(&mut self, cx: &mut super::BuildContext) -> Id {
        let mut state = (self.make_state)();
        let mut view = (self.make_view)(&mut state);
        self.state = Some(state);
        let id = view.build(cx);
        self.view = Some(view);
        id
    }

    fn rebuild(&mut self, cx: &mut super::BuildContext, old: &mut Self) {
        let mut state = old.state.take().unwrap();
        let mut view = (self.make_view)(&mut state);
        self.state = Some(state);
        view.rebuild(cx, old.view.as_mut().unwrap());
        self.view = Some(view);
    }

    fn layout(&mut self, cx: &mut super::LayoutContext, id: super::Id) {
        self.view.as_mut().unwrap().layout(cx, id)
    }

    fn paint(&mut self, taffy: &taffy::Taffy, canvas: &mut skia_safe::Canvas) {
        self.view.as_mut().unwrap().paint(taffy, canvas)
    }

    fn message(&mut self, _state: &mut T, id_path: &[super::Id], message: &dyn Any) -> Option<A> {
        self.view
            .as_mut()
            .unwrap()
            .message(self.state.as_mut().unwrap(), id_path, message)
    }
}