Struct slint_interpreter::Weak

pub struct Weak<T>where
    T: ComponentHandle,{ /* private fields */ }

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

impl<T> Weak<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

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.

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();

Trait Implementations

impl<T> Clone for Weak<T>where T: ComponentHandle,

fn clone(&self) -> Weak<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Default for Weak<T>where T: ComponentHandle,

fn default() -> Weak<T>

Returns the “default value” for a type.

impl<T> Send for Weak<T>where T: ComponentHandle,