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

[bennysj]

Feature Description

Having the following global component:

export global BLogicAAPI {
    // A lot properties and etc ...

    callback update-data(bdata: BData);
}

From the application main.rs it's accesed via:

fn main() -> Result<(), Box<dyn Error>> {
    let ui = AppWindow::new()?;

    let blociga_api = ui.global::<blogica::backend::BLogicAAPI>();
    blogica::backend::init(&blociga_api);
}

Due to that the business logic of BLogicAAPI is implemented in it's own crate / module it does not know the AppWindow, and can't do ui.global::<blogica::backend::BLogicAAPI>(), so in lib.rs we would like to do something like:

    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();
                // Do stuff here with blogica_api
            }
        });
    }

Internally the global components are already Rc instances, so proving .as_weak() and .upgrade() functionality should be techincally possible, (just like with the AppWindow)

Relates to issue #7060

Product Impact

No response

[ogoffart]

The problem is that the global don't necessarily live by themselves in Rc.
But we should indeed find a solution.
Currently, you can try something like that:

fn init<T>(main_window: &T)
where
    T: slint::ComponentHandle + 'static,
    for<'a> BLogicAAPI<'a>: slint::Global<'a, T>,
{
    main_window.global::<BLogicAAPI>().on_update_data({
        let weak = main_window.as_weak();
        |bdata| {
            let main_window = weak.upgrade().unwrap();
            let blogica_api = main_window.global::<BLogicAAPI>();
            // Do stuff here with blogica_api
        }
    });
}

Yes, this is a ugly workaround a we should figure out ways to improve on that.

[bennysj]

In the generated Rust code:

    #[allow(unused)]
    pub struct r#BLogicAAPI<'a>(&'a ::core::pin::Pin<sp::Rc<InnerBLogicAAPI>>);

Does it really need to be reference & to InnerBLogicAAPI ?
If it's just an Rc, it would make things a bit easier:

    #[allow(unused)]
    pub struct r#BLogicAAPI(sp::Rc<InnerBLogicAAPI>);

Otherwise there will an issue with lifetime of &'a ::core::pin::Pin<sp::Rc<InnerBLogicAAPI>>

[ogoffart]

I think it indeed may not need to be a reference and we can change that.
IIRC this used to not be even wrapped in a Rc.

[tronical]

We might want to tie the life-time of the global still to the life-time of the component instance. Example:

let app = AppWindow::new().unwrap();
let some_global = app.global::<Foo>();
let weak = some_global.as_weak();
drop(some_global);
drop(app);
assert!(weak.upgrade().is_some());

That could be done by adding a second field in the tuple though.