cxx-qt-lib: Add binding for QQmlApplicationEngine::singletonInstance

[redstrate]

This allows accessing QObject singleton instances registered in the QML engine (using #[qml_singleton]) from the Rust side.

[redstrate]

I kind of hate everything about this, but this somehow works. Suggestions appreciated, since I don't know of any other method supported in cxx-qt that has a template parameter.

[ahayzen-kdab]

Hmm, once we have up/down casting and QObject already as a type #562 then this would be much easier. We would like this have this implemented in this cycle as it seems useful in multiple places.

It would be return a pointer to a QObject, then use the downcast_ptr method to get your original type back.

[LeonMatthesKDAB]

Hm, right, this could be a decent way to solve this issue 🤔

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 100.00%. Comparing base (f5afefe) to head (892f14f).

Additional details and impacted files

@@            Coverage Diff            @@
##              main     #1140   +/-   ##
=========================================
  Coverage   100.00%   100.00%           
=========================================
  Files           71        71           
  Lines        11967     11967           
=========================================
  Hits         11967     11967           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[redstrate]

This #[cfg] doesn't work I guess, so Qt5 and <6.5 builds will fail. A possible solution could be to separate this into a different cxx::bridge as suggested in this issue but that seems extreme?

[ahayzen-kdab]

Fully support for cfg flags everywhere comes in #1133 and #1132 which i plan to look at next.

For now you could try instead of putting the cfg flag on the extern block itself put it on the method as this is passed through to CXX.

[redstrate]

That does work, but the QAnyStringView inclusion is hitting the same problems as seen in #1141 :(

[LeonMatthesKDAB]

Hm, this is definitely not safe to do here!

As you could basically "spoof" T to be different from the actual type that the singleton has.

In the most extreme case, I could just do:

engine.singleton_instance::<i32>(...);

We could mark the function itself as unsafe to move that responsibility up one level, but it's still not great...

[redstrate]

I have added some lifetime checks to improve it a bit, but yes this is inherently unsafe due to a lack of type-checking. Note that once we have the ability to do type checking (like in #562, or akiselev's comment), this should stay unsafe.

[redstrate]

I'll leave it up to your discretion whether we should include this inherently-unsafe version now, and then have a proper solution in tandem with #562 or engineer it all here and right now. IMO, it would be really useful even in it's current state :-)

[akiselev]

For what it's worth, I implemented this using a template helper:

template <typename T>
T *qqmlengineSingletonInstance(QQmlEngine &engine, const QString &module, const QString &name)
{
    auto ptr =
        engine.template singletonInstance<T *>(
            QAnyStringView(module), QAnyStringView(name));
    return ptr;
}

Then in the C++ bridge:

    #[rust_name = "get_theme_singleton"]
    unsafe fn qqmlengineSingletonInstance(
        engine: Pin<&mut QQmlEngine>,
        module: &QString,
        name: &QString,
    ) -> *mut ThemeSingleton;

and finally the safe Rust wrapper:

    fn get_theme_singleton(self: Pin<&mut Self>) -> Option<Pin<&mut ThemeSingleton>> {
        unsafe {
            // This is safe because we're checking if it's null and only handing out a pinned mut ref
            // Qt does its own type safety checks here too
            let ptr = get_theme_singleton(
                self.as_qqmlengine()
                &QString::from("App.Core"),
                &QString::from("Theme"),
            );
            ptr.as_mut().map(|p| Pin::new_unchecked(p))
        }
    }

Then wrap it in a pair of traits:

pub trait GetSingleton<T> {
    fn try_singleton(self: Pin<&mut Self>) -> Option<Pin<&mut T>>;

    fn get_singleton(self: Pin<&mut Self>) -> Pin<&mut T> {
        self.try_singleton().expect("Singleton is not initialized")
    }
}

pub trait SingletonType {
    unsafe fn get_instance(engine: Pin<&mut QQmlEngine>) -> *mut Self;
}

impl<T: SingletonType> GetSingleton<T> for QQmlEngine {
    fn try_singleton(self: Pin<&mut Self>) -> Option<Pin<&mut T>> {
        unsafe {
            // This is safe because we're checking if it's null and only handing out a pinned mut ref
            // Qt does its own type safety checks here too
            let ptr = T::get_instance(self);
            ptr.as_mut().map(|p| Pin::new_unchecked(p))
        }
    }
}

impl SingletonType for ThemeSingleton {
    unsafe fn get_instance(engine: Pin<&mut QQmlEngine>) -> *mut Self {
        ffi::get_theme_instance(
            engine,
            &QString::from("App.Core"),
            &QString::from("Theme"),
        )
    }
}