slides, settings, and file stuff ported

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;
@@ -14,128 +10,134 @@ mod file_helper {
         include!("cxx-qt-lib/qvariant.h");
         type QVariant = cxx_qt_lib::QVariant;
     }
-
+    unsafe extern "RustQt" {
-    #[derive(Clone)]
+        #[qobject]
-    #[cxx_qt::qobject]
+        #[qml_element]
-    pub struct FileHelper {
+        #[qproperty(QString, name)]
-        #[qproperty]
+        #[qproperty(QString, file_path)]
-        name: QString,
+        type FileHelper = super::FileHelperRust;
-        #[qproperty]
-        file_path: QString,
-    }
-
-    impl Default for FileHelper {
-        fn default() -> Self {
-            Self {
-                name: QString::from(""),
-                file_path: QString::from(""),
-            }
-        }
-    }
-
-    impl qobject::FileHelper {
-        // #[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> {
+        fn load(
-            println!("{file}");
+            self: Pin<&mut FileHelper>,
-            vec!["hi".to_string()]
+            file: QUrl,
-        }
+        ) -> Vec<String>;
 
         #[qinvokable]
-        pub fn validate(self: Pin<&mut Self>, file: QUrl) -> bool {
+        fn validate(self: Pin<&mut FileHelper>, file: QUrl) -> bool;
-            let file_string = file.to_string();
-            let file_string = file_string.strip_prefix("file://");
-            match file_string {
-                Some(file) => {
-                    let exists = Path::new(&file).exists();
-                    println!("{file} exists? {exists}");
-                    exists
-                }
-                None => {
-                    let exists =
-                        Path::new(&file.to_string()).exists();
-                    println!("{file} exists? {exists}");
-                    exists
-                }
-            }
-        }
-
         #[qinvokable]
-        pub fn save_file(self: Pin<&mut Self>) -> QUrl {
+        fn save_file(self: Pin<&mut FileHelper>) -> QUrl;
-            let file = FileDialog::new()
-                .set_file_name("NVTFC.pres")
-                .set_title("Save Presentation")
-                .save_file();
-            if let Some(file) = file {
-                println!("saving-file: {:?}", file);
-                let mut string =
-                    String::from(file.to_str().unwrap_or(""));
-                if string.is_empty() {
-                    QUrl::default()
-                } else {
-                    string.insert_str(0, "file://");
-                    QUrl::from(string.as_str())
-                }
-            } else {
-                QUrl::default()
-            }
-        }
-
         #[qinvokable]
-        pub fn load_file(
+        fn load_file(
-            self: Pin<&mut Self>,
+            self: Pin<&mut FileHelper>,
             title: QString,
             filter: QString,
-        ) -> QUrl {
+        ) -> QUrl;
-            let video_filters = [
+    }
-                "mp4", "webm", "avi", "mkv", "MP4", "WEBM", "AVI",
+}
-                "MKV",
+
-            ];
+use rfd::FileDialog;
-            let image_filters = [
+use std::path::Path;
-                "jpg", "png", "gif", "jpeg", "JPG", "PNG", "webp",
+use tracing::{debug, debug_span, error, info, instrument};
-                "gif",
+
-            ];
+#[derive(Clone)]
-            let audio_filters = ["mp3", "opus", "ogg", "flac", "wav"];
+pub struct FileHelperRust {
-            let title = title.to_string();
+    name: QString,
-            let filter = filter.to_string();
+    file_path: QString,
-            let mut file = FileDialog::new().set_title(title);
+}
-            match filter.as_str() {
+
-                "video" => {
+impl Default for FileHelperRust {
-                    file = file.add_filter(filter, &video_filters);
+    fn default() -> Self {
-                }
+        Self {
-                "image" => {
+            name: QString::from(""),
-                    file = file.add_filter(filter, &image_filters);
+            file_path: QString::from(""),
-                }
+        }
-                "audio" => {
+    }
-                    file = file.add_filter(filter, &audio_filters);
+}
-                }
+
-                _ => debug!("nothing"),
+impl qobject::FileHelper {
-            };
+    pub fn load(self: Pin<&mut Self>, file: QUrl) -> Vec<String> {
-            let file = file.pick_file();
+        println!("{file}");
-            if let Some(file) = file {
+        vec!["hi".to_string()]
-                println!("loading-file: {:?}", file);
+    }
-                let mut string =
+
-                    String::from(file.to_str().unwrap_or(""));
+    pub fn validate(self: Pin<&mut Self>, file: QUrl) -> bool {
-                if string.is_empty() {
+        let file_string = file.to_string();
-                    QUrl::default()
+        let file_string = file_string.strip_prefix("file://");
-                } else {
+        match file_string {
-                    string.insert_str(0, "file://");
+            Some(file) => {
-                    QUrl::from(string.as_str())
+                let exists = Path::new(&file).exists();
-                }
+                println!("{file} exists? {exists}");
-            } else {
+                exists
-                QUrl::default()
+            }
-            }
+            None => {
+                let exists = Path::new(&file.to_string()).exists();
+                println!("{file} exists? {exists}");
+                exists
+            }
+        }
+    }
+
+    pub fn save_file(self: Pin<&mut Self>) -> QUrl {
+        let file = FileDialog::new()
+            .set_file_name("NVTFC.pres")
+            .set_title("Save Presentation")
+            .save_file();
+        if let Some(file) = file {
+            println!("saving-file: {:?}", file);
+            let mut string =
+                String::from(file.to_str().unwrap_or(""));
+            if string.is_empty() {
+                QUrl::default()
+            } else {
+                string.insert_str(0, "file://");
+                QUrl::from(string.as_str())
+            }
+        } else {
+            QUrl::default()
+        }
+    }
+
+    pub fn load_file(
+        self: Pin<&mut Self>,
+        title: QString,
+        filter: QString,
+    ) -> QUrl {
+        let video_filters = [
+            "mp4", "webm", "avi", "mkv", "MP4", "WEBM", "AVI", "MKV",
+        ];
+        let image_filters = [
+            "jpg", "png", "gif", "jpeg", "JPG", "PNG", "webp", "gif",
+        ];
+        let audio_filters = ["mp3", "opus", "ogg", "flac", "wav"];
+        let title = title.to_string();
+        let filter = filter.to_string();
+        let mut file = FileDialog::new().set_title(title);
+        match filter.as_str() {
+            "video" => {
+                file = file.add_filter(filter, &video_filters);
+            }
+            "image" => {
+                file = file.add_filter(filter, &image_filters);
+            }
+            "audio" => {
+                file = file.add_filter(filter, &audio_filters);
+            }
+            _ => debug!("nothing"),
+        };
+        let file = file.pick_file();
+        if let Some(file) = file {
+            println!("loading-file: {:?}", file);
+            let mut string =
+                String::from(file.to_str().unwrap_or(""));
+            if string.is_empty() {
+                QUrl::default()
+            } else {
+                string.insert_str(0, "file://");
+                QUrl::from(string.as_str())
+            }
+        } else {
+            QUrl::default()
         }
     }
 }

