trying to move slide building to more backend focused

src/rust/image_model.rs

@@ -1,5 +1,5 @@
 #[cxx_qt::bridge]
-mod image_model {
+pub mod image_model {
     unsafe extern "C++" {
         include!(< QAbstractListModel >);
         include!("cxx-qt-lib/qhash.h");
@@ -206,6 +206,12 @@ impl Default for ImageModelRust {
     }
 }
 
+impl ImageModelRust {
+    pub fn get_image(index: i32) -> Option<&Image> {
+        todo!()
+    }
+}
+
 impl image_model::ImageModel {
     pub fn clear(mut self: Pin<&mut Self>) {
         unsafe {

src/rust/presentation_model.rs

@@ -1,5 +1,5 @@
 #[cxx_qt::bridge]
-mod presentation_model {
+pub mod presentation_model {
     unsafe extern "C++" {
         include!(< QAbstractListModel >);
         include!("cxx-qt-lib/qhash.h");
@@ -233,6 +233,12 @@ impl Default for PresentationModelRust {
     }
 }
 
+impl PresentationModelRust {
+    pub fn get_presentation(index: i32) -> Presentation {
+        todo!()
+    }
+}
+
 impl presentation_model::PresentationModel {
     pub fn clear(mut self: Pin<&mut Self>) {
         unsafe {

src/rust/service_item_model.rs

@@ -72,13 +72,15 @@ mod service_item_model {
         fn item_inserted(
             self: Pin<&mut ServiceItemModel>,
             index: &i32,
-            item: &QMap_QString_QVariant,
+            id: &i32,
+            kind: &QString,
         );
         #[qsignal]
         fn item_added(
             self: Pin<&mut ServiceItemModel>,
             index: &i32,
-            item: &QMap_QString_QVariant,
+            id: &i32,
+            kind: &QString,
         );
         #[qsignal]
         fn item_removed(
@@ -471,9 +473,8 @@ impl service_item_model::ServiceItemModel {
             self.as_mut().rust_mut().service_items.push(s_item);
             self.as_mut().end_insert_rows();
         }
-        let item = self.as_mut().get_item(index);
         debug!("ADDING: {:?}", &service_item);
-        self.as_mut().item_added(&index, &item);
+        self.as_mut().item_added(&index, &service_item.id, &service_item.ty.to_string());
     }
 
     pub fn insert_item(
@@ -516,24 +517,23 @@ impl service_item_model::ServiceItemModel {
     fn insert_service_item(
         mut self: Pin<&mut Self>,
         service_item: &ServiceItem,
-        id: i32,
+        index: i32,
     ) {
         let s_item = service_item.clone();
         unsafe {
             self.as_mut().begin_insert_rows(
                 &QModelIndex::default(),
-                id,
+                index,
-                id,
+                index,
             );
             self.as_mut()
                 .rust_mut()
                 .service_items
-                .insert(id as usize, s_item);
+                .insert(index as usize, s_item);
             self.as_mut().end_insert_rows();
         }
-        let item = self.as_mut().get_item(id);
         debug!("ADDING: {:?}", &service_item);
-        self.as_mut().item_inserted(&id, &item);
+        self.as_mut().item_inserted(&index, &service_item.id, &service_item.ty.to_string());
     }
 
     pub fn get_item(

src/rust/slide_model.rs

@@ -20,6 +20,14 @@ pub mod slide_model {
         type QList_QString = cxx_qt_lib::QList<QString>;
         include!("cxx-qt-gen/slide_object.cxxqt.h");
         type SlideObject = crate::slide_object::slide_object::SlideObject;
+        include!("cxx-qt-gen/song_model.cxxqt.h");
+        type SongModel = crate::songs::song_model::song_model::SongModel;
+        include!("cxx-qt-gen/video_model.cxxqt.h");
+        type VideoModel = crate::video_model::video_model::VideoModel;
+        include!("cxx-qt-gen/image_model.cxxqt.h");
+        type ImageModel = crate::image_model::image_model::ImageModel;
+        include!("cxx-qt-gen/presentation_model.cxxqt.h");
+        type PresentationModel = crate::presentation_model::presentation_model::PresentationModel;
     }
 
     #[qenum(SlideModel)]
@@ -52,6 +60,10 @@ pub mod slide_model {
         #[qml_element]
         #[qproperty(i32, count)]
         #[qproperty(*mut SlideObject, slide_object)]
+        // #[qproperty(*mut SongModel, song_model)]
+        // #[qproperty(*mut VideoModel, video_model)]
+        // #[qproperty(*mut ImageModel, image_model)]
+        // #[qproperty(*mut PresentationModel, presentation_model)]
         type SlideModel = super::SlideModelRust;
 
         #[inherit]
@@ -90,6 +102,7 @@ pub mod slide_model {
             self: Pin<&mut SlideModel>,
             index: i32,
             service_item: &QMap_QString_QVariant,
+            id: i32,
         );
 
         #[qinvokable]
@@ -97,6 +110,7 @@ pub mod slide_model {
             self: Pin<&mut SlideModel>,
             index: i32,
             service_item: &QMap_QString_QVariant,
+            id: i32,
         );
 
         #[qinvokable]
@@ -214,9 +228,16 @@ pub mod slide_model {
     }
 }
 
+use crate::image_model::image_model::ImageModel;
+use crate::presentation_model::presentation_model::PresentationModel;
+use crate::songs::song_model::song_model::SongModel;
+use crate::songs::song_model::SongModelRust;
+use crate::video_model::video_model::VideoModel;
+use crate::video_model::VideoModelRust;
 use crate::{ffmpeg, slide_types::SlideType};
 use crate::obs::Obs;
 use crate::slide_model::slide_model::QList_QString;
+use color_eyre::owo_colors::OwoColorize;
 use cxx_qt::{CxxQtType, Threading};
 use cxx_qt_lib::{
     CaseSensitivity, QByteArray, QModelIndex, QString, QStringList, QVariant
@@ -283,11 +304,15 @@ impl Default for Slide {
 
 #[derive(Debug)]
 pub struct SlideModelRust {
-    id: i32,
+    current_index: i32,
     slides: Vec<Slide>,
     obs: Option<Obs>,
     count: i32,
     slide_object: *mut SlideObject,
+    // song_model: *mut SongModel,
+    // video_model: *mut VideoModel,
+    // image_model: *mut ImageModel,
+    // presentation_model: *mut PresentationModel,
 }
 
 impl Default for SlideModelRust {
@@ -303,11 +328,15 @@ impl Default for SlideModelRust {
                 }
             });
         Self {
-            id: 0,
+            current_index: 0,
             slides: Vec::new(),
             obs,
             count: 0,
             slide_object: std::ptr::null_mut(),
+            // song_model: std::ptr::null_mut(),
+            // video_model: std::ptr::null_mut(),
+            // image_model: std::ptr::null_mut(),
+            // presentation_model: std::ptr::null_mut(),
         }
     }
 }
@@ -471,6 +500,7 @@ impl slide_model::SlideModel {
         mut self: Pin<&mut Self>,
         index: i32,
         service_item: &QMap_QString_QVariant,
+        id: i32,
     ) {
         debug!(index, "Inserting slide from service insert");
         for (key, data) in service_item.iter() {
@@ -634,11 +664,31 @@ impl slide_model::SlideModel {
     pub fn add_item_from_service(
         mut self: Pin<&mut Self>,
         index: i32,
-        service_item: &QMap_QString_QVariant,
+        id: i32,
+        kind: &QString,
     ) {
         debug!("add rust slide {:?}", index);
         let mut slide = Slide::default();
         let iter = service_item.iter();
+        if let Ok(kind) = SlideType::try_from(kind) {
+            match kind {
+                SlideType::Song => {
+                    let song = SongModelRust::get_song(id)?;
+                },
+                SlideType::Video => {
+                    let video = VideoModelRust::get_video(id)?;
+                },
+                SlideType::Image => {
+                    let image = ImageModelRust::get_image(id)?;
+                },
+                SlideType::Content => {
+                    todo!()
+                },
+                SlideType::Presentation(_) => {
+                    let presentation = PresentationModelRust::get_presentation(id)?;
+                }
+            }
+        }
 
         for (key, _value) in iter {
             debug!(?key);
@@ -1124,11 +1174,11 @@ impl slide_model::SlideModel {
     pub fn next(mut self: Pin<&mut Self>) -> bool {
         if let Some(object) = unsafe { self.slide_object.as_mut() } {
             let object = unsafe { Pin::new_unchecked(object) };
-            let id = self.as_ref().id + 1;
+            let id = self.as_ref().current_index + 1;
             if let Some(slide) = self.rust().slides.get(id as usize) {
                 object.set_slide(slide);
                 self.as_mut().activate(id);
-                self.as_mut().rust_mut().id = id;
+                self.as_mut().rust_mut().current_index = id;
                 true
             } else {
                 false
@@ -1141,11 +1191,11 @@ impl slide_model::SlideModel {
     pub fn prev(mut self: Pin<&mut Self>) -> bool {
         if let Some(object) = unsafe { self.slide_object.as_mut() } {
             let object = unsafe { Pin::new_unchecked(object) };
-            let id = self.as_ref().id - 1;
+            let id = self.as_ref().current_index - 1;
             if let Some(slide) = self.rust().slides.get(id as usize) {
                 object.set_slide(slide);
                 self.as_mut().activate(id);
-                self.as_mut().rust_mut().id = id;
+                self.as_mut().rust_mut().current_index = id;
                 true
             } else {
                 false

src/rust/songs/song_model.rs

@@ -249,6 +249,7 @@ use sqlx::{query, query_as, Connection, SqliteConnection};
 use std::collections::HashMap;
 use std::pin::Pin;
 use tracing::{debug, error};
+use color_eyre::Result;
 
 use self::song_model::{
     QHash_i32_QByteArray, QMap_QString_QVariant, QVector_i32,
@@ -315,6 +316,29 @@ impl Default for SongModelRust {
     }
 }
 
+const SELECT_SINGLE_SONG_STATEMENT: &'static str = r#"SELECT vorder as "verse_order!", fontSize as "font_size!: i32", backgroundType as "background_type!", horizontalTextAlignment as "horizontal_text_alignment!", verticalTextAlignment as "vertical_text_alignment!", title as "title!", font as "font!", background as "background!", lyrics as "lyrics!", ccli as "ccli!", author as "author!", audio as "audio!", id as "id: i32"  from songs where id = ?"#;
+
+impl SongModelRust {
+    pub fn get_song(id: i32) -> Result<Song> {
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        let mut db = {
+            let mut data = dirs::data_local_dir().unwrap();
+            data.push("lumina");
+            data.push("library-db.sqlite3");
+            let mut db_url = String::from("sqlite://");
+            db_url.push_str(data.to_str().unwrap());
+            rt.block_on(async {
+                SqliteConnection::connect(&db_url).await.expect("problems")
+            })
+        };
+        rt.block_on(async {
+            let statement = format!("{} where id = ?", SELECT_SONG_STATEMENT).as_str();
+            let result = query_as!(Song, SELECT_SINGLE_SONG_STATEMENT, id).fetch_one(&mut db).await?;
+            Ok(result)
+        })
+    }
+}
+
 impl song_model::SongModel {
     pub fn clear(mut self: Pin<&mut Self>) {
         unsafe {

src/rust/video_model.rs

@@ -1,5 +1,5 @@
 #[cxx_qt::bridge]
-mod video_model {
+pub mod video_model {
     unsafe extern "C++" {
         include!(< QAbstractListModel >);
         include!("cxx-qt-lib/qhash.h");
@@ -231,6 +231,13 @@ impl Default for VideoModelRust {
     }
 }
 
+impl VideoModelRust {
+    pub fn get_video(index: i32) -> Option<&Video> {
+        todo!();
+    }
+
+}
+
 impl video_model::VideoModel {
     pub fn clear(mut self: Pin<&mut Self>) {
         unsafe {