diff --git a/src/rust/file_helper.rs b/src/rust/file_helper.rs
index a8b002a..47c3039 100644
--- a/src/rust/file_helper.rs
+++ b/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,127 +11,124 @@ mod file_helper {
         type QVariant = cxx_qt_lib::QVariant;
     }
 
-    #[derive(Clone)]
-    #[cxx_qt::qobject]
-    pub struct FileHelper {
-        #[qproperty]
-        name: QString,
-        #[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;
-        // }
+    unsafe extern "RustQt" {
+        #[qobject]
+        #[qml_element]
+        #[qproperty(QString, name)]
+        #[qproperty(QString, file_path)]
+        type FileHelper = super::FileHelperRust;
 
         #[qinvokable]
-        pub fn load(self: Pin<&mut Self>, file: QUrl) -> Vec<String> {
-            println!("{file}");
-            vec!["hi".to_string()]
-        }
-
+        fn validate(self: Pin<&mut FileHelper>, file: QUrl) -> bool;
         #[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://");
-            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
-                }
-            }
-        }
-
+        pub fn save_file(self: Pin<&mut FileHelper>) -> QUrl;
         #[qinvokable]
-        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()
-            }
-        }
-
-        #[qinvokable]
-        pub fn load_file(
-            self: Pin<&mut Self>,
+        fn load_file(
+            self: Pin<&mut FileHelper>,
             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()
-            }
+        ) -> 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 ffi::FileHelperRust {
+    pub fn validate(self: Pin<&mut Self>, 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
+            }
+        }
+    }
+
+    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()
         }
     }
 }
diff --git a/src/rust/slide_obj.rs b/src/rust/slide_obj.rs
index 4e84183..2a97bb3 100644
--- a/src/rust/slide_obj.rs
+++ b/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,294 +10,312 @@ mod slide_obj {
         type QVariant = cxx_qt_lib::QVariant;
     }
 
-    #[cxx_qt::qsignals(SlideObj)]
-    pub enum Signals<'a> {
-        PlayingChanged { is_playing: &'a bool },
-        SlideIndexChanged { slide_index: &'a i32 },
-        SlideSizeChanged { slide_size: &'a i32 },
-        SlideChanged { slide: &'a i32 },
-        LoopChanged { looping: &'a bool },
-    }
+    unsafe extern "RustQt" {
+        #[qobject]
+        #[qml_element]
+        #[qproperty(i32, slide_index)]
+        #[qproperty(i32, slide_size)]
+        #[qproperty(i32, image_count)]
+        #[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)]
-    #[cxx_qt::qobject]
-    pub struct SlideObj {
-        #[qproperty]
-        slide_index: i32,
-        #[qproperty]
-        slide_size: i32,
-        #[qproperty]
-        image_count: i32,
-        #[qproperty]
-        is_playing: bool,
-        #[qproperty]
-        looping: bool,
-        #[qproperty]
-        text: QString,
-        #[qproperty]
-        ty: QString,
-        #[qproperty]
-        audio: QString,
-        #[qproperty]
-        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,
-    }
+        #[qsignal]
+        fn playing_changed(
+            self: Pin<&mut SlideObj>,
+            is_playing: bool,
+        );
+        #[qsignal]
+        fn slide_index_changed(
+            self: Pin<&mut SlideObj>,
+            slide_index: i32,
+        );
+        #[qsignal]
+        fn slide_size_changed(
+            self: Pin<&mut SlideObj>,
+            slide_size: i32,
+        );
+        #[qsignal]
+        fn slide_changed(self: Pin<&mut SlideObj>, slide: i32);
+        #[qsignal]
+        fn loop_changed(self: Pin<&mut SlideObj>, looping: bool);
 
-    impl Default for SlideObj {
-        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::SlideObj {
         #[qinvokable]
-        pub fn change_slide(
-            mut self: Pin<&mut Self>,
+        fn change_slide(
+            self: Pin<&mut SlideObj>,
             item: QMap_QString_QVariant,
             index: i32,
-        ) {
-            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)
-            }
-            let icount = item
-                .get(&QString::from("imageCount"))
-                .unwrap_or(QVariant::from(&1));
-            if let Some(int) = icount.value::<i32>() {
-                self.as_mut().set_image_count(int);
-            }
-            let slindex = item
-                .get(&QString::from("slideIndex"))
-                .unwrap_or(QVariant::from(&0));
-            if let Some(int) = slindex.value::<i32>() {
-                println!("New slide index = {}", int);
-                self.as_mut().set_slide_index(int);
-            };
-            self.as_mut()
-                .emit(Signals::SlideChanged { slide: &index });
-            println!("## Slide End ##");
-        }
-
+        );
         #[qinvokable]
-        pub fn next(
-            mut self: Pin<&mut Self>,
+        fn next(
+            self: Pin<&mut SlideObj>,
             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
-        }
+        ) -> bool;
         #[qinvokable]
-        pub fn previous(
-            mut self: Pin<&mut Self>,
+        fn previous(
+            self: Pin<&mut SlideObj>,
             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
-        }
+        ) -> bool;
         #[qinvokable]
-        pub fn play(mut self: Pin<&mut Self>) -> bool {
-            self.as_mut().set_is_playing(true);
-            self.as_mut().emit_playing_changed(&true);
-            true
-        }
+        fn play(self: Pin<&mut SlideObj>) -> bool;
         #[qinvokable]
-        pub fn pause(mut self: Pin<&mut Self>) -> bool {
-            self.as_mut().set_is_playing(false);
-            self.as_mut().emit_playing_changed(&false);
-            false
-        }
+        fn pause(self: Pin<&mut SlideObj>) -> bool;
         #[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);
-            !playing
+        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,
+            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 ffi::SlideObjectRust {
+    pub fn change_slide(
+        mut self: Pin<&mut Self>,
+        item: QMap_QString_QVariant,
+        index: i32,
+    ) {
+        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().loop_changed(&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)
+        }
+        let icount = item
+            .get(&QString::from("imageCount"))
+            .unwrap_or(QVariant::from(&1));
+        if let Some(int) = icount.value::<i32>() {
+            self.as_mut().set_image_count(int);
+        }
+        let slindex = item
+            .get(&QString::from("slideIndex"))
+            .unwrap_or(QVariant::from(&0));
+        if let Some(int) = slindex.value::<i32>() {
+            println!("New slide index = {}", int);
+            self.as_mut().set_slide_index(int);
+        };
+        self.as_mut().slide_changed(&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().playing_changed(&true);
+        true
+    }
+    pub fn pause(mut self: Pin<&mut Self>) -> bool {
+        self.as_mut().set_is_playing(false);
+        self.as_mut().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().playing_changed(&!playing);
+        !playing
+    }
+}