src/rust/service_thing.rs

@@ -64,7 +64,6 @@ impl Default for ServiceThingRust {
 }
 
 impl qobject::ServiceThing {
-    #[qinvokable]
     pub fn activate(self: Pin<&mut Self>) {
         println!("{}", self.active());
         let active: bool = *self.active();
@@ -72,7 +71,6 @@ impl qobject::ServiceThing {
         println!("{}", !active);
     }
 
-    #[qinvokable]
     pub fn check_active(self: Pin<&mut Self>) {
         println!("Are we active?: {}", self.active());
     }

src/rust/settings.rs

@@ -15,6 +15,12 @@ mod settings {
         #[qproperty(QUrl, last_save_file)]
         #[qproperty(QUrl, loaded_file)]
         type Settings = super::SettingsRust;
+
+        #[qinvokable]
+        fn setup(self: Pin<&mut Settings>);
+
+        #[qinvokable]
+        fn set_save_file(self: Pin<&mut Settings>, file: QUrl);
     }
 }
 
@@ -28,13 +34,9 @@ use std::path::PathBuf;
 pub struct SettingsRust {
     config: Ini,
 
-    #[qproperty]
     screen: QString,
-    #[qproperty]
     sound_effect: QString,
-    #[qproperty]
     last_save_file: QUrl,
-    #[qproperty]
     loaded_file: QUrl,
 }
 
@@ -51,15 +53,6 @@ impl Default for SettingsRust {
 }
 
 impl qobject::Settings {
-    #[qinvokable]
-    pub fn print_sound(self: Pin<&mut Self>) {
-        let mut config = Ini::new();
-        let _map = config.load("~/.config/lumina/lumina.conf");
-
-        println!("{}", self.sound_effect());
-    }
-
-    #[qinvokable]
     pub fn setup(mut self: Pin<&mut Self>) {
         let home = dirs::config_dir();
         println!("{:?}", home);
@@ -92,7 +85,6 @@ impl qobject::Settings {
         }
     }
 
-    #[qinvokable]
     pub fn set_save_file(mut self: Pin<&mut Self>, file: QUrl) {
         println!("{file}");
         match self.as_mut().config_mut().set(

src/rust/slide_object.rs

@@ -1,11 +1,5 @@
 #[cxx_qt::bridge]
 mod slide_object {
-    // use cxx_qt_lib::QVariantValue;
-    // use std::path::Path;
-    // use std::task::Context;
-
-    use tracing::debug;
-
     unsafe extern "C++" {
         include!("cxx-qt-lib/qstring.h");
         type QString = cxx_qt_lib::QString;
@@ -16,322 +10,341 @@ mod slide_object {
         type QVariant = cxx_qt_lib::QVariant;
     }
 
-    #[derive(Debug)]
+    unsafe extern "RustQt" {
-    #[cxx_qt::qsignals(SlideObject)]
+        #[qsignal]
-    pub enum Signals<'a> {
+        fn playing_changed(
-        PlayingChanged { is_playing: &'a bool },
+            self: Pin<&mut SlideObject>,
-        SlideIndexChanged { slide_index: &'a i32 },
+            is_playing: bool,
-        SlideSizeChanged { slide_size: &'a i32 },
+        );
-        SlideChanged { slide: &'a i32 },
+        // #[qsignal]
-        LoopChanged { looping: &'a bool },
+        // fn slide_index_changed(
-        RevealNext,
+        //     self: Pin<&mut SlideObject>,
-        RevealPrev,
+        //     slide_index: i32,
-    }
+        // );
+        // #[qsignal]
+        // fn slide_size_changed(
+        //     self: Pin<&mut SlideObject>,
+        //     slide_size: i32,
+        // );
+        #[qsignal]
+        fn slide_changed(self: Pin<&mut SlideObject>, slide: i32);
+        #[qsignal]
+        fn loop_changed(self: Pin<&mut SlideObject>, looping: bool);
+        #[qsignal]
+        fn reveal_next(self: Pin<&mut SlideObject>);
+        #[qsignal]
+        fn reveal_prev(self: Pin<&mut SlideObject>);
 
-    #[derive(Clone, Debug)]
+        #[qobject]
-    #[cxx_qt::qobject]
+        #[qml_element]
-    pub struct SlideObject {
+        #[qproperty(i32, slide_index)]
-        #[qproperty]
+        #[qproperty(i32, slide_size)]
-        slide_index: i32,
+        #[qproperty(i32, image_count)]
-        #[qproperty]
+        #[qproperty(bool, is_playing)]
-        slide_size: i32,
+        #[qproperty(bool, looping)]
-        #[qproperty]
+        #[qproperty(QString, text)]
-        image_count: i32,
+        #[qproperty(QString, ty)]
-        #[qproperty]
+        #[qproperty(QString, audio)]
-        is_playing: bool,
+        #[qproperty(QString, image_background)]
-        #[qproperty]
+        #[qproperty(QString, video_background)]
-        looping: bool,
+        #[qproperty(QString, html)]
-        #[qproperty]
+        #[qproperty(QString, vtext_alignment)]
-        text: QString,
+        #[qproperty(QString, htext_alignment)]
-        #[qproperty]
+        #[qproperty(QString, font)]
-        ty: QString,
+        #[qproperty(bool, font_size)]
-        #[qproperty]
+        #[qproperty(f32, video_start_time)]
-        audio: QString,
+        #[qproperty(f32, video_end_time)]
-        #[qproperty]
+        type SlideObject = super::SlideObjectRust;
-        image_background: QString,
-        #[qproperty]
-        video_background: QString,
-        #[qproperty]
-        html: QString,
-        #[qproperty]
-        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 SlideObject {
-        fn default() -> Self {
-            Self {
-                slide_index: 0,
-                slide_size: 0,
-                is_playing: false,
-                looping: false,
-                text: QString::from(""),
-                ty: QString::from(""),
-                audio: QString::from(""),
-                image_background: QString::from(""),
-                html: QString::from(""),
-                video_background: QString::from(""),
-                vtext_alignment: QString::from(""),
-                htext_alignment: QString::from(""),
-                font: QString::from(""),
-                font_size: 50,
-                image_count: 0,
-                video_start_time: 0.0,
-                video_end_time: 0.0,
-            }
-        }
-    }
-
-    impl qobject::SlideObject {
         #[qinvokable]
-        pub fn change_slide(
+        fn change_slide(
-            mut self: Pin<&mut Self>,
+            self: Pin<&mut SlideObject>,
             item: QMap_QString_QVariant,
             index: i32,
-        ) {
+        );
-            let current_index = self.as_ref().get_ref().slide_index();
-            let icount_variant = item
-                .get(&QString::from("imageCount"))
-                .unwrap_or(QVariant::from(&1));
-            let count =
-                icount_variant.value::<i32>().unwrap_or_default();
-
-            let slindex = item
-                .get(&QString::from("slideIndex"))
-                .unwrap_or(QVariant::from(&0));
-            let slide_index =
-                slindex.value::<i32>().unwrap_or_default();
-
-            let html = item
-                .get(&QString::from("html"))
-                .unwrap_or(QVariant::from(&false));
-            if let Some(html) = html.value::<bool>() {
-                if html {
-                    debug!(?html, count, slide_index);
-                    if slide_index > 0 && slide_index < count - 1 {
-                        if current_index < &index {
-                            self.as_mut().emit(Signals::RevealNext);
-                            debug!(signal = ?Signals::RevealNext);
-                            return;
-                        } else if slide_index > 0 {
-                            self.as_mut().emit(Signals::RevealPrev);
-                            debug!(signal = ?Signals::RevealPrev);
-                            return;
-                        }
-                    }
-                }
-            }
-
-            println!("## Slide Details ##");
-            let text = item
-                .get(&QString::from("text"))
-                .unwrap_or(QVariant::from(&QString::from("")));
-            if let Some(txt) = text.value::<QString>() {
-                if &txt != self.as_ref().text() {
-                    println!("text: {txt}");
-                    self.as_mut().set_text(txt);
-                };
-            } else {
-                println!("text: empty");
-            }
-            let audio = item
-                .get(&QString::from("audio"))
-                .unwrap_or(QVariant::from(&QString::from("")));
-            if let Some(audio) = audio.value::<QString>() {
-                if &audio != self.as_ref().audio() {
-                    println!("audio: {audio}");
-                    self.as_mut().set_audio(audio);
-                }
-            } else {
-                println!("audio: empty");
-            }
-            let ty = item
-                .get(&QString::from("type"))
-                .unwrap_or(QVariant::from(&QString::from("")));
-            if let Some(ty) = ty.value::<QString>() {
-                if &ty != self.as_ref().ty() {
-                    println!("type: {ty}");
-                    self.as_mut().set_ty(ty);
-                }
-            } else {
-                println!("type: empty");
-            }
-
-            let image_background = item
-                .get(&QString::from("imageBackground"))
-                .unwrap_or(QVariant::from(&QString::from("")));
-            if let Some(image_background) =
-                image_background.value::<QString>()
-            {
-                if &image_background
-                    != self.as_ref().image_background()
-                {
-                    println!("image-bg: {image_background}");
-                    self.as_mut()
-                        .set_image_background(image_background);
-                }
-            } else {
-                println!("image-bg: empty");
-            }
-            let video_background = item
-                .get(&QString::from("videoBackground"))
-                .unwrap_or(QVariant::from(&QString::from("")));
-            if let Some(video_background) =
-                video_background.value::<QString>()
-            {
-                if &video_background
-                    != self.as_ref().video_background()
-                {
-                    println!("video-bg: {video_background}");
-                    self.as_mut()
-                        .set_video_background(video_background);
-                }
-            } else {
-                println!("video-bg: empty");
-            }
-            let font = item.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}");
-                    self.as_mut().set_font(font);
-                }
-            } else {
-                println!("font: empty");
-            }
-            let vtext_alignment = item
-                .get(&QString::from("verticalTextAlignment"))
-                .unwrap_or(QVariant::from(&QString::from("center")));
-            if let Some(vtext_alignment) =
-                vtext_alignment.value::<QString>()
-            {
-                if &vtext_alignment != self.as_ref().vtext_alignment()
-                {
-                    println!(
-                        "vertical-text-align: {vtext_alignment}"
-                    );
-                    self.as_mut()
-                        .set_vtext_alignment(vtext_alignment);
-                }
-            } else {
-                println!("vertical-text-align: empty");
-            }
-            let htext_alignment = item
-                .get(&QString::from("horizontalTextAlignment"))
-                .unwrap_or(QVariant::from(&QString::from("center")));
-            if let Some(htext_alignment) =
-                htext_alignment.value::<QString>()
-            {
-                if &htext_alignment != self.as_ref().htext_alignment()
-                {
-                    println!(
-                        "horizontal-text-align: {htext_alignment}"
-                    );
-                    self.as_mut()
-                        .set_htext_alignment(htext_alignment);
-                }
-            } else {
-                println!("horizontal-text-align: empty");
-            }
-            let font_size = item
-                .get(&QString::from("fontSize"))
-                .unwrap_or(QVariant::from(&50));
-            if let Some(font_size) = font_size.value::<i32>() {
-                if &font_size != self.as_ref().font_size() {
-                    println!("font-size: {font_size}");
-                    self.as_mut().set_font_size(font_size);
-                }
-            } else {
-                println!("font-size: empty");
-            }
-            let looping = item
-                .get(&QString::from("looping"))
-                .unwrap_or(QVariant::from(&false));
-            if let Some(looping) = looping.value::<bool>() {
-                if &looping != self.as_ref().looping() {
-                    println!("looping: {looping}");
-                    self.as_mut().set_looping(looping);
-                    let lp = looping;
-                    self.as_mut()
-                        .emit(Signals::LoopChanged { looping: &lp });
-                }
-            } else {
-                println!("looping: empty")
-            }
-            let slide_size = item
-                .get(&QString::from("slide_size"))
-                .unwrap_or(QVariant::from(&1));
-            if let Some(slide_size) = slide_size.value::<i32>() {
-                if &slide_size != self.as_ref().slide_size() {
-                    println!("slide-size: {slide_size}");
-                    self.as_mut().set_slide_size(slide_size);
-                }
-            }
-            let video_start_time = item
-                .get(&QString::from("videoStartTime"))
-                .unwrap_or(QVariant::from(&0.0));
-            if let Some(int) = video_start_time.value::<f32>() {
-                self.as_mut().set_video_start_time(int)
-            }
-
-            self.as_mut().set_image_count(count);
-
-            self.as_mut().set_slide_index(slide_index);
-
-            self.as_mut()
-                .emit(Signals::SlideChanged { slide: &index });
-            println!("## Slide End ##");
-        }
-
         #[qinvokable]
-        pub fn next(
+        fn next(
-            mut self: Pin<&mut Self>,
+            self: Pin<&mut SlideObject>,
             next_item: QMap_QString_QVariant,
-        ) -> bool {
+        ) -> bool;
-            let new_id = self.as_ref().slide_index() + 1;
-            self.as_mut().change_slide(next_item, new_id);
-            true
-        }
         #[qinvokable]
-        pub fn previous(
+        fn previous(
-            mut self: Pin<&mut Self>,
+            self: Pin<&mut SlideObject>,
-            prev_item: QMap_QString_QVariant,
+            next_item: QMap_QString_QVariant,
-        ) -> bool {
+        ) -> bool;
-            let new_id = self.as_ref().slide_index() - 1;
-            self.as_mut().change_slide(prev_item, new_id);
-            true
-        }
         #[qinvokable]
-        pub fn play(mut self: Pin<&mut Self>) -> bool {
+        pub fn play(self: Pin<&mut SlideObject>) -> bool;
-            self.as_mut().set_is_playing(true);
-            self.as_mut().emit_playing_changed(&true);
-            true
-        }
         #[qinvokable]
-        pub fn pause(mut self: Pin<&mut Self>) -> bool {
+        pub fn pause(self: Pin<&mut SlideObject>) -> bool;
-            self.as_mut().set_is_playing(false);
-            self.as_mut().emit_playing_changed(&false);
-            false
-        }
         #[qinvokable]
-        pub fn play_pause(mut self: Pin<&mut Self>) -> bool {
+        pub fn play_pause(self: Pin<&mut SlideObject>) -> 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),
+use tracing::debug;
-            }
+
-            self.as_mut().emit_playing_changed(&!playing);
+#[derive(Clone, Debug)]
-            !playing
+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,
+            slide_size: 0,
+            is_playing: false,
+            looping: false,
+            text: QString::from(""),
+            ty: QString::from(""),
+            audio: QString::from(""),
+            image_background: QString::from(""),
+            html: QString::from(""),
+            video_background: QString::from(""),
+            vtext_alignment: QString::from(""),
+            htext_alignment: QString::from(""),
+            font: QString::from(""),
+            font_size: 50,
+            image_count: 0,
+            video_start_time: 0.0,
+            video_end_time: 0.0,
         }
     }
 }
+
+impl qobject::SlideObject {
+    pub fn change_slide(
+        mut self: Pin<&mut Self>,
+        item: QMap_QString_QVariant,
+        index: i32,
+    ) {
+        let current_index = self.as_ref().get_ref().slide_index();
+        let icount_variant = item
+            .get(&QString::from("imageCount"))
+            .unwrap_or(QVariant::from(&1));
+        let count = icount_variant.value::<i32>().unwrap_or_default();
+
+        let slindex = item
+            .get(&QString::from("slideIndex"))
+            .unwrap_or(QVariant::from(&0));
+        let slide_index = slindex.value::<i32>().unwrap_or_default();
+
+        let html = item
+            .get(&QString::from("html"))
+            .unwrap_or(QVariant::from(&false));
+        if let Some(html) = html.value::<bool>() {
+            if html {
+                debug!(?html, count, slide_index);
+                if slide_index > 0 && slide_index < count - 1 {
+                    if current_index < &index {
+                        self.as_mut().emit(Signals::RevealNext);
+                        debug!(signal = ?Signals::RevealNext);
+                        return;
+                    } else if slide_index > 0 {
+                        self.as_mut().emit(Signals::RevealPrev);
+                        debug!(signal = ?Signals::RevealPrev);
+                        return;
+                    }
+                }
+            }
+        }
+
+        println!("## Slide Details ##");
+        let text = item
+            .get(&QString::from("text"))
+            .unwrap_or(QVariant::from(&QString::from("")));
+        if let Some(txt) = text.value::<QString>() {
+            if &txt != self.as_ref().text() {
+                println!("text: {txt}");
+                self.as_mut().set_text(txt);
+            };
+        } else {
+            println!("text: empty");
+        }
+        let audio = item
+            .get(&QString::from("audio"))
+            .unwrap_or(QVariant::from(&QString::from("")));
+        if let Some(audio) = audio.value::<QString>() {
+            if &audio != self.as_ref().audio() {
+                println!("audio: {audio}");
+                self.as_mut().set_audio(audio);
+            }
+        } else {
+            println!("audio: empty");
+        }
+        let ty = item
+            .get(&QString::from("type"))
+            .unwrap_or(QVariant::from(&QString::from("")));
+        if let Some(ty) = ty.value::<QString>() {
+            if &ty != self.as_ref().ty() {
+                println!("type: {ty}");
+                self.as_mut().set_ty(ty);
+            }
+        } else {
+            println!("type: empty");
+        }
+
+        let image_background = item
+            .get(&QString::from("imageBackground"))
+            .unwrap_or(QVariant::from(&QString::from("")));
+        if let Some(image_background) =
+            image_background.value::<QString>()
+        {
+            if &image_background != self.as_ref().image_background() {
+                println!("image-bg: {image_background}");
+                self.as_mut().set_image_background(image_background);
+            }
+        } else {
+            println!("image-bg: empty");
+        }
+        let video_background = item
+            .get(&QString::from("videoBackground"))
+            .unwrap_or(QVariant::from(&QString::from("")));
+        if let Some(video_background) =
+            video_background.value::<QString>()
+        {
+            if &video_background != self.as_ref().video_background() {
+                println!("video-bg: {video_background}");
+                self.as_mut().set_video_background(video_background);
+            }
+        } else {
+            println!("video-bg: empty");
+        }
+        let font = item
+            .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}");
+                self.as_mut().set_font(font);
+            }
+        } else {
+            println!("font: empty");
+        }
+        let vtext_alignment = item
+            .get(&QString::from("verticalTextAlignment"))
+            .unwrap_or(QVariant::from(&QString::from("center")));
+        if let Some(vtext_alignment) =
+            vtext_alignment.value::<QString>()
+        {
+            if &vtext_alignment != self.as_ref().vtext_alignment() {
+                println!("vertical-text-align: {vtext_alignment}");
+                self.as_mut().set_vtext_alignment(vtext_alignment);
+            }
+        } else {
+            println!("vertical-text-align: empty");
+        }
+        let htext_alignment = item
+            .get(&QString::from("horizontalTextAlignment"))
+            .unwrap_or(QVariant::from(&QString::from("center")));
+        if let Some(htext_alignment) =
+            htext_alignment.value::<QString>()
+        {
+            if &htext_alignment != self.as_ref().htext_alignment() {
+                println!("horizontal-text-align: {htext_alignment}");
+                self.as_mut().set_htext_alignment(htext_alignment);
+            }
+        } else {
+            println!("horizontal-text-align: empty");
+        }
+        let font_size = item
+            .get(&QString::from("fontSize"))
+            .unwrap_or(QVariant::from(&50));
+        if let Some(font_size) = font_size.value::<i32>() {
+            if &font_size != self.as_ref().font_size() {
+                println!("font-size: {font_size}");
+                self.as_mut().set_font_size(font_size);
+            }
+        } else {
+            println!("font-size: empty");
+        }
+        let looping = item
+            .get(&QString::from("looping"))
+            .unwrap_or(QVariant::from(&false));
+        if let Some(looping) = looping.value::<bool>() {
+            if &looping != self.as_ref().looping() {
+                println!("looping: {looping}");
+                self.as_mut().set_looping(looping);
+                let lp = looping;
+                self.as_mut()
+                    .emit(Signals::LoopChanged { looping: &lp });
+            }
+        } else {
+            println!("looping: empty")
+        }
+        let slide_size = item
+            .get(&QString::from("slide_size"))
+            .unwrap_or(QVariant::from(&1));
+        if let Some(slide_size) = slide_size.value::<i32>() {
+            if &slide_size != self.as_ref().slide_size() {
+                println!("slide-size: {slide_size}");
+                self.as_mut().set_slide_size(slide_size);
+            }
+        }
+        let video_start_time = item
+            .get(&QString::from("videoStartTime"))
+            .unwrap_or(QVariant::from(&0.0));
+        if let Some(int) = video_start_time.value::<f32>() {
+            self.as_mut().set_video_start_time(int)
+        }
+
+        self.as_mut().set_image_count(count);
+
+        self.as_mut().set_slide_index(slide_index);
+
+        self.as_mut().emit(Signals::SlideChanged { slide: &index });
+        println!("## Slide End ##");
+    }
+
+    pub fn next(
+        mut self: Pin<&mut Self>,
+        next_item: QMap_QString_QVariant,
+    ) -> bool {
+        let new_id = self.as_ref().slide_index() + 1;
+        self.as_mut().change_slide(next_item, new_id);
+        true
+    }
+    pub fn previous(
+        mut self: Pin<&mut Self>,
+        prev_item: QMap_QString_QVariant,
+    ) -> bool {
+        let new_id = self.as_ref().slide_index() - 1;
+        self.as_mut().change_slide(prev_item, new_id);
+        true
+    }
+    pub fn play(mut self: Pin<&mut Self>) -> bool {
+        self.as_mut().set_is_playing(true);
+        self.as_mut().emit_playing_changed(&true);
+        true
+    }
+    pub fn pause(mut self: Pin<&mut Self>) -> bool {
+        self.as_mut().set_is_playing(false);
+        self.as_mut().emit_playing_changed(&false);
+        false
+    }
+    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);
+        !playing
+    }
+}