chris/lumina
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

setting these two to do the same

Browse source
This commit is contained in:
Chris Cochrun 2023-10-11 11:37:00 -05:00
parent 5163a39317
commit ba25cee53f
2 changed files with 406 additions and 399 deletions
Download patch file Download diff file Expand all files Collapse all files

231
src/rust/file_helper.rs
View file

@ -2,10 +2,6 @@
// of whether or not a file exists // of whether or not a file exists
#[cxx_qt::bridge] #[cxx_qt::bridge]
mod file_helper { mod file_helper {
use rfd::FileDialog;
use std::path::Path;
use tracing::{debug, debug_span, error, info, instrument};
unsafe extern "C++" { unsafe extern "C++" {
include!("cxx-qt-lib/qstring.h"); include!("cxx-qt-lib/qstring.h");
type QString = cxx_qt_lib::QString; type QString = cxx_qt_lib::QString;
@ -15,127 +11,124 @@ mod file_helper {
type QVariant = cxx_qt_lib::QVariant; type QVariant = cxx_qt_lib::QVariant;
} }
#[derive(Clone)] unsafe extern "RustQt" {
#[cxx_qt::qobject] #[qobject]
pub struct FileHelper { #[qml_element]
#[qproperty] #[qproperty(QString, name)]
name: QString, #[qproperty(QString, file_path)]
#[qproperty] type FileHelper = super::FileHelperRust;
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;
// }
#[qinvokable] #[qinvokable]
pub fn load(self: Pin<&mut Self>, file: QUrl) -> Vec<String> { fn validate(self: Pin<&mut FileHelper>, file: QUrl) -> bool;
println!("{file}");
vec!["hi".to_string()]
}
#[qinvokable] #[qinvokable]
pub fn validate(self: Pin<&mut Self>, file: QUrl) -> bool { pub fn save_file(self: Pin<&mut FileHelper>) -> QUrl;
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] #[qinvokable]
pub fn save_file(self: Pin<&mut Self>) -> QUrl { fn load_file(
let file = FileDialog::new() self: Pin<&mut FileHelper>,
.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, title: QString,
filter: QString, filter: QString,
) -> QUrl { ) -> QUrl;
let video_filters = [
"mp4", "webm", "avi", "mkv", "MP4", "WEBM", "AVI", }
"MKV", }
];
let image_filters = [ use rfd::FileDialog;
"jpg", "png", "gif", "jpeg", "JPG", "PNG", "webp", use std::path::Path;
"gif", use tracing::{debug, debug_span, error, info, instrument};
];
let audio_filters = ["mp3", "opus", "ogg", "flac", "wav"]; #[derive(Clone)]
let title = title.to_string(); pub struct FileHelperRust {
let filter = filter.to_string(); name: QString,
let mut file = FileDialog::new().set_title(title); file_path: QString,
match filter.as_str() { }
"video" => {
file = file.add_filter(filter, &video_filters); impl Default for FileHelperRust {
} fn default() -> Self {
"image" => { Self {
file = file.add_filter(filter, &image_filters); name: QString::from(""),
} file_path: QString::from(""),
"audio" => { }
file = file.add_filter(filter, &audio_filters); }
} }
_ => debug!("nothing"),
}; impl ffi::FileHelperRust {
let file = file.pick_file(); pub fn validate(self: Pin<&mut Self>, file: QUrl) -> bool {
if let Some(file) = file { let file_string = file.to_string();
println!("loading-file: {:?}", file); let file_string = file_string.strip_prefix("file://");
let mut string = match file_string {
String::from(file.to_str().unwrap_or("")); Some(file) => {
if string.is_empty() { let exists = Path::new(&file).exists();
QUrl::default() println!("{file} exists? {exists}");
} else { exists
string.insert_str(0, "file://"); }
QUrl::from(string.as_str()) None => {
} let exists = Path::new(&file.to_string()).exists();
} else { println!("{file} exists? {exists}");
QUrl::default() 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()
} }
} }
} }

574
src/rust/slide_obj.rs
View file

@ -1,9 +1,5 @@
#[cxx_qt::bridge] #[cxx_qt::bridge]
mod slide_obj { mod slide_obj {
// use cxx_qt_lib::QVariantValue;
// use std::path::Path;
// use std::task::Context;
unsafe extern "C++" { unsafe extern "C++" {
include!("cxx-qt-lib/qstring.h"); include!("cxx-qt-lib/qstring.h");
type QString = cxx_qt_lib::QString; type QString = cxx_qt_lib::QString;
@ -14,294 +10,312 @@ mod slide_obj {
type QVariant = cxx_qt_lib::QVariant; type QVariant = cxx_qt_lib::QVariant;
} }
#[cxx_qt::qsignals(SlideObj)] unsafe extern "RustQt" {
pub enum Signals<'a> { #[qobject]
PlayingChanged { is_playing: &'a bool }, #[qml_element]
SlideIndexChanged { slide_index: &'a i32 }, #[qproperty(i32, slide_index)]
SlideSizeChanged { slide_size: &'a i32 }, #[qproperty(i32, slide_size)]
SlideChanged { slide: &'a i32 }, #[qproperty(i32, image_count)]
LoopChanged { looping: &'a bool }, #[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)] #[qsignal]
#[cxx_qt::qobject] fn playing_changed(
pub struct SlideObj { self: Pin<&mut SlideObj>,
#[qproperty] is_playing: bool,
slide_index: i32, );
#[qproperty] #[qsignal]
slide_size: i32, fn slide_index_changed(
#[qproperty] self: Pin<&mut SlideObj>,
image_count: i32, slide_index: i32,
#[qproperty] );
is_playing: bool, #[qsignal]
#[qproperty] fn slide_size_changed(
looping: bool, self: Pin<&mut SlideObj>,
#[qproperty] slide_size: i32,
text: QString, );
#[qproperty] #[qsignal]
ty: QString, fn slide_changed(self: Pin<&mut SlideObj>, slide: i32);
#[qproperty] #[qsignal]
audio: QString, fn loop_changed(self: Pin<&mut SlideObj>, looping: bool);
#[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] #[qinvokable]
pub fn change_slide( fn change_slide(
mut self: Pin<&mut Self>, self: Pin<&mut SlideObj>,
item: QMap_QString_QVariant, item: QMap_QString_QVariant,
index: i32, 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] #[qinvokable]
pub fn next( fn next(
mut self: Pin<&mut Self>, self: Pin<&mut SlideObj>,
next_item: QMap_QString_QVariant, next_item: QMap_QString_QVariant,
) -> bool { ) -> bool;
let new_id = self.as_ref().slide_index() + 1;
self.as_mut().change_slide(next_item, new_id);
true
}
#[qinvokable] #[qinvokable]
pub fn previous( fn previous(
mut self: Pin<&mut Self>, self: Pin<&mut SlideObj>,
prev_item: QMap_QString_QVariant, prev_item: QMap_QString_QVariant,
) -> bool { ) -> bool;
let new_id = self.as_ref().slide_index() - 1;
self.as_mut().change_slide(prev_item, new_id);
true
}
#[qinvokable] #[qinvokable]
pub fn play(mut self: Pin<&mut Self>) -> bool { fn play(self: Pin<&mut SlideObj>) -> bool;
self.as_mut().set_is_playing(true);
self.as_mut().emit_playing_changed(&true);
true
}
#[qinvokable] #[qinvokable]
pub fn pause(mut self: Pin<&mut Self>) -> bool { fn pause(self: Pin<&mut SlideObj>) -> bool;
self.as_mut().set_is_playing(false);
self.as_mut().emit_playing_changed(&false);
false
}
#[qinvokable] #[qinvokable]
pub fn play_pause(mut self: Pin<&mut Self>) -> bool { fn play_pause(self: Pin<&mut SlideObj>) -> 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),
} #[derive(Clone, Debug)]
self.as_mut().emit_playing_changed(&!playing); pub struct SlideObjectRust {
!playing 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
}
}