relm4 0.11.0

An idiomatic GUI library inspired by Elm and based on gtk4-rs
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
130
131

// Prevent false positive in nightly
#![allow(unused_qualifications)]

//! Traits for for managing and updating factories.

use crate::Sender;
use crate::channel::AsyncFactorySender;
use crate::factory::{AsyncPosition, DynamicIndex, FactoryView};
use crate::loading_widgets::LoadingWidgets;

use std::fmt::Debug;

/// A component that's stored inside a factory.
/// Similar to [`Component`](crate::Component) but adjusted to fit the life cycle
/// of factories.
pub trait AsyncFactoryComponent:
    AsyncPosition<<Self::ParentWidget as FactoryView>::Position> + Sized + 'static
{
    /// Container widget to which all widgets of the factory will be added.
    type ParentWidget: FactoryView + 'static;

    /// Messages which are received from commands executing in the background.
    type CommandOutput: Debug + Send + 'static;

    /// The message type that the factory component accepts as inputs.
    type Input: Debug + 'static;

    /// The message type that the factory component provides as outputs.
    type Output: Debug + 'static;

    /// The parameter used to initialize the factory component.
    type Init;

    /// The top-level widget of the factory component.
    type Root: AsRef<<Self::ParentWidget as FactoryView>::Children> + Debug + Clone;

    /// The type that's used for storing widgets created for this factory component.
    type Widgets: 'static;

    /// Initializes the model.
    fn init_model(
        init: Self::Init,
        index: &DynamicIndex,
        sender: AsyncFactorySender<Self>,
    ) -> impl std::future::Future<Output = Self>;

    /// Initializes the root widget
    fn init_root() -> Self::Root;

    /// Allows you to initialize the root widget with a temporary value
    /// as a placeholder until the [`init_model()`] future completes.
    ///
    /// This method does nothing by default.
    ///
    /// [`init_model()`]: AsyncFactoryComponent::init_model
    #[must_use]
    fn init_loading_widgets(_root: Self::Root) -> Option<LoadingWidgets> {
        None
    }

    /// Initializes the widgets.
    fn init_widgets(
        &mut self,
        index: &DynamicIndex,
        root: Self::Root,
        returned_widget: &<Self::ParentWidget as FactoryView>::ReturnedWidget,
        sender: AsyncFactorySender<Self>,
    ) -> Self::Widgets;

    /// Processes inputs received by the component.
    #[allow(unused)]
    fn update(
        &mut self,
        message: Self::Input,
        sender: AsyncFactorySender<Self>,
    ) -> impl std::future::Future<Output = ()> {
        async {}
    }

    /// Defines how the component should respond to command updates.
    #[allow(unused)]
    fn update_cmd(
        &mut self,
        message: Self::CommandOutput,
        sender: AsyncFactorySender<Self>,
    ) -> impl std::future::Future<Output = ()> {
        async {}
    }

    /// Handles updates from a command.
    fn update_cmd_with_view(
        &mut self,
        widgets: &mut Self::Widgets,
        message: Self::CommandOutput,
        sender: AsyncFactorySender<Self>,
    ) -> impl std::future::Future<Output = ()> {
        async {
            self.update_cmd(message, sender.clone()).await;
            self.update_view(widgets, sender);
        }
    }

    /// Updates the view after the model has been updated.
    #[allow(unused)]
    fn update_view(&self, widgets: &mut Self::Widgets, sender: AsyncFactorySender<Self>) {}

    /// Updates the model and view. Optionally returns a command to run.
    fn update_with_view(
        &mut self,
        widgets: &mut Self::Widgets,
        message: Self::Input,
        sender: AsyncFactorySender<Self>,
    ) -> impl std::future::Future<Output = ()> {
        async {
            self.update(message, sender.clone()).await;
            self.update_view(widgets, sender);
        }
    }

    /// Last method called before a factory component is shut down.
    #[allow(unused)]
    fn shutdown(&mut self, widgets: &mut Self::Widgets, output: Sender<Self::Output>) {}

    /// An identifier for the component used for debug logging.
    ///
    /// The default implementation of this method uses the address of the component, but
    /// implementations are free to provide more meaningful identifiers.
    fn id(&self) -> String {
        format!("{:p}", &self)
    }
}