How to write a qt_method that accepts a reference to a QObject-derived object?

[pgeorgiev98]

I have two QObject-derived classes (let's call them Foo and Bar) and I'm trying to implement a method in Bar that takes a reference to a Foo object as an argument. My idea is for that method to be called from QML. Is there any way to do this?

I noticed that if I use QVariant for the type my function gets called with the variant type set to 39 (QObject*), but I couldn't find a way to convert that to a Rust type.

I understand that I can make Bar own Foo with a RefCell<Foo> property, but I'm trying to simplify the example code.

use cstr::cstr;
use qmetaobject::prelude::*;

#[derive(QObject,Default)]
struct Foo {
    base: qt_base_class!(trait QObject),
}

#[derive(QObject,Default)]
struct Bar {
    base: qt_base_class!(trait QObject),
    do_something: qt_method!(fn do_something(&self, foo: ???) {
        dbg!(&foo);
    })
}

fn main() {
    qml_register_type::<Foo>(cstr!("Foo"), 1, 0, cstr!("Foo"));
    qml_register_type::<Bar>(cstr!("Bar"), 1, 0, cstr!("Bar"));
    let mut engine = QmlEngine::new();
    engine.load_data(r#"
        import QtQuick 2.6
        import QtQuick.Window 2.0
        import QtQuick.Controls 2.15
        import Foo 1.0
        import Bar 1.0

        Window {
            visible: true
            Foo {
                id: foo;
            }
            Bar {
                id: bar;
            }
            Button {
                anchors.centerIn: parent
                text: 'click'
                onClicked: {
                    console.log('cl');
                    bar.do_something(foo);
                }
            }
        }
    "#.into());
    engine.exec();
}