flo_ui 0.1.0

Implementation-free user interface description library
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

use super::*;
use super::core::*;
use super::event::*;
use super::update::*;
use super::event_sink::*;
use super::update_stream::*;
use super::super::controller::*;
use super::super::user_interface::*;

use desync::*;
use binding::*;

use std::sync::*;
use std::ops::Deref;

///
/// UI session provides a raw user interface implementation for a core controller
/// 
pub struct UiSession<CoreController: Controller> {
    /// The core controller
    controller: Arc<CoreController>,

    /// The core of the UI session
    core: Arc<Desync<UiSessionCore>>,

    /// A releasable that tracks UI updates
    ui_update_lifetime: Mutex<Box<Releasable>>
}

impl<CoreController: Controller+'static> UiSession<CoreController> {
    ///
    /// Cretes a new UI session with the specified core controller
    /// 
    pub fn new(controller: CoreController) -> UiSession<CoreController> {
        let controller          = Arc::new(controller);
        let core                = UiSessionCore::new(controller.clone());
        let core                = Arc::new(Desync::new(core));

        let ui_update_lifetime  = Self::track_ui_updates(Arc::clone(&core));

        UiSession {
            controller:         controller,
            core:               core,
            ui_update_lifetime: Mutex::new(ui_update_lifetime)
        }
    }

    ///
    /// Causes wake_for_updates to be called on a core when its UI changes
    /// 
    fn track_ui_updates(core: Arc<Desync<UiSessionCore>>) -> Box<Releasable> {
        let update_core = Arc::clone(&core);

        core.sync(move |core| {
            let ui = core.ui_tree();

            ui.when_changed(notify(move || update_core.async(|core| core.wake_for_updates())))
        })
    }
}

impl<CoreController: Controller> Drop for UiSession<CoreController> {
    fn drop(&mut self) {
        self.ui_update_lifetime.lock().unwrap().done();
    }
}

impl<CoreController: Controller> Deref for UiSession<CoreController> {
    type Target = Arc<CoreController>;

    fn deref(&self) -> &Arc<CoreController> {
        &self.controller
    }
}

impl<CoreController: 'static+Controller> UserInterface<Vec<UiEvent>, Vec<UiUpdate>, ()> for UiSession<CoreController> {
    /// The type of the event sink for this UI
    type EventSink = UiEventSink;

    /// The type of the update stream for this UI
    type UpdateStream = UiUpdateStream;

    /// Retrieves an input event sink for this user interface
    fn get_input_sink(&self) -> UiEventSink {
        UiEventSink::new(Arc::clone(&self.controller), Arc::clone(&self.core))
    }

    /// Retrieves a view onto the update stream for this user interface
    fn get_updates(&self) -> UiUpdateStream {
        UiUpdateStream::new(self.controller.clone(), Arc::clone(&self.core))
    }
}

impl<CoreController: 'static+Controller> CoreUserInterface for UiSession<CoreController> {
    fn ui_tree(&self) -> BindRef<Control> {
        self.core.sync(|core| core.ui_tree())
    }
}