Use Self type in examples

Author: BenFordTytherington

crates/cxx-qt-gen/test_inputs/passthrough_and_naming.rs

@@ -113,19 +113,17 @@ pub mod ffi {
         fn errorOccurred(self: Pin<&mut ExternObject>);
     }
 
-    extern "RustQt" {
+    unsafe extern "RustQt" {
         #[qobject]
         #[base = QStringListModel]
         #[qproperty(i32, property_name, cxx_name = "propertyName")]
         type MyObject = super::MyObjectRust;
-    }
 
-    unsafe extern "RustQt" {
         #[qsignal]
-        fn ready(self: Pin<&mut MyObject>);
+        fn ready(self: Pin<&mut Self>);
 
         #[qinvokable]
-        fn invokable_name(self: Pin<&mut MyObject>);
+        fn invokable_name(self: Pin<&mut Self>);
     }
 
     extern "RustQt" {

examples/qml_features/rust/src/containers.rs

@@ -46,32 +46,32 @@ pub mod qobject {
 
         /// Reset all the containers
         #[qinvokable]
-        fn reset(self: Pin<&mut RustContainers>);
+        fn reset(self: Pin<&mut Self>);
 
         /// Append the given number to the vector container
         #[qinvokable]
         #[cxx_name = "appendVector"]
-        fn append_vector(self: Pin<&mut RustContainers>, value: i32);
+        fn append_vector(self: Pin<&mut Self>, value: i32);
 
         /// Append the given number to the list container
         #[qinvokable]
         #[cxx_name = "appendList"]
-        fn append_list(self: Pin<&mut RustContainers>, value: i32);
+        fn append_list(self: Pin<&mut Self>, value: i32);
 
         /// Insert the given number into the set container
         #[qinvokable]
         #[cxx_name = "insertSet"]
-        fn insert_set(self: Pin<&mut RustContainers>, value: i32);
+        fn insert_set(self: Pin<&mut Self>, value: i32);
 
         /// Insert the given string and variant to the hash container
         #[qinvokable]
         #[cxx_name = "insertHash"]
-        fn insert_hash(self: Pin<&mut RustContainers>, key: QString, value: QVariant);
+        fn insert_hash(self: Pin<&mut Self>, key: QString, value: QVariant);
 
         /// Insert the given string and variant to the map container
         #[qinvokable]
         #[cxx_name = "insertMap"]
-        fn insert_map(self: Pin<&mut RustContainers>, key: QString, value: QVariant);
+        fn insert_map(self: Pin<&mut Self>, key: QString, value: QVariant);
     }
 }
 

examples/qml_features/rust/src/custom_parent_class.rs

@@ -43,15 +43,15 @@ pub mod qobject {
         /// Override QQuickPaintedItem::paint to draw two rectangles in Rust using QPainter
         #[qinvokable]
         #[cxx_override]
-        unsafe fn paint(self: Pin<&mut CustomParentClass>, painter: *mut QPainter);
+        unsafe fn paint(self: Pin<&mut Self>, painter: *mut QPainter);
 
         /// Define that we need to inherit size() from the base class
         #[inherit]
-        fn size(self: &CustomParentClass) -> QSizeF;
+        fn size(self: &Self) -> QSizeF;
 
         /// Define that we need to inherit update() from the base class
         #[inherit]
-        fn update(self: Pin<&mut CustomParentClass>);
+        fn update(self: Pin<&mut Self>);
     }
 
     impl cxx_qt::Constructor<()> for CustomParentClass {}

examples/qml_features/rust/src/externcxxqt.rs

@@ -37,14 +37,14 @@ pub mod ffi {
         #[qinvokable]
         #[cxx_name = "connectToExternal"]
         unsafe fn connect_to_external(
-            self: Pin<&mut ExternalCxxQtHelper>,
+            self: Pin<&mut Self>,
             external: *mut ExternalQObject,
         );
 
         #[qinvokable]
         #[cxx_name = "triggerOnExternal"]
         unsafe fn trigger_on_external(
-            self: Pin<&mut ExternalCxxQtHelper>,
+            self: Pin<&mut Self>,
             external: *mut ExternalQObject,
             amount: u32,
         );

examples/qml_features/rust/src/multiple_qobjects.rs

@@ -23,53 +23,45 @@ pub mod qobject {
         #[qproperty(i32, counter)]
         #[qproperty(QColor, color)]
         type FirstObject = super::FirstObjectRust;
-    }
 
-    // Enabling threading on the qobject
-    impl cxx_qt::Threading for FirstObject {}
-
-    extern "RustQt" {
         /// Accepted Q_SIGNAL
         #[qsignal]
-        fn accepted(self: Pin<&mut FirstObject>);
+        fn accepted(self: Pin<&mut Self>);
 
         /// Rejected Q_SIGNAL
         #[qsignal]
-        fn rejected(self: Pin<&mut FirstObject>);
-    }
+        fn rejected(self: Pin<&mut Self>);
 
-    extern "RustQt" {
         /// A Q_INVOKABLE on the first QObject which increments a counter
         #[qinvokable]
-        fn increment(self: Pin<&mut FirstObject>);
+        fn increment(self: Pin<&mut Self>);
     }
 
+    // Enabling threading on the qobject
+    impl cxx_qt::Threading for FirstObject {}
+
     extern "RustQt" {
         #[qobject]
         #[qml_element]
         #[qproperty(i32, counter)]
         #[qproperty(QUrl, url)]
         type SecondObject = super::SecondObjectRust;
-    }
 
-    // Enabling threading on the qobject
-    impl cxx_qt::Threading for SecondObject {}
-
-    extern "RustQt" {
         /// Accepted Q_SIGNAL
         #[qsignal]
-        fn accepted(self: Pin<&mut SecondObject>);
+        fn accepted(self: Pin<&mut Self>);
 
         /// Rejected Q_SIGNAL
         #[qsignal]
-        fn rejected(self: Pin<&mut SecondObject>);
-    }
+        fn rejected(self: Pin<&mut Self>);
 
-    extern "RustQt" {
         /// A Q_INVOKABLE on the second QObject which increments a counter
         #[qinvokable]
-        fn increment(self: Pin<&mut SecondObject>);
+        fn increment(self: Pin<&mut Self>);
     }
+
+    // Enabling threading on the qobject
+    impl cxx_qt::Threading for SecondObject {}
 }
 
 use core::pin::Pin;

examples/qml_features/rust/src/naming.rs

@@ -15,13 +15,12 @@ pub mod qobject {
         #[cxx_name = "RenamedObject"]
         #[namespace = "my_namespace"]
         type NamedObject = super::NamedObjectRust;
-    }
 
-    extern "RustQt" {
         #[qinvokable]
         #[cxx_name = "increment"]
         #[rust_name = "plus_one"]
         fn increment_number(self: Pin<&mut NamedObject>);
+
     }
 
     #[auto_cxx_name]

examples/qml_features/rust/src/nested_qobjects.rs

@@ -44,7 +44,7 @@ pub mod qobject {
         ///
         /// Due to a raw pointer this is considered unsafe in CXX
         #[qsignal]
-        unsafe fn called(self: Pin<&mut OuterObject>, inner: *mut InnerObject);
+        unsafe fn called(self: Pin<&mut Self>, inner: *mut InnerObject);
     }
 
     extern "RustQt" {

examples/qml_features/rust/src/properties.rs

@@ -31,15 +31,15 @@ pub mod qobject {
         /// Custom on changed signal, used for all the properties
         #[qsignal]
         #[cxx_name = "connectedStateChanged"]
-        fn connected_state_changed(self: Pin<&mut RustProperties>);
+        fn connected_state_changed(self: Pin<&mut Self>);
 
         /// Custom setter for connected_url, which also handles setting the other qproperties
         #[cxx_name = "setUrl"]
-        fn set_url(self: Pin<&mut RustProperties>, url: QUrl);
+        fn set_url(self: Pin<&mut Self>, url: QUrl);
 
         /// Resets value of connected_url to empty, as well as calling the other disconnected logic
         #[cxx_name = "resetUrl"]
-        fn reset_url(self: Pin<&mut RustProperties>);
+        fn reset_url(self: Pin<&mut Self>);
     }
 
     impl cxx_qt::Constructor<()> for RustProperties {}

examples/qml_features/rust/src/serialisation.rs

@@ -28,18 +28,18 @@ pub mod qobject {
 
         /// An error signal
         #[qsignal]
-        fn error(self: Pin<&mut Serialisation>, message: QString);
+        fn error(self: Pin<&mut Self>, message: QString);
 
         /// Retrieve the JSON form of this QObject
         #[qinvokable]
         #[cxx_name = "asJsonStr"]
-        fn as_json_str(self: Pin<&mut Serialisation>) -> QString;
+        fn as_json_str(self: Pin<&mut Self>) -> QString;
 
         /// From a given JSON string try to load values for the Q_PROPERTYs
         // ANCHOR: book_grab_values
         #[qinvokable]
         #[cxx_name = "fromJsonStr"]
-        fn from_json_str(self: Pin<&mut Serialisation>, string: &QString);
+        fn from_json_str(self: Pin<&mut Self>, string: &QString);
         // ANCHOR_END: book_grab_values
     }
 }

examples/qml_features/rust/src/singleton.rs

@@ -18,7 +18,7 @@ pub mod qobject {
 
         /// Increment the persistent value Q_PROPERTY of the QML_SINGLETON
         #[qinvokable]
-        fn increment(self: Pin<&mut RustSingleton>);
+        fn increment(self: Pin<&mut Self>);
     }
 }
 

