Implement .as_weak() and .upgrade() for global component instances #9436

bennysj · 2025-09-16T12:13:58Z

The idea to make it easier and more convenient to pass a reference to a Slint global instance into a Rust closure / lambda.

The current implementation works the following way:

  pub fn init(blogica_api: &BLogicAAPI) {
        blogica_api.on_update_data({
            let blogica_api_weak = blogica_api.as_weak();
            |bdata| {
                let blogica_api = blogica_api_weak.upgrade().unwrap();
                // It would have been very nice if the call to .global() could avoided, as it depends on the lifetime
                // of the GlobalStrong<T> it's needed
                let blogica_api = blogica_api_weak.to_global();

                // Do stuff here with blogica_api
            }
        });
    }

Fixes #9389

dfaure-kdab · 2025-09-25T12:39:10Z

internal/core/api.rs

 pub use weak_handle::*;

+/// This trait provides the necessary functionality for allowing creating strongly-referenced
+/// clones and conversion into/ a weak pointer for a Global slint component.


into/ ?

Did you mean into/from maybe, or is the / a typo?

dfaure-kdab · 2025-09-25T12:49:06Z

internal/core/api.rs

+        }
+
+        /// Returns a new GlobalStrong struct, where it's possible to get the global component
+        /// struct interface. Ff some other instance still


dfaure-kdab · 2025-09-25T12:49:39Z

internal/core/api.rs

+            if std::thread::current().id() != self.thread {
+                return None;
+            }
+            let coso = T::upgrade_from_weak_inner(&self.inner)?;


Renamed to 'inner'

dfaure-kdab · 2025-09-25T12:50:57Z

internal/core/api.rs

+        ///     // now forward the data to the main thread using upgrade_in_event_loop
+        ///     my_app_data_weak.upgrade_in_event_loop(move |my_app_data| my_app_data.set_foo(foo));
+        /// });
+        /// # thread.join().unwrap(); return; // don't run the event loop in examples


I'm confused. This is docu, not actual example, why the commented-out code?

It's a lot of copy / paste from the same function for Weak - at line 930

tronical · 2025-10-13T11:41:26Z

internal/core/api.rs

+    where
+        Self: Sized;
+
+    /// Internal function used when upgrading a weak reference to a strong one.


Suggested change

/// Internal function used when upgrading a weak reference to a strong one.

/// Internal function used when upgrading a weak reference to a strong one.

#[doc(hidden)]

tronical · 2025-10-13T11:42:47Z

internal/compiler/generator/rust.rs

        #[repr(C)]
        #[pin]
-        #pub_token struct #inner_component_id {
+        pub struct #inner_component_id {


Is this needed as part of this feature?

Need to remember,... but it's due to the PinnedInner type, unfortunately to make this work, this may need to be 'pub'

tronical · 2025-10-13T11:44:33Z

internal/core/api.rs

+        pub fn to_global<'a>(&'a self) -> T::Global<'a> {
+            T::to_self(&self.0)
+        }


Would it perhaps make more sense to implement AsRef<T> for GlobalStrong<T>, instead of this new function?

That might be a good idea, let me try implement that.

Implementing AsRef and/or Deref for GlobalStrong is not possible (unless there is some Rust wizardy that I don't know about yet) The reason is that Global has a reference '&' and a lifetime 'a to the inner.
I've just renamed this method to 'global', that may be more appropriate.
'as_ref' does not feel right, as it's not returning a reference '&'

tronical · 2025-10-13T11:47:12Z

internal/core/api.rs

+        /// If the current thread is not the thread that created the component the functor
+        /// will not be called and this function will do nothing.


It's a bit unfortunate that that's a silent error. I think my preference would be to omit this function, as it can "fail" for two unrelated reasons that the user won't be able to find out about.

If I call upgrade_in() from the wrong thread, it's a programmer error. If the upgrade fails because the global doesn't exist anymore, it's what could be a normal condition.

Thinking about it, I think both should be a programmer error.

Different thread, let's just panic

If it does not exist anymore, then it's called after the MainWindow is destroyed, I think this is also a programmer error, let also panic

tronical · 2025-10-13T11:49:17Z

tests/manual/module-builds/blogica/src/lib.rs

+            move |bdata| {
+                {
+                    let blogica_api = blogica_api.upgrade().unwrap();
+                    let blogica_api = blogica_api.to_global();


This is where I think .as_ref() is the idiomatic name. It could also implement Deref perhaps? Conceptually I think this should behave like a smart pointer.

On my previous comment, it does not return a reference '&', therefor, at least me, it does not feel correct

The idea to make it easier and more convenient to pass a reference to a Slint global instance into a Rust closure / lambda. Fixes slint-ui#9389

bennysj force-pushed the global_comp_improvments branch 4 times, most recently from ab2a50a to 595f2e2 Compare September 16, 2025 14:06

dfaure-kdab reviewed Sep 25, 2025

View reviewed changes

bennysj force-pushed the global_comp_improvments branch 3 times, most recently from d2882a0 to 91264dc Compare September 25, 2025 18:47

tronical reviewed Oct 13, 2025

View reviewed changes

bennysj force-pushed the global_comp_improvments branch from 91264dc to 46a0a06 Compare October 17, 2025 13:16

Implement .as_weak() and .upgrade() for global component instances

14718b4

The idea to make it easier and more convenient to pass a reference to a Slint global instance into a Rust closure / lambda. Fixes slint-ui#9389

bennysj force-pushed the global_comp_improvments branch from 46a0a06 to 14718b4 Compare October 17, 2025 20:37

	/// Internal function used when upgrading a weak reference to a strong one.
	/// Internal function used when upgrading a weak reference to a strong one.
	#[doc(hidden)]

		/// If the current thread is not the thread that created the component the functor
		/// will not be called and this function will do nothing.

Implement .as_weak() and .upgrade() for global component instances #9436

Are you sure you want to change the base?

Implement .as_weak() and .upgrade() for global component instances #9436

Uh oh!

Conversation

bennysj commented Sep 16, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

bennysj Oct 17, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

bennysj Oct 17, 2025 •

edited

Loading