setting these two to do the same

src/rust/file_helper.rs

@@ -2,10 +2,6 @@
 // of whether or not a file exists
 #[cxx_qt::bridge]
 mod file_helper {
-    use rfd::FileDialog;
-    use std::path::Path;
-    use tracing::{debug, debug_span, error, info, instrument};
-
     unsafe extern "C++" {
         include!("cxx-qt-lib/qstring.h");
         type QString = cxx_qt_lib::QString;
@@ -15,44 +11,47 @@ mod file_helper {
         type QVariant = cxx_qt_lib::QVariant;
     }
 
-    #[derive(Clone)]
+    unsafe extern "RustQt" {
-    #[cxx_qt::qobject]
+        #[qobject]
-    pub struct FileHelper {
+        #[qml_element]
-        #[qproperty]
+        #[qproperty(QString, name)]
-        name: QString,
+        #[qproperty(QString, file_path)]
-        #[qproperty]
+        type FileHelper = super::FileHelperRust;
-        file_path: QString,
-    }
 
-    impl Default for FileHelper {
+        #[qinvokable]
+        fn validate(self: Pin<&mut FileHelper>, file: QUrl) -> bool;
+        #[qinvokable]
+        pub fn save_file(self: Pin<&mut FileHelper>) -> QUrl;
+        #[qinvokable]
+        fn load_file(
+            self: Pin<&mut FileHelper>,
+            title: QString,
+            filter: QString,
+        ) -> QUrl;
+
+    }
+}
+
+use rfd::FileDialog;
+use std::path::Path;
+use tracing::{debug, debug_span, error, info, instrument};
+
+#[derive(Clone)]
+pub struct FileHelperRust {
+    name: QString,
+    file_path: QString,
+}
+
+impl Default for FileHelperRust {
     fn default() -> Self {
         Self {
             name: QString::from(""),
             file_path: QString::from(""),
         }
     }
-    }
+}
 
-    impl qobject::FileHelper {
+impl ffi::FileHelperRust {
-        // #[qinvokable]
-        // pub fn save(self: Pin<&mut Self>, file: QUrl, service_list: QVariant) -> bool {
-        //     println!("{}", file);
-        //     match service_list.value() {
-        //         QVariantValue::<QString>(..) => println!("string"),
-        //         QVariantValue::<QUrl>(..) => println!("url"),
-        //         QVariantValue::<QDate>(..) => println!("date"),
-        //         _ => println!("QVariant is..."),
-        //     }
-        //     return true;
-        // }
-
-        #[qinvokable]
-        pub fn load(self: Pin<&mut Self>, file: QUrl) -> Vec<String> {
-            println!("{file}");
-            vec!["hi".to_string()]
-        }
-
-        #[qinvokable]
     pub fn validate(self: Pin<&mut Self>, file: QUrl) -> bool {
         let file_string = file.to_string();
         let file_string = file_string.strip_prefix("file://");
@@ -63,15 +62,13 @@ mod file_helper {
                 exists
             }
             None => {
-                    let exists =
+                let exists = Path::new(&file.to_string()).exists();
-                        Path::new(&file.to_string()).exists();
                 println!("{file} exists? {exists}");
                 exists
             }
         }
     }
 
-        #[qinvokable]
     pub fn save_file(self: Pin<&mut Self>) -> QUrl {
         let file = FileDialog::new()
             .set_file_name("NVTFC.pres")
@@ -92,19 +89,16 @@ mod file_helper {
         }
     }
 
-        #[qinvokable]
     pub fn load_file(
         self: Pin<&mut Self>,
         title: QString,
         filter: QString,
     ) -> QUrl {
         let video_filters = [
-                "mp4", "webm", "avi", "mkv", "MP4", "WEBM", "AVI",
+            "mp4", "webm", "avi", "mkv", "MP4", "WEBM", "AVI", "MKV",
-                "MKV",
         ];
         let image_filters = [
-                "jpg", "png", "gif", "jpeg", "JPG", "PNG", "webp",
+            "jpg", "png", "gif", "jpeg", "JPG", "PNG", "webp", "gif",
-                "gif",
         ];
         let audio_filters = ["mp3", "opus", "ogg", "flac", "wav"];
         let title = title.to_string();
@@ -137,5 +131,4 @@ mod file_helper {
             QUrl::default()
         }
     }
-    }
 }

src/rust/slide_obj.rs

