pub struct Weak<T> where
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
sourceimpl<T> Weak<T> where
T: ComponentHandle,
impl<T> Weak<T> where
T: ComponentHandle,
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) where
T: 'static,
pub fn upgrade_in_event_loop(&self, func: impl FnOnce(T) + Send + 'static) 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! { MyApp := Window { property <int> foo; /* ... */ } }
let handle = MyApp::new();
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();
Trait Implementations
sourceimpl<T> Clone for Weak<T> where
T: ComponentHandle,
impl<T> Clone for Weak<T> where
T: ComponentHandle,
impl<T> Send for Weak<T> where
T: ComponentHandle,
Auto Trait Implementations
impl<T> RefUnwindSafe for Weak<T> where
<T as ComponentHandle>::Inner: RefUnwindSafe,
impl<T> !Sync for Weak<T>
impl<T> Unpin for Weak<T>
impl<T> UnwindSafe for Weak<T> where
<T as ComponentHandle>::Inner: RefUnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more