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

// Copyright 2021-2022 Aaron Erhardt <aaron.erhardt@t-online.de>
// Copyright 2022 System76 <info@system76.com>
// SPDX-License-Identifier: MIT or Apache-2.0

use std::cell::Ref;
use std::fmt::{self, Debug};

use crate::Sender;

use super::{Component, StateWatcher};

/// Shared behavior of component controller types.
pub trait ComponentController<C: Component> {
    /// Emits an input to the component.
    fn emit(&self, event: C::Input) {
        self.sender().send(event).unwrap();
    }

    /// Provides access to the component's sender.
    fn sender(&self) -> &Sender<C::Input>;

    /// Provides access to the state of a component.
    fn state(&self) -> &StateWatcher<C>;

    /// Returns a reference to the [`Component`].
    fn model(&self) -> Ref<'_, C> {
        let part_ref = self.state().get();
        Ref::map(part_ref, |part| &part.model)
    }

    /// Returns a reference to the [`Component::Widgets`].
    fn widgets(&self) -> Ref<'_, C::Widgets> {
        let part_ref = self.state().get();
        Ref::map(part_ref, |part| &part.widgets)
    }

    /// Returns the root widget of the component.
    fn widget(&self) -> &C::Root;

    /// Dropping this type will usually stop the runtime of the component.
    /// With this method you can give the runtime a static lifetime.
    /// In other words, dropping the controller or connector will not stop
    /// the runtime anymore, instead it will run until the app is closed.
    fn detach_runtime(&mut self);
}

/// Controls the component from afar.
pub struct Controller<C: Component> {
    /// The models and widgets maintained by the component.
    pub(super) state: StateWatcher<C>,

    /// The widget that this component manages.
    pub(super) widget: C::Root,

    /// Used for emitting events to the component.
    pub(super) sender: Sender<C::Input>,
}

impl<C: Component> ComponentController<C> for Controller<C> {
    fn sender(&self) -> &Sender<C::Input> {
        &self.sender
    }

    fn state(&self) -> &StateWatcher<C> {
        &self.state
    }

    fn widget(&self) -> &C::Root {
        &self.widget
    }

    fn detach_runtime(&mut self) {
        self.state.detach_runtime();
    }
}

impl<C> Debug for Controller<C>
where
    C: Component + Debug,
    C::Widgets: Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Controller")
            .field("state", &self.state)
            .field("widget", &self.widget)
            .field("sender", &self.sender)
            .finish()
    }
}