@@ -1,9 +1,5 @@
 #[cxx_qt::bridge]
 mod slide_obj {
-    // use cxx_qt_lib::QVariantValue;
-    // use std::path::Path;
-    // use std::task::Context;
-
     unsafe extern "C++" {
         include!("cxx-qt-lib/qstring.h");
         type QString = cxx_qt_lib::QString;
@@ -14,55 +10,96 @@ mod slide_obj {
         type QVariant = cxx_qt_lib::QVariant;
     }
 
-    #[cxx_qt::qsignals(SlideObj)]
+    unsafe extern "RustQt" {
-    pub enum Signals<'a> {
+        #[qobject]
-        PlayingChanged { is_playing: &'a bool },
+        #[qml_element]
-        SlideIndexChanged { slide_index: &'a i32 },
+        #[qproperty(i32, slide_index)]
-        SlideSizeChanged { slide_size: &'a i32 },
+        #[qproperty(i32, slide_size)]
-        SlideChanged { slide: &'a i32 },
+        #[qproperty(i32, image_count)]
-        LoopChanged { looping: &'a bool },
+        #[qproperty(bool, is_playing)]
-    }
+        #[qproperty(bool, looping)]
+        #[qproperty(QString, text)]
+        #[qproperty(QString, ty)]
+        #[qproperty(QString, audio)]
+        #[qproperty(QString, image_background)]
+        #[qproperty(QString, video_background)]
+        #[qproperty(QString, html)]
+        #[qproperty(QString, vtext_alignment)]
+        #[qproperty(QString, htext_alignment)]
+        #[qproperty(QString, font)]
+        #[qproperty(i32, font_size)]
+        #[qproperty(f32, video_start_time)]
+        #[qproperty(f32, video_end_time)]
+        type SlideObj = super::SlideObjectRust;
 
-    #[derive(Clone, Debug)]
+        #[qsignal]
-    #[cxx_qt::qobject]
+        fn playing_changed(
-    pub struct SlideObj {
+            self: Pin<&mut SlideObj>,
-        #[qproperty]
-        slide_index: i32,
-        #[qproperty]
-        slide_size: i32,
-        #[qproperty]
-        image_count: i32,
-        #[qproperty]
             is_playing: bool,
-        #[qproperty]
+        );
-        looping: bool,
+        #[qsignal]
-        #[qproperty]
+        fn slide_index_changed(
-        text: QString,
+            self: Pin<&mut SlideObj>,
-        #[qproperty]
+            slide_index: i32,
-        ty: QString,
+        );
-        #[qproperty]
+        #[qsignal]
-        audio: QString,
+        fn slide_size_changed(
-        #[qproperty]
+            self: Pin<&mut SlideObj>,
-        image_background: QString,
+            slide_size: i32,
-        #[qproperty]
+        );
-        video_background: QString,
+        #[qsignal]
-        #[qproperty]
+        fn slide_changed(self: Pin<&mut SlideObj>, slide: i32);
-        html: QString,
+        #[qsignal]
-        #[qproperty]
+        fn loop_changed(self: Pin<&mut SlideObj>, looping: bool);
-        vtext_alignment: QString,
-        #[qproperty]
-        htext_alignment: QString,
-        #[qproperty]
-        font: QString,
-        #[qproperty]
-        font_size: i32,
-        #[qproperty]
-        video_start_time: f32,
-        #[qproperty]
-        video_end_time: f32,
-    }
 
-    impl Default for SlideObj {
+        #[qinvokable]
+        fn change_slide(
+            self: Pin<&mut SlideObj>,
+            item: QMap_QString_QVariant,
+            index: i32,
+        );
+        #[qinvokable]
+        fn next(
+            self: Pin<&mut SlideObj>,
+            next_item: QMap_QString_QVariant,
+        ) -> bool;
+        #[qinvokable]
+        fn previous(
+            self: Pin<&mut SlideObj>,
+            prev_item: QMap_QString_QVariant,
+        ) -> bool;
+        #[qinvokable]
+        fn play(self: Pin<&mut SlideObj>) -> bool;
+        #[qinvokable]
+        fn pause(self: Pin<&mut SlideObj>) -> bool;
+        #[qinvokable]
+        fn play_pause(self: Pin<&mut SlideObj>) -> bool;
+
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct SlideObjectRust {
+    slide_index: i32,
+    slide_size: i32,
+    image_count: i32,
+    is_playing: bool,
+    looping: bool,
+    text: QString,
+    ty: QString,
+    audio: QString,
+    image_background: QString,
+    video_background: QString,
+    html: QString,
+    vtext_alignment: QString,
+    htext_alignment: QString,
+    font: QString,
+    font_size: i32,
+    video_start_time: f32,
+    video_end_time: f32,
+}
+
+impl Default for SlideObjectRust {
     fn default() -> Self {
         Self {
             slide_index: 0,
@@ -84,10 +121,9 @@ mod slide_obj {
             video_end_time: 0.0,
         }
     }
-    }
+}
 
-    impl qobject::SlideObj {
+impl ffi::SlideObjectRust {
-        #[qinvokable]
     pub fn change_slide(
         mut self: Pin<&mut Self>,
         item: QMap_QString_QVariant,
@@ -134,12 +170,9 @@ mod slide_obj {
         if let Some(image_background) =
             image_background.value::<QString>()
         {
-                if &image_background
+            if &image_background != self.as_ref().image_background() {
-                    != self.as_ref().image_background()
-                {
                 println!("image-bg: {image_background}");
-                    self.as_mut()
+                self.as_mut().set_image_background(image_background);
-                        .set_image_background(image_background);
             }
         } else {
             println!("image-bg: empty");
@@ -150,19 +183,16 @@ mod slide_obj {
         if let Some(video_background) =
             video_background.value::<QString>()
         {
-                if &video_background
+            if &video_background != self.as_ref().video_background() {
-                    != self.as_ref().video_background()
-                {
                 println!("video-bg: {video_background}");
-                    self.as_mut()
+                self.as_mut().set_video_background(video_background);
-                        .set_video_background(video_background);
             }
         } else {
             println!("video-bg: empty");
         }
-            let font = item.get(&QString::from("font")).unwrap_or(
+        let font = item
-                QVariant::from(&QString::from("Quicksand")),
+            .get(&QString::from("font"))
-            );
+            .unwrap_or(QVariant::from(&QString::from("Quicksand")));
         if let Some(font) = font.value::<QString>() {
             if &font != self.as_ref().font() {
                 println!("font: {font}");
@@ -177,13 +207,9 @@ mod slide_obj {
         if let Some(vtext_alignment) =
             vtext_alignment.value::<QString>()
         {
-                if &vtext_alignment != self.as_ref().vtext_alignment()
+            if &vtext_alignment != self.as_ref().vtext_alignment() {
-                {
+                println!("vertical-text-align: {vtext_alignment}");
-                    println!(
+                self.as_mut().set_vtext_alignment(vtext_alignment);
-                        "vertical-text-align: {vtext_alignment}"
-                    );
-                    self.as_mut()
-                        .set_vtext_alignment(vtext_alignment);
             }
         } else {
             println!("vertical-text-align: empty");
@@ -194,13 +220,9 @@ mod slide_obj {
         if let Some(htext_alignment) =
             htext_alignment.value::<QString>()
         {
-                if &htext_alignment != self.as_ref().htext_alignment()
+            if &htext_alignment != self.as_ref().htext_alignment() {
-                {
+                println!("horizontal-text-align: {htext_alignment}");
-                    println!(
+                self.as_mut().set_htext_alignment(htext_alignment);
-                        "horizontal-text-align: {htext_alignment}"
-                    );
-                    self.as_mut()
-                        .set_htext_alignment(htext_alignment);
             }
         } else {
             println!("horizontal-text-align: empty");
@@ -224,8 +246,7 @@ mod slide_obj {
                 println!("looping: {looping}");
                 self.as_mut().set_looping(looping);
                 let lp = looping;
-                    self.as_mut()
+                self.as_mut().loop_changed(&lp);
-                        .emit(Signals::LoopChanged { looping: &lp });
             }
         } else {
             println!("looping: empty")
@@ -258,12 +279,10 @@ mod slide_obj {
             println!("New slide index = {}", int);
             self.as_mut().set_slide_index(int);
         };
-            self.as_mut()
+        self.as_mut().slide_changed(&index);
-                .emit(Signals::SlideChanged { slide: &index });
         println!("## Slide End ##");
     }
 
-        #[qinvokable]
     pub fn next(
         mut self: Pin<&mut Self>,
         next_item: QMap_QString_QVariant,
@@ -272,7 +291,6 @@ mod slide_obj {
         self.as_mut().change_slide(next_item, new_id);
         true
     }
-        #[qinvokable]
     pub fn previous(
         mut self: Pin<&mut Self>,
         prev_item: QMap_QString_QVariant,
@@ -281,27 +299,23 @@ mod slide_obj {
         self.as_mut().change_slide(prev_item, new_id);
         true
     }
-        #[qinvokable]
     pub fn play(mut self: Pin<&mut Self>) -> bool {
         self.as_mut().set_is_playing(true);
-            self.as_mut().emit_playing_changed(&true);
+        self.as_mut().playing_changed(&true);
         true
     }
-        #[qinvokable]
     pub fn pause(mut self: Pin<&mut Self>) -> bool {
         self.as_mut().set_is_playing(false);
-            self.as_mut().emit_playing_changed(&false);
+        self.as_mut().playing_changed(&false);
         false
     }
-        #[qinvokable]
     pub fn play_pause(mut self: Pin<&mut Self>) -> bool {
         let playing = self.as_ref().is_playing().clone();
         match playing {
             true => self.as_mut().set_is_playing(false),
             false => self.as_mut().set_is_playing(true),
         }
-            self.as_mut().emit_playing_changed(&!playing);
+        self.as_mut().playing_changed(&!playing);
         !playing
     }
-    }
 }