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
use crate::engine::d2::util::{
Disposable, Listener0, Listener1, Listener2, Signal0, Signal1, Signal2,
};
use super::Component;
/// A component that manages a set of Disposable objects. When this component is removed from its
/// owner, all managed Disposables are disposed.
pub struct Disposer {
pub inner: Component,
disposables: Vec<Box<dyn Disposable>>,
}
impl Disposer {
pub fn new() -> Self {
Self {
inner: Default::default(),
disposables: Vec::new(),
}
}
/// Add a Disposable, so that it also gets disposed when this component does.
/// @returns This instance, for chaining.
pub fn add(&mut self, disposable: Box<dyn Disposable>) -> &Self {
self.disposables.push(disposable);
self
}
/// Remove a Disposable from this disposer.
/// @returns True if the disposable was removed.
pub fn remove(&self, disposable: impl Disposable) /*-> bool*/
{
// self._disposables.remove(disposable)
unimplemented!()
}
/// Chainable convenience method for connecting a signal listener and adding its SignalConnection
/// to this disposer.
/// @returns This instance, for chaining.
pub fn connect0(&mut self, signal: Signal0, listener: Listener0) -> &Self {
self.add(Box::new(signal.connect(listener, false)));
self
}
/// Chainable convenience method for connecting a signal listener and adding its SignalConnection
/// to this disposer.
/// @returns This instance, for chaining.
pub fn connect1<A>(&mut self, signal: Signal1<A>, listener: Listener1<A>) -> &Self {
self.add(Box::new(signal.connect(listener, false)));
self
}
/// Chainable convenience method for connecting a signal listener and adding its SignalConnection
/// to this disposer.
/// @returns This instance, for chaining.
pub fn connect2<A, B>(&mut self, signal: Signal2<A, B>, listener: Listener2<A, B>) -> &Self {
self.add(Box::new(signal.connect(listener, false)));
self
}
// override
pub fn on_removed(&mut self) {
self.free_disposables();
}
// override
pub fn dispose(&mut self) {
self.inner.dispose();
self.free_disposables(); // Cleanup even if this component had no owner
}
fn free_disposables(&mut self) {
while let Some(disposable) = self.disposables.pop() {
disposable.dispose()
}
}
}
impl AsRef<Component> for Disposer {
fn as_ref(&self) -> &Component {
&self.inner
}
}