kagura 0.14.3

component-oriented GUI 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
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

//! # Examples
//!
//! ```
//! use kagura::prelude::*;
//! use tokio::time;
//!
//! struct Props {
//!     initial_count: usize,
//! }
//!
//! enum Msg {
//!     SetCount(usize)
//! }
//!
//! enum On {}
//!
//! struct Timer {
//!     interval: u64,
//! }
//!
//! struct MyComponent {
//!     count: usize,
//! }
//!
//! impl BatchProcess<MyComponent> for Timer {
//!     fn poll(&mut self) -> Pin<Box<dyn Future<Output = Cmd<MyComponent>>>> {
//!         let duration = Duration::from_millis(self.interval);
//!         Box::pin(async move {
//!             time::sleep(duration).await;
//!             Cmd::chain(Msg::SetCount(count + 1))
//!         })
//!     }
//! }
//!
//! impl Component for MyComponent {
//!     type Props = Props;
//!     type Msg = Msg;
//!     type Event = On;
//! }
//!
//! impl Constructor for MyComponent {
//!     fn constructor(props: Props) -> Self {
//!         Self { count: props.initial_count }
//!     }
//! }
//!
//! impl Update for MyComponent {
//!     fn on_assemble(self: Pin<&mut Self>) -> Cmd<Self> {
//!         Cmd::batch(Timer {
//!             interval: 1000
//!         })
//!     }
//!
//!     fn on_load(self: Pin<&mut Self>, props: Props) -> Cmd<Self> {
//!         if self.count < props.initial_count {
//!             self.count = props.initial_count;
//!         }
//!         Cmd::none()
//!     }
//!
//!     fn update(self: Pin<&mut Self>, msg: Msg) -> Cmd<Self> {
//!         match msg {
//!             Msg::SetCount(count) => {
//!                 self.count = count;
//!                 Cmd::none()
//!             }
//!         }
//!     }
//! }
//!
//! impl Render<String> for MyComponent {
//!     type Children = (String, String);
//!     fn render(&self, (prefix, suffix): Self::Children) -> String {
//!         format!("{}{}{}", prefix, self.count, suffix)
//!     }
//! }
//! ```

pub mod cmd;

use std::pin::Pin;

pub use cmd::BatchProcess;
pub use cmd::Cmd;

/// `Component` trait is a common component in Kagura-component.  
/// In this trait, tyoes of `Props`, `Msg` and `Event` are defined.
///
pub trait Component: Sized {
    /// The type of property of this component.  
    /// Parent component gives a property to this component. The property will be used to generate initial state of this component.
    type Props;

    /// The type of message of this component.  
    /// A message transfers message of an event and so on occurs in this component to `update` function.
    type Msg;

    /// The type of event of this component.  
    /// An event transfers message to parent component.
    type Event;
}

/// A constructor of the component is defined.  
/// The Constructor generates a component with `Props`.
pub trait Constructor: Component {
    /// The constructor of a component.
    ///
    /// # Arguments
    ///
    /// - `props` - A property which given by parent component to generate this component.
    fn constructor(_props: Self::Props) -> Self;
}

pub trait Update: Component {
    fn on_assemble(self: Pin<&mut Self>) -> Cmd<Self> {
        Cmd::None
    }
    fn on_load(self: Pin<&mut Self>, _props: Self::Props) -> Cmd<Self> {
        Cmd::None
    }
    fn update(self: Pin<&mut Self>, _msg: Self::Msg) -> Cmd<Self> {
        Cmd::None
    }
}

pub trait Render<T>: Component {
    type Children: Default;
    fn render(&self, children: Self::Children) -> T;
}