diff --git a/src/rust/slide_obj.rs b/src/rust/slide_obj.rs
index c0513c0..d489435 100644
--- a/src/rust/slide_obj.rs
+++ b/src/rust/slide_obj.rs
@@ -15,9 +15,9 @@ mod slide_obj {
 
     #[cxx_qt::qsignals(SlideObj)]
     pub enum Signals<'a> {
-        PlayingChanged { isPlaying: &'a bool },
-        SlideIndexChanged { slideIndex: &'a i32 },
-        SlideSizeChanged { slideSize: &'a i32 },
+        PlayingChanged { is_playing: &'a bool },
+        SlideIndexChanged { slide_index: &'a i32 },
+        SlideSizeChanged { slide_size: &'a i32 },
         SlideChanged { slide: &'a i32 },
         LoopChanged { looping: &'a bool },
     }
@@ -79,23 +79,34 @@ mod slide_obj {
     impl qobject::SlideObj {
         #[qinvokable]
         pub fn change_slide(mut self: Pin<&mut Self>, item: QMap_QString_QVariant, index: i32) {
-            let text = item.get(&QString::from("text")).unwrap();
+            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!("{}", &txt);
+                    println!("text: {txt}");
                     self.as_mut().set_text(txt);
                 };
+            } else {
+                println!("text: empty");
             }
-            let audio = item.get(&QString::from("audio")).unwrap();
+            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"));
             if let Some(ty) = ty {
                 if let Some(ty) = ty.value::<QString>() {
                     if &ty != self.as_ref().ty() {
+                        println!("type: {ty}");
                         self.as_mut().set_ty(ty);
                     }
                 } else {
@@ -110,64 +121,86 @@ mod slide_obj {
                 .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("vtext_alignment"))
+                .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("htext_alignment"))
+                .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("font_size"))
+                .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);
                 }
             }
@@ -178,13 +211,14 @@ mod slide_obj {
                 self.as_mut().set_image_count(int);
             }
             let slindex = item
-                .get(&QString::from("slide_index"))
+                .get(&QString::from("slideIndex"))
                 .unwrap_or(QVariant::from(&0));
             if let Some(int) = slindex.value::<i32>() {
                 self.as_mut().set_slide_index(int);
                 let si = int;
                 self.as_mut().emit(Signals::SlideChanged { slide: &si });
             };
+            println!("## Slide End ##");
         }
 
         #[qinvokable]