added the loading function.

src/rust/service_item_model.rs

@@ -1,4 +1,3 @@
-use serde::{Deserialize, Serialize};
 #[cxx_qt::bridge]
 mod service_item_model {
     unsafe extern "C++" {
@@ -23,8 +22,9 @@ mod service_item_model {
         type QUrl = cxx_qt_lib::QUrl;
     }
 
+    use serde::{Deserialize, Serialize};
     #[cxx_qt::qobject]
-    #[derive(Clone, Debug, Deserialize, Serialize)]
+    #[derive(Clone, Debug)]
     pub struct ServiceItm {
         #[qproperty]
         name: QString,
@@ -135,10 +135,10 @@ mod service_item_model {
     // use image::{ImageBuffer, Rgba};
     use dirs;
     use serde_json::{Deserializer, Serializer, Value};
-    use std::fs;
     use std::io::{self, Read, Write};
     use std::path::{Path, PathBuf};
     use std::str;
+    use std::{fs, println};
     use tar::{Archive, Builder};
     use zstd::{Decoder, Encoder};
     impl qobject::ServiceItemMod {
@@ -210,6 +210,8 @@ mod service_item_model {
                 self.as_mut().service_items_mut().push(service_item);
                 self.as_mut().end_insert_rows();
             }
+            let item = self.as_mut().get_item(index);
+            self.as_mut().emit_item_added(&index, &item);
         }
 
         #[qinvokable]
@@ -303,7 +305,32 @@ mod service_item_model {
 
         #[qinvokable]
         pub fn select(mut self: Pin<&mut Self>, index: i32) -> bool {
-            todo!();
+            let rc = self.as_ref().count() - 1;
+            let tl = &self.as_ref().index(0, 0, &QModelIndex::default());
+            let br = &self.as_ref().index(rc, 0, &QModelIndex::default());
+            let mut vector_roles = QVector_i32::default();
+            vector_roles.append(self.get_role(Role::SelectedRole));
+            for service_item in self.as_mut().service_items_mut().iter_mut() {
+                // println!("service_item is deactivating {:?}", i);
+                service_item.selected = false;
+            }
+            if let Some(service_item) = self.as_mut().service_items_mut().get_mut(index as usize) {
+                println!("selecting-item: {:?}", index);
+                println!("service_item_title: {:?}", service_item.name);
+                println!("service_item_background: {:?}", service_item.background);
+                println!(
+                    "service_item_background_type: {:?}",
+                    service_item.background_type
+                );
+                service_item.selected = true;
+                self.as_mut().emit_data_changed(tl, br, &vector_roles);
+                // We use this signal generated by our signals enum to tell QML that
+                // the selected service_item has changed which is used to reposition views.
+                self.as_mut().emit_selected_changed();
+                true
+            } else {
+                false
+            }
         }
 
         #[qinvokable]
@@ -354,34 +381,89 @@ mod service_item_model {
         #[qinvokable]
         pub fn load(mut self: Pin<&mut Self>, file: QUrl) -> bool {
             // todo!();
-            println!("THE LAST SAVE FILE ISSSSS: {file}");
+            println!("file is: {file}");
-            let lf = fs::File::open(file.to_local_file().unwrap_or_default().to_string()).unwrap();
+            let lfr = fs::File::open(file.to_local_file().unwrap_or_default().to_string());
+            if let Ok(lf) = lfr {
                 println!("{:?}", lf);
                 let dec = Decoder::new(lf).unwrap();
                 let mut tar = Archive::new(dec);
                 for file in tar.entries().unwrap() {
                     let mut file = file.unwrap();
                     // Inspect metadata about the file
-                println!("{:?}", file.header().path().unwrap());
+                    println!("filename: {:?}", file.header().path().unwrap());
-                println!("{:?}", file.header().size().unwrap());
+                    println!("size: {:?}", file.header().size().unwrap());
 
                     if file.header().path().unwrap().to_str().unwrap() == "servicelist.json" {
                         println!("THIS ONE HERE CAPTAIN!");
 
                         let mut s = String::new();
                         file.read_to_string(&mut s);
-                    println!("{:?}", s);
                         let ds: Value = serde_json::from_str(&s).unwrap();
-                    println!("{:?}", ds);
+                        for obj in ds.as_array().unwrap() {
+                            println!("objname: {:?}", obj.get("name").unwrap().as_str().unwrap());
+                            println!("objtype: {:?}", obj.get("type").unwrap().as_str().unwrap());
+                            let name = QString::from(obj.get("name").unwrap().as_str().unwrap());
+                            let ty = QString::from(obj.get("type").unwrap().as_str().unwrap());
+                            // both audio and background will need to know if
+                            // it exists on disk, if not use the flat version
+                            let audio = QString::from(obj.get("audio").unwrap().as_str().unwrap());
+                            let background =
+                                QString::from(obj.get("background").unwrap().as_str().unwrap());
+                            let background_type =
+                                QString::from(obj.get("backgroundType").unwrap().as_str().unwrap());
+                            let font = QString::from(obj.get("font").unwrap().as_str().unwrap());
+                            let font_size = obj.get("fontSize").unwrap().as_i64().unwrap() as i32;
+                            let looping = obj.get("loop").unwrap().as_bool().unwrap();
+                            let slide_count =
+                                obj.get("slideNumber").unwrap().as_i64().unwrap() as i32;
+                            let mut video_start_time = f32::default();
+                            if let Some(video_start_value) = obj.get("video_start_time") {
+                                video_start_time = video_start_value.as_f64().unwrap() as f32;
+                            }
+                            let mut video_end_time = f32::default();
+                            if let Some(video_end_value) = obj.get("video_end_time") {
+                                video_end_time = video_end_value.as_f64().unwrap() as f32;
+                            }
+                            let text_array = obj.get("text").unwrap().as_array().unwrap();
+                            let mut text_list = QList_QString::default();
+                            for txt in text_array {
+                                text_list.append(QString::from(txt.as_str().unwrap()));
+                            }
+                            let text = QStringList::from(&text_list);
+
+                            let service_item = ServiceItm {
+                                name,
+                                ty,
+                                text,
+                                background,
+                                background_type,
+                                audio,
+                                font,
+                                font_size,
+                                slide_count,
+                                looping,
+                                video_start_time,
+                                video_end_time,
+                                ..Default::default()
+                            };
+                            self.as_mut().add_service_item(&service_item);
+                        }
+                        println!("Loaded Service: {:?}", ds);
                     }
                     // // files implement the Read trait
                 }
+                true
+            } else {
+                println!("There is no file here: {file}");
+                println!("Loading default service");
                 false
             }
+        }
 
         #[qinvokable]
         pub fn load_last_saved(mut self: Pin<&mut Self>) -> bool {
             todo!();
+            // Don't actually need
         }
 
         fn get_role(&self, role: Role) -> i32 {