From a0a8400d1660d70571774ef73eaa6f8f92d68236 Mon Sep 17 00:00:00 2001 From: Chris Cochrun Date: Wed, 11 Oct 2023 20:22:26 +0000 Subject: [PATCH] Revert "setting these two to do the same" This reverts commit ba25cee53f0504996750ba2e5ef434dc9922e988 --- src/rust/file_helper.rs | 225 ++++++++-------- src/rust/slide_obj.rs | 578 ++++++++++++++++++++-------------------- 2 files changed, 398 insertions(+), 405 deletions(-) diff --git a/src/rust/file_helper.rs b/src/rust/file_helper.rs index 47c3039..a8b002a 100644 --- a/src/rust/file_helper.rs +++ b/src/rust/file_helper.rs @@ -2,6 +2,10 @@ // 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; @@ -11,124 +15,127 @@ mod file_helper { type QVariant = cxx_qt_lib::QVariant; } - unsafe extern "RustQt" { - #[qobject] - #[qml_element] - #[qproperty(QString, name)] - #[qproperty(QString, file_path)] - type FileHelper = super::FileHelperRust; + #[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::(..) => println!("string"), + // QVariantValue::(..) => println!("url"), + // QVariantValue::(..) => println!("date"), + // _ => println!("QVariant is..."), + // } + // return true; + // } #[qinvokable] - fn validate(self: Pin<&mut FileHelper>, file: QUrl) -> bool; + pub fn load(self: Pin<&mut Self>, file: QUrl) -> Vec { + println!("{file}"); + vec!["hi".to_string()] + } + #[qinvokable] - pub fn save_file(self: Pin<&mut FileHelper>) -> QUrl; + 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 + } + } + } + #[qinvokable] - fn load_file( - self: Pin<&mut FileHelper>, + 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>, title: QString, filter: QString, - ) -> 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() + ) -> 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 { - 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 2a97bb3..4e84183 100644 --- a/src/rust/slide_obj.rs +++ b/src/rust/slide_obj.rs @@ -1,5 +1,9 @@ #[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; @@ -10,312 +14,294 @@ mod slide_obj { type QVariant = cxx_qt_lib::QVariant; } - 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; + #[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 }, + } - #[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); + #[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, + } + 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] - fn change_slide( - self: Pin<&mut SlideObj>, + pub fn change_slide( + mut self: Pin<&mut Self>, item: QMap_QString_QVariant, index: i32, - ); - #[qinvokable] - fn next( - self: Pin<&mut SlideObj>, - next_item: QMap_QString_QVariant, - ) -> bool; - #[qinvokable] - fn previous( - self: Pin<&mut SlideObj>, - prev_item: QMap_QString_QVariant, - ) -> bool; - #[qinvokable] - fn play(self: Pin<&mut SlideObj>) -> bool; - #[qinvokable] - fn pause(self: Pin<&mut SlideObj>) -> bool; - #[qinvokable] - fn play_pause(self: Pin<&mut SlideObj>) -> bool; + ) { + println!("## Slide Details ##"); + let text = item + .get(&QString::from("text")) + .unwrap_or(QVariant::from(&QString::from(""))); + if let Some(txt) = text.value::() { + 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::() { + 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::() { + if &ty != self.as_ref().ty() { + println!("type: {ty}"); + self.as_mut().set_ty(ty); + } + } else { + println!("type: empty"); + } - } -} - -#[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::() { - if &txt != self.as_ref().text() { - println!("text: {txt}"); - self.as_mut().set_text(txt); + let image_background = item + .get(&QString::from("imageBackground")) + .unwrap_or(QVariant::from(&QString::from(""))); + if let Some(image_background) = + image_background.value::() + { + 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::() + { + 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::() { + 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::() + { + 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::() + { + 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::() { + 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::() { + 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::() { + 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::() { + 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::() { + 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::() { + println!("New slide index = {}", int); + self.as_mut().set_slide_index(int); }; - } else { - println!("text: empty"); - } - let audio = item - .get(&QString::from("audio")) - .unwrap_or(QVariant::from(&QString::from(""))); - if let Some(audio) = audio.value::() { - 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::() { - if &ty != self.as_ref().ty() { - println!("type: {ty}"); - self.as_mut().set_ty(ty); - } - } else { - println!("type: empty"); + self.as_mut() + .emit(Signals::SlideChanged { slide: &index }); + println!("## Slide End ##"); } - let image_background = item - .get(&QString::from("imageBackground")) - .unwrap_or(QVariant::from(&QString::from(""))); - if let Some(image_background) = - image_background.value::() - { - if &image_background != self.as_ref().image_background() { - println!("image-bg: {image_background}"); - self.as_mut().set_image_background(image_background); + #[qinvokable] + 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 + } + #[qinvokable] + 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 + } + #[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 + } + #[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 + } + #[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), } - } else { - println!("image-bg: empty"); + self.as_mut().emit_playing_changed(&!playing); + !playing } - let video_background = item - .get(&QString::from("videoBackground")) - .unwrap_or(QVariant::from(&QString::from(""))); - if let Some(video_background) = - video_background.value::() - { - 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::() { - 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::() - { - 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::() - { - 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::() { - 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::() { - 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::() { - 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::() { - 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::() { - 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::() { - 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 } }