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

69
src/rust/file_helper.rs
View file

@ -2,10 +2,6 @@
// 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;
@ -15,16 +11,38 @@ 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;
#[qinvokable]
fn validate(self: Pin<&mut FileHelper>, file: QUrl) -> bool;
#[qinvokable]
pub fn save_file(self: Pin<&mut FileHelper>) -> QUrl;
#[qinvokable]
fn load_file(
self: Pin<&mut FileHelper>,
title: QString,
filter: QString,
) -> QUrl;
}
}
use rfd::FileDialog;
use std::path::Path;
use tracing::{debug, debug_span, error, info, instrument};
#[derive(Clone)]
#[cxx_qt::qobject]
pub struct FileHelper {
#[qproperty]
pub struct FileHelperRust {
name: QString,
#[qproperty]
file_path: QString,
}
impl Default for FileHelper {
impl Default for FileHelperRust {
fn default() -> Self {
Self {
name: QString::from(""),
@ -33,26 +51,7 @@ mod file_helper {
}
}
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]
pub fn load(self: Pin<&mut Self>, file: QUrl) -> Vec<String> {
println!("{file}");
vec!["hi".to_string()]
}
#[qinvokable]
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://");
@ -63,15 +62,13 @@ mod file_helper {
exists
}
None => {
let exists =
Path::new(&file.to_string()).exists();
let exists = Path::new(&file.to_string()).exists();
println!("{file} exists? {exists}");
exists
}
}
}
#[qinvokable]
pub fn save_file(self: Pin<&mut Self>) -> QUrl {
let file = FileDialog::new()
.set_file_name("NVTFC.pres")
@ -92,19 +89,16 @@ mod file_helper {
}
}
#[qinvokable]
pub fn load_file(
self: Pin<&mut Self>,
title: QString,
filter: QString,
) -> QUrl {
let video_filters = [
"mp4", "webm", "avi", "mkv", "MP4", "WEBM", "AVI",
"MKV",
"mp4", "webm", "avi", "mkv", "MP4", "WEBM", "AVI", "MKV",
];
let image_filters = [
"jpg", "png", "gif", "jpeg", "JPG", "PNG", "webp",
"gif",
"jpg", "png", "gif", "jpeg", "JPG", "PNG", "webp", "gif",
];
let audio_filters = ["mp3", "opus", "ogg", "flac", "wav"];
let title = title.to_string();
@ -138,4 +132,3 @@ mod file_helper {
}
}
}
}

160
src/rust/slide_obj.rs
View file

@ -1,9 +1,5 @@
#[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;
@ -14,55 +10,96 @@ mod slide_obj {
type QVariant = cxx_qt_lib::QVariant;
}
#[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 },
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;
#[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);
#[qinvokable]
fn change_slide(
self: Pin<&mut SlideObj>,
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;
}
}
#[derive(Clone, Debug)]
#[cxx_qt::qobject]
pub struct SlideObj {
#[qproperty]
pub struct SlideObjectRust {
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 {
impl Default for SlideObjectRust {
fn default() -> Self {
Self {
slide_index: 0,
@ -86,8 +123,7 @@ mod slide_obj {
}
}
impl qobject::SlideObj {
#[qinvokable]
impl ffi::SlideObjectRust {
pub fn change_slide(
mut self: Pin<&mut Self>,
item: QMap_QString_QVariant,
@ -134,12 +170,9 @@ mod slide_obj {
if let Some(image_background) =
image_background.value::<QString>()
{
if &image_background
!= self.as_ref().image_background()
{
if &image_background != self.as_ref().image_background() {
println!("image-bg: {image_background}");
self.as_mut()
.set_image_background(image_background);
self.as_mut().set_image_background(image_background);
}
} else {
println!("image-bg: empty");
@ -150,19 +183,16 @@ mod slide_obj {
if let Some(video_background) =
video_background.value::<QString>()
{
if &video_background
!= self.as_ref().video_background()
{
if &video_background != self.as_ref().video_background() {
println!("video-bg: {video_background}");
self.as_mut()
.set_video_background(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")),
);
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}");
@ -177,13 +207,9 @@ mod slide_obj {
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);
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");
@ -194,13 +220,9 @@ mod slide_obj {
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);
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");
@ -224,8 +246,7 @@ mod slide_obj {
println!("looping: {looping}");
self.as_mut().set_looping(looping);
let lp = looping;
self.as_mut()
.emit(Signals::LoopChanged { looping: &lp });
self.as_mut().loop_changed(&lp);
}
} else {
println!("looping: empty")
@ -258,12 +279,10 @@ mod slide_obj {
println!("New slide index = {}", int);
self.as_mut().set_slide_index(int);
};
self.as_mut()
.emit(Signals::SlideChanged { slide: &index });
self.as_mut().slide_changed(&index);
println!("## Slide End ##");
}
#[qinvokable]
pub fn next(
mut self: Pin<&mut Self>,
next_item: QMap_QString_QVariant,
@ -272,7 +291,6 @@ mod slide_obj {
self.as_mut().change_slide(next_item, new_id);
true
}
#[qinvokable]
pub fn previous(
mut self: Pin<&mut Self>,
prev_item: QMap_QString_QVariant,
@ -281,27 +299,23 @@ mod slide_obj {
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);
self.as_mut().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);
self.as_mut().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),
}
self.as_mut().emit_playing_changed(&!playing);
self.as_mut().playing_changed(&!playing);
!playing
}
}
}