vgtk 0.3.0

A declarative UI framework for GTK
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

use glib::{Cast, Object};
use gtk::{self, Widget};

use crate::component::Component;
use crate::scope::Scope;
use crate::vnode::VNode;

mod component_state;
pub(crate) use component_state::ComponentState;

mod gtk_state;
use gtk_state::GtkState;

pub(crate) enum State<Model: Component> {
    Gtk(GtkState<Model>),
    Component(ComponentState<Model>),
}

impl<Model: 'static + Component> State<Model> {
    /// Build a full state from a `VItem` spec.
    pub(crate) fn build(
        vnode: &VNode<Model>,
        parent: Option<&Object>,
        scope: &Scope<Model>,
    ) -> Self {
        match vnode {
            VNode::Object(object) => State::Gtk(GtkState::build(object, parent, scope)),
            VNode::Component(vcomp) => {
                let comp = (vcomp.constructor)(&vcomp.props, parent, &vcomp.child_props, scope);
                State::Component(comp)
            }
        }
    }

    /// Build a full state from a `VItem` spec.
    pub(crate) fn build_root(
        vnode: &VNode<Model>,
        parent: Option<&Object>,
        scope: &Scope<Model>,
    ) -> Self {
        match vnode {
            VNode::Object(object) => State::Gtk(GtkState::build_root(object, parent, scope)),
            VNode::Component(_vcomp) => {
                // let comp = (vcomp.constructor)(&vcomp.props, parent, &vcomp.child_props, scope);
                // State::Component(comp)
                unimplemented!()
            }
        }
    }

    pub(crate) fn build_children(&mut self, vnode: &VNode<Model>, scope: &Scope<Model>) {
        match vnode {
            VNode::Object(vobject) => match self {
                State::Gtk(gtk_state) => gtk_state.build_children(vobject, scope),
                _ => unimplemented!(),
            },
            _ => unimplemented!(),
        }
    }

    /// Patch a state in place with a `VItem` spec.
    ///
    /// Returns true if patching succeeded, or false if a rebuild is required.
    #[must_use]
    pub(crate) fn patch(
        &mut self,
        vnode: &VNode<Model>,
        parent: Option<&Object>,
        scope: &Scope<Model>,
    ) -> bool {
        match vnode {
            VNode::Object(object) => match self {
                State::Gtk(state) => state.patch(object, parent, scope),
                State::Component(_) => false,
            },
            VNode::Component(vcomp) => match self {
                State::Component(state) => state.patch(vcomp, parent, scope),
                State::Gtk(_) => false,
            },
        }
    }

    pub(crate) fn unmount(self) {
        match self {
            State::Gtk(state) => state.unmount(),
            State::Component(state) => state.unmount(),
        }
    }

    /// Get the Glib `Object` represented by this state.
    pub(crate) fn object(&self) -> &Object {
        match self {
            State::Gtk(state) => &state.object,
            State::Component(state) => &state.object,
        }
    }

    /// Get the Gtk `Widget` represented by this state, if it has a `Widget`.
    pub(crate) fn widget(&self) -> Option<&Widget> {
        match self {
            State::Gtk(state) => state.object.downcast_ref::<Widget>(),
            State::Component(state) => state.object.downcast_ref::<Widget>(),
        }
    }
}