pub struct Weak<T: ComponentHandle> { /* private fields */ }Expand description
Struct that’s used to hold weak references of a Slint component
In order to create a Weak, you should use ComponentHandle::as_weak.
Strong references should not be captured by the functions given to a lambda, as this would produce a reference loop and leak the component. Instead, the callback function should capture a weak component.
The Weak component also implement Send and can be send to another thread.
but the upgrade function will only return a valid component from the same thread
as the one it has been created from.
This is useful to use with invoke_from_event_loop() or Self::upgrade_in_event_loop().
Implementations§
Source§impl<T: ComponentHandle> Weak<T>
impl<T: ComponentHandle> Weak<T>
Sourcepub fn upgrade(&self) -> Option<T>where
T: ComponentHandle,
pub fn upgrade(&self) -> Option<T>where
T: ComponentHandle,
Returns a new strongly referenced component if some other instance still holds a strong reference. Otherwise, returns None.
This also returns None if the current thread is not the thread that created the component
Sourcepub fn unwrap(&self) -> T
pub fn unwrap(&self) -> T
Convenience function that returns a new strongly referenced component if some other instance still holds a strong reference and the current thread is the thread that created this component. Otherwise, this function panics.
Sourcepub fn upgrade_in_event_loop(
&self,
func: impl FnOnce(T) + Send + 'static,
) -> Result<(), EventLoopError>where
T: 'static,
pub fn upgrade_in_event_loop(
&self,
func: impl FnOnce(T) + Send + 'static,
) -> Result<(), EventLoopError>where
T: 'static,
Convenience function that combines invoke_from_event_loop() with Self::upgrade()
The given functor will be added to an internal queue and will wake the event loop.
On the next iteration of the event loop, the functor will be executed with a T as an argument.
If the component was dropped because there are no more strong reference to the component, the functor will not be called.
§Example
slint::slint! { export component MyApp inherits Window { in property <int> foo; /* ... */ } }
let handle = MyApp::new().unwrap();
let handle_weak = handle.as_weak();
let thread = std::thread::spawn(move || {
// ... Do some computation in the thread
let foo = 42;
// now forward the data to the main thread using upgrade_in_event_loop
handle_weak.upgrade_in_event_loop(move |handle| handle.set_foo(foo));
});
handle.run().unwrap();