cxx-qt-gen: use cxx-qt connectiontype and qmetaobjectconnection

Author: ahayzen-kdab

book/src/bridge/extern_rustqt.md

@@ -225,17 +225,9 @@ using the signal name `<property>Changed` with no parameters.
 {{#include ../../../examples/qml_features/rust/src/signals.rs:book_signals_connect}}
 ```
 
-Each connection returns a [`QMetaObject::Connection`](https://doc.qt.io/qt-6/qmetaobject-connection.html) which is used to manage the connection.
+Each connection returns a [`QMetaObject::Connection`](https://doc.qt.io/qt-6/qmetaobject-connection.html) which can be used to manage the connection.
 
-Note that the `QMetaObjectConnection` returned by CXX-Qt behaves a bit different from the Qt C++ implementation.
-
-When the `QMetaObjectConnection` is dropped, it automatically disconnects the connection, similar to how a C++ `std::unique_ptr` or Rusts `Box` behaves.
-If you don't want to store the `QMetaObjectConnection`, call `release`, which will drop the object without disconnecting.
-In this case, it is no longer possible to disconnect later.
-
-```rust,ignore,noplayground
-{{#include ../../../examples/qml_features/rust/src/signals.rs:book_signals_disconnect}}
-```
+> Note that a `QMetaObjectConnectionGuard` can be created from the `QMetaObject::Connection` which allows for RAII style disconnects
 
 ### Emitting a signal
 

crates/cxx-qt-gen/src/generator/rust/property/mod.rs

@@ -310,8 +310,7 @@ mod tests {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "trivialPropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
-                    #[must_use]
-                    pub fn connect_trivial_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt_lib::ConnectionType) -> cxx_qt_lib::QMetaObjectConnection
+                    pub fn connect_trivial_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnection
                     {
                         ffi::MyObject_connect_trivial_property_changed(
                             self,
@@ -331,13 +330,12 @@ mod tests {
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
                     #[doc = "\n"]
                     #[doc = "Note that this method uses a AutoConnection connection type."]
-                    #[must_use]
-                    pub fn on_trivial_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt_lib::QMetaObjectConnection
+                    pub fn on_trivial_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnection
                     {
                         ffi::MyObject_connect_trivial_property_changed(
                             self,
                             cxx_qt::signalhandler::CxxQtSignalHandler::<MyObjectCxxQtSignalClosuretrivialPropertyChanged>::new(Box::new(closure)),
-                            cxx_qt_lib::ConnectionType::AutoConnection,
+                            cxx_qt::ConnectionType::AutoConnection,
                         )
                     }
                 }
@@ -438,8 +436,7 @@ mod tests {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "opaquePropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
-                    #[must_use]
-                    pub fn connect_opaque_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt_lib::ConnectionType) -> cxx_qt_lib::QMetaObjectConnection
+                    pub fn connect_opaque_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnection
                     {
                         ffi::MyObject_connect_opaque_property_changed(
                             self,
@@ -459,13 +456,12 @@ mod tests {
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
                     #[doc = "\n"]
                     #[doc = "Note that this method uses a AutoConnection connection type."]
-                    #[must_use]
-                    pub fn on_opaque_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt_lib::QMetaObjectConnection
+                    pub fn on_opaque_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnection
                     {
                         ffi::MyObject_connect_opaque_property_changed(
                             self,
                             cxx_qt::signalhandler::CxxQtSignalHandler::<MyObjectCxxQtSignalClosureopaquePropertyChanged>::new(Box::new(closure)),
-                            cxx_qt_lib::ConnectionType::AutoConnection,
+                            cxx_qt::ConnectionType::AutoConnection,
                         )
                     }
                 }
@@ -566,8 +562,7 @@ mod tests {
                     #[doc = "Connect the given function pointer to the signal "]
                     #[doc = "unsafePropertyChanged"]
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
-                    #[must_use]
-                    pub fn connect_unsafe_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt_lib::ConnectionType) -> cxx_qt_lib::QMetaObjectConnection
+                    pub fn connect_unsafe_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnection
                     {
                         ffi::MyObject_connect_unsafe_property_changed(
                             self,
@@ -587,13 +582,12 @@ mod tests {
                     #[doc = ", so that when the signal is emitted the function pointer is executed."]
                     #[doc = "\n"]
                     #[doc = "Note that this method uses a AutoConnection connection type."]
-                    #[must_use]
-                    pub fn on_unsafe_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt_lib::QMetaObjectConnection
+                    pub fn on_unsafe_property_changed<F: FnMut(core::pin::Pin<&mut MyObject>, ) + 'static>(self: core::pin::Pin<&mut MyObject>, mut closure: F) -> cxx_qt::QMetaObjectConnection
                     {
                         ffi::MyObject_connect_unsafe_property_changed(
                             self,
                             cxx_qt::signalhandler::CxxQtSignalHandler::<MyObjectCxxQtSignalClosureunsafePropertyChanged>::new(Box::new(closure)),
-                            cxx_qt_lib::ConnectionType::AutoConnection,
+                            cxx_qt::ConnectionType::AutoConnection,
                         )
                     }
                 }