fui_core 0.1.0

Core library of FUI MVVM UI Framework
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

use std::cell::RefCell;
use std::rc::Rc;
use std::rc::Weak;

use crate::Callback;

///
/// EventSubscription is an owner of the callback.
/// Calling the callback stops when EventSubscription is dropped.
///
pub struct EventSubscription {
    _callback: Rc<dyn CallbackObject>,
}

pub trait CallbackObject {}
impl<A> CallbackObject for Callback<A> {}

pub struct Event<A> {
    callbacks: RefCell<Vec<Weak<Callback<A>>>>,
}

impl<A: 'static + Clone> Event<A> {
    pub fn new() -> Self {
        Event {
            callbacks: RefCell::new(Vec::new()),
        }
    }

    pub fn subscribe<F: 'static + Fn(A)>(&mut self, f: F) -> EventSubscription {
        let mut callback = Callback::<A>::empty();
        callback.set(f);
        let rc_callback = Rc::new(callback);
        let weak_callback = Rc::downgrade(&rc_callback);
        self.callbacks.borrow_mut().push(weak_callback);

        EventSubscription {
            _callback: rc_callback,
        }
    }

    pub fn emit(&self, args: A) {
        let mut cleanup = false;

        for weak_callback in self.callbacks.borrow().iter() {
            if let Some(callback) = weak_callback.upgrade() {
                callback.emit(args.clone());
            } else {
                cleanup = true;
            }
        }

        if cleanup {
            self.callbacks.borrow_mut().retain(|ref weak_callback| {
                let got_ref = weak_callback.clone().upgrade();
                match got_ref {
                    None => false,
                    _ => true,
                }
            });
        }
    }
}