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 132 133 134 135 136 137
// 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 super::stream::ComponentStream;
use super::{Component, ComponentController, Controller, StateWatcher};
use crate::{Receiver, Sender};
use std::fmt::{self, Debug};
/// Contains the post-launch input sender and output receivers with the root widget.
///
/// The receiver can be separated from the [`Connector`] by choosing a method for handling it.
pub struct Connector<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>,
/// The outputs being received by the component.
pub(super) receiver: Receiver<C::Output>,
}
impl<C: Component> Connector<C> {
/// Forwards output events to the designated sender.
pub fn forward<X: 'static, F: (Fn(C::Output) -> X) + 'static>(
self,
sender_: &Sender<X>,
transform: F,
) -> Controller<C> {
let Self {
state,
widget,
sender,
receiver,
} = self;
crate::spawn_local(receiver.forward(sender_.clone(), transform));
Controller {
state,
widget,
sender,
}
}
/// Given a mutable closure, captures the receiver for handling.
pub fn connect_receiver<F: FnMut(&mut Sender<C::Input>, C::Output) + 'static>(
self,
mut func: F,
) -> Controller<C> {
let Self {
state,
widget,
sender,
receiver,
} = self;
let mut sender_ = sender.clone();
crate::spawn_local(async move {
while let Some(event) = receiver.recv().await {
func(&mut sender_, event);
}
});
Controller {
state,
widget,
sender,
}
}
/// Ignore outputs from the component and finish the builder.
pub fn detach(self) -> Controller<C> {
let Self {
state,
widget,
sender,
..
} = self;
Controller {
state,
widget,
sender,
}
}
/// Convert his type into a [`Stream`](futures::Stream) that yields output events
/// as futures.
pub fn into_stream(self) -> ComponentStream<C> {
let Self {
receiver, state, ..
} = self;
ComponentStream {
stream: receiver.into_stream(),
shutdown_on_drop: state.shutdown_on_drop,
}
}
}
impl<C: Component> ComponentController<C> for Connector<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 Connector<C>
where
C: Component + Debug,
C::Widgets: Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Connector")
.field("state", &self.state)
.field("widget", &self.widget)
.field("sender", &self.sender)
.field("receiver", &self.receiver)
.finish()
}
}