examples/qml_features/rust/src/threading.rs

@@ -27,24 +27,22 @@ pub mod qobject {
         #[qproperty(QString, title)]
         #[qproperty(QUrl, url)]
         type ThreadingWebsite = super::ThreadingWebsiteRust;
-    }
-
-    // ANCHOR: book_threading_trait
-    // Enabling threading on the qobject
-    impl cxx_qt::Threading for ThreadingWebsite {}
-    // ANCHOR_END: book_threading_trait
 
-    extern "RustQt" {
         /// Swap the URL between kdab.com and github.com
         #[qinvokable]
         #[cxx_name = "changeUrl"]
-        fn change_url(self: Pin<&mut ThreadingWebsite>);
+        fn change_url(self: Pin<&mut Self>);
 
         /// Simulate delay of a network request to retrieve the title of the website
         #[qinvokable]
         #[cxx_name = "fetchTitle"]
-        fn fetch_title(self: Pin<&mut ThreadingWebsite>);
+        fn fetch_title(self: Pin<&mut Self>);
     }
+
+    // ANCHOR: book_threading_trait
+    // Enabling threading on the qobject
+    impl cxx_qt::Threading for ThreadingWebsite {}
+    // ANCHOR_END: book_threading_trait
 }
 
 use core::pin::Pin;

examples/qml_features/rust/src/types.rs

@@ -83,12 +83,12 @@ pub mod ffi {
         /// Load the value from a QVariant
         #[qinvokable]
         #[cxx_name = "loadFromVariant"]
-        fn load_from_variant(self: Pin<&mut Types>, variant: &QVariant);
+        fn load_from_variant(self: Pin<&mut Self>, variant: &QVariant);
 
         /// Toggle the boolean Q_PROPERTY
         #[qinvokable]
         #[cxx_name = "toggleBoolean"]
-        fn toggle_boolean(self: Pin<&mut Types>);
+        fn toggle_boolean(self: Pin<&mut Self>);
     }
 }