Struct slint::Weak

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§

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

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.

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§

Returns a copy of the value. Read more
Performs copy-assignment from source. Read more

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

Returns the argument unchanged.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The alignment of pointer.
The type for initializers.
Initializes a with the given initializer. Read more
Dereferences the given pointer. Read more
Mutably dereferences the given pointer. Read more
Drops the object pointed to by the given pointer. Read more
Should always be Self
The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.
Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more