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

making sure sql models are in lumina folder

Browse source
This commit is contained in:
Chris Cochrun 2023-09-13 14:58:13 -05:00
parent d65243a106
commit 4499d1a957
4 changed files with 732 additions and 238 deletions
Download patch file Download diff file Expand all files Collapse all files

121
src/rust/image_model.rs
View file

@ -10,9 +10,11 @@ mod image_model {
unsafe extern "C++" {
include!(< QAbstractListModel >);
include!("cxx-qt-lib/qhash.h");
type QHash_i32_QByteArray = cxx_qt_lib::QHash<cxx_qt_lib::QHashPair_i32_QByteArray>;
type QHash_i32_QByteArray =
cxx_qt_lib::QHash<cxx_qt_lib::QHashPair_i32_QByteArray>;
include!("cxx-qt-lib/qmap.h");
type QMap_QString_QVariant = cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
type QMap_QString_QVariant =
cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
include!("cxx-qt-lib/qvariant.h");
type QVariant = cxx_qt_lib::QVariant;
include!("cxx-qt-lib/qstring.h");
@ -106,22 +108,32 @@ mod image_model {
}
#[qinvokable]
pub fn remove_item(mut self: Pin<&mut Self>, index: i32) -> bool {
pub fn remove_item(
mut self: Pin<&mut Self>,
index: i32,
) -> bool {
if index < 0 || (index as usize) >= self.images().len() {
return false;
}
let db = &mut self.as_mut().get_db();
let image_id = self.images().get(index as usize).unwrap().id;
let image_id =
self.images().get(index as usize).unwrap().id;
let result = delete(images.filter(id.eq(image_id))).execute(db);
let result =
delete(images.filter(id.eq(image_id))).execute(db);
match result {
Ok(_i) => {
unsafe {
self.as_mut().begin_remove_rows(
&QModelIndex::default(),
index,
index,
);
self.as_mut()
.begin_remove_rows(&QModelIndex::default(), index, index);
self.as_mut().images_mut().remove(index as usize);
.images_mut()
.remove(index as usize);
self.as_mut().end_remove_rows();
}
println!("removed-item-at-index: {:?}", image_id);
@ -137,26 +149,32 @@ mod image_model {
fn get_db(self: Pin<&mut Self>) -> SqliteConnection {
let mut data = dirs::data_local_dir().unwrap();
data.push("librepresenter");
data.push("lumina");
data.push("library-db.sqlite3");
let mut db_url = String::from("sqlite://");
db_url.push_str(data.to_str().unwrap());
println!("DB: {:?}", db_url);
SqliteConnection::establish(&db_url)
.unwrap_or_else(|_| panic!("error connecting to {}", db_url))
SqliteConnection::establish(&db_url).unwrap_or_else(
|_| panic!("error connecting to {}", db_url),
)
}
#[qinvokable]
pub fn new_item(mut self: Pin<&mut Self>, url: QUrl) {
println!("LETS INSERT THIS SUCKER!");
let file_path = PathBuf::from(url.path().to_string());
let name = file_path.file_stem().unwrap().to_str().unwrap();
let name =
file_path.file_stem().unwrap().to_str().unwrap();
let image_id = self.rust().highest_id + 1;
let image_title = QString::from(name);
let image_path = url.to_qstring();
if self.as_mut().add_item(image_id, image_title, image_path) {
if self.as_mut().add_item(
image_id,
image_title,
image_path,
) {
println!("filename: {:?}", name);
self.as_mut().set_highest_id(image_id);
} else {
@ -205,18 +223,30 @@ mod image_model {
let index = self.as_ref().images().len() as i32;
println!("{:?}", image);
unsafe {
self.as_mut()
.begin_insert_rows(&QModelIndex::default(), index, index);
self.as_mut().begin_insert_rows(
&QModelIndex::default(),
index,
index,
);
self.as_mut().images_mut().push(image);
self.as_mut().end_insert_rows();
}
}
#[qinvokable]
pub fn update_title(mut self: Pin<&mut Self>, index: i32, updated_title: QString) -> bool {
pub fn update_title(
mut self: Pin<&mut Self>,
index: i32,
updated_title: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::TitleRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::TitleRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(images.filter(id.eq(index)))
@ -233,8 +263,11 @@ mod image_model {
image.title = updated_title.clone();
println!("rust-title: {:?}", image.title);
}
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
}
Err(_e) => false,
@ -248,8 +281,13 @@ mod image_model {
updated_file_path: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::PathRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::PathRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(images.filter(id.eq(index)))
@ -266,8 +304,11 @@ mod image_model {
image.path = updated_file_path.clone();
println!("rust-title: {:?}", image.path);
}
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
}
Err(_e) => false,
@ -275,7 +316,10 @@ mod image_model {
}
#[qinvokable]
pub fn get_item(self: Pin<&mut Self>, index: i32) -> QMap_QString_QVariant {
pub fn get_item(
self: Pin<&mut Self>,
index: i32,
) -> QMap_QString_QVariant {
println!("{index}");
let mut qvariantmap = QMap_QString_QVariant::default();
let idx = self.index(index, 0, &QModelIndex::default());
@ -284,7 +328,9 @@ mod image_model {
}
let role_names = self.as_ref().role_names();
let role_names_iter = role_names.iter();
if let Some(image) = self.rust().images.get(index as usize) {
if let Some(image) =
self.rust().images.get(index as usize)
{
for i in role_names_iter {
qvariantmap.insert(
QString::from(&i.1.to_string()),
@ -314,7 +360,9 @@ mod image_model {
first: i32,
last: i32,
);
unsafe fn end_insert_rows(self: Pin<&mut qobject::ImageModel>);
unsafe fn end_insert_rows(
self: Pin<&mut qobject::ImageModel>,
);
unsafe fn begin_remove_rows(
self: Pin<&mut qobject::ImageModel>,
@ -322,16 +370,25 @@ mod image_model {
first: i32,
last: i32,
);
unsafe fn end_remove_rows(self: Pin<&mut qobject::ImageModel>);
unsafe fn end_remove_rows(
self: Pin<&mut qobject::ImageModel>,
);
unsafe fn begin_reset_model(self: Pin<&mut qobject::ImageModel>);
unsafe fn end_reset_model(self: Pin<&mut qobject::ImageModel>);
unsafe fn begin_reset_model(
self: Pin<&mut qobject::ImageModel>,
);
unsafe fn end_reset_model(
self: Pin<&mut qobject::ImageModel>,
);
}
#[cxx_qt::inherit]
unsafe extern "C++" {
#[cxx_name = "canFetchMore"]
fn base_can_fetch_more(self: &qobject::ImageModel, parent: &QModelIndex) -> bool;
fn base_can_fetch_more(
self: &qobject::ImageModel,
parent: &QModelIndex,
) -> bool;
fn index(
self: &qobject::ImageModel,
@ -345,7 +402,9 @@ mod image_model {
impl qobject::ImageModel {
#[qinvokable(cxx_override)]
fn data(&self, index: &QModelIndex, role: i32) -> QVariant {
if let Some(image) = self.images().get(index.row() as usize) {
if let Some(image) =
self.images().get(index.row() as usize)
{
return match role {
0 => QVariant::from(&image.id),
1 => QVariant::from(&image.title),

181
src/rust/presentation_model.rs
View file

@ -12,9 +12,11 @@ mod presentation_model {
unsafe extern "C++" {
include!(< QAbstractListModel >);
include!("cxx-qt-lib/qhash.h");
type QHash_i32_QByteArray = cxx_qt_lib::QHash<cxx_qt_lib::QHashPair_i32_QByteArray>;
type QHash_i32_QByteArray =
cxx_qt_lib::QHash<cxx_qt_lib::QHashPair_i32_QByteArray>;
include!("cxx-qt-lib/qmap.h");
type QMap_QString_QVariant = cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
type QMap_QString_QVariant =
cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
include!("cxx-qt-lib/qvariant.h");
type QVariant = cxx_qt_lib::QVariant;
include!("cxx-qt-lib/qstring.h");
@ -115,26 +117,45 @@ mod presentation_model {
}
#[qinvokable]
pub fn remove_item(mut self: Pin<&mut Self>, index: i32) -> bool {
if index < 0 || (index as usize) >= self.presentations().len() {
pub fn remove_item(
mut self: Pin<&mut Self>,
index: i32,
) -> bool {
if index < 0
|| (index as usize) >= self.presentations().len()
{
return false;
}
let db = &mut self.as_mut().get_db();
let presentation_id = self.presentations().get(index as usize).unwrap().id;
let presentation_id =
self.presentations().get(index as usize).unwrap().id;
let result = delete(presentations.filter(id.eq(presentation_id))).execute(db);
let result =
delete(presentations.filter(id.eq(presentation_id)))
.execute(db);
match result {
Ok(_i) => {
unsafe {
self.as_mut().begin_remove_rows(
&QModelIndex::default(),
index,
index,
);
self.as_mut()
.begin_remove_rows(&QModelIndex::default(), index, index);
self.as_mut().presentations_mut().remove(index as usize);
.presentations_mut()
.remove(index as usize);
self.as_mut().end_remove_rows();
}
println!("removed-item-at-index: {:?}", presentation_id);
println!("new-Vec: {:?}", self.as_mut().presentations());
println!(
"removed-item-at-index: {:?}",
presentation_id
);
println!(
"new-Vec: {:?}",
self.as_mut().presentations()
);
true
}
Err(_e) => {
@ -146,26 +167,33 @@ mod presentation_model {
fn get_db(self: Pin<&mut Self>) -> SqliteConnection {
let mut data = dirs::data_local_dir().unwrap();
data.push("librepresenter");
data.push("lumina");
data.push("library-db.sqlite3");
let mut db_url = String::from("sqlite://");
db_url.push_str(data.to_str().unwrap());
println!("DB: {:?}", db_url);
SqliteConnection::establish(&db_url)
.unwrap_or_else(|_| panic!("error connecting to {}", db_url))
SqliteConnection::establish(&db_url).unwrap_or_else(
|_| panic!("error connecting to {}", db_url),
)
}
#[qinvokable]
pub fn new_item(mut self: Pin<&mut Self>, url: QUrl, new_page_count: i32) {
pub fn new_item(
mut self: Pin<&mut Self>,
url: QUrl,
new_page_count: i32,
) {
println!("LETS INSERT THIS SUCKER!");
let file_path = PathBuf::from(url.path().to_string());
let name = file_path.file_stem().unwrap().to_str().unwrap();
let name =
file_path.file_stem().unwrap().to_str().unwrap();
let presentation_id = self.rust().highest_id + 1;
let presentation_title = QString::from(name);
let presentation_path = url.to_qstring();
println!("{:?}", file_path.extension().unwrap());
let presentation_html = file_path.extension().unwrap() == std::ffi::OsStr::new(".html");
let presentation_html = file_path.extension().unwrap()
== std::ffi::OsStr::new(".html");
if self.as_mut().add_item(
presentation_id,
@ -194,8 +222,12 @@ mod presentation_model {
// println!("{:?}", db);
let mut actual_page_count = new_page_count;
if presentation_html {
let actual_path = presentation_path.clone().to_string();
actual_page_count = reveal_js::count_slides_and_fragments(actual_path.trim());
let actual_path =
presentation_path.clone().to_string();
actual_page_count =
reveal_js::count_slides_and_fragments(
actual_path.trim(),
);
}
let presentation = self::Presentation {
@ -231,19 +263,28 @@ mod presentation_model {
}
}
fn add_presentation(mut self: Pin<&mut Self>, presentation: self::Presentation) {
fn add_presentation(
mut self: Pin<&mut Self>,
presentation: self::Presentation,
) {
let index = self.as_ref().presentations().len() as i32;
println!("{:?}", presentation);
unsafe {
self.as_mut()
.begin_insert_rows(&QModelIndex::default(), index, index);
self.as_mut().begin_insert_rows(
&QModelIndex::default(),
index,
index,
);
self.as_mut().presentations_mut().push(presentation);
self.as_mut().end_insert_rows();
}
}
#[qinvokable]
pub fn get_item(self: Pin<&mut Self>, index: i32) -> QMap_QString_QVariant {
pub fn get_item(
self: Pin<&mut Self>,
index: i32,
) -> QMap_QString_QVariant {
println!("{index}");
let mut qvariantmap = QMap_QString_QVariant::default();
let idx = self.index(index, 0, &QModelIndex::default());
@ -252,7 +293,9 @@ mod presentation_model {
}
let role_names = self.as_ref().role_names();
let role_names_iter = role_names.iter();
if let Some(presentation) = self.rust().presentations.get(index as usize) {
if let Some(presentation) =
self.rust().presentations.get(index as usize)
{
for i in role_names_iter {
qvariantmap.insert(
QString::from(&i.1.to_string()),
@ -264,10 +307,19 @@ mod presentation_model {
}
#[qinvokable]
pub fn update_title(mut self: Pin<&mut Self>, index: i32, updated_title: QString) -> bool {
pub fn update_title(
mut self: Pin<&mut Self>,
index: i32,
updated_title: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::TitleRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::TitleRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(presentations.filter(id.eq(index)))
@ -281,12 +333,19 @@ mod presentation_model {
.iter_mut()
.filter(|x| x.id == index)
{
presentation.title = updated_title.to_string();
println!("rust-title: {:?}", presentation.title);
presentation.title =
updated_title.to_string();
println!(
"rust-title: {:?}",
presentation.title
);
}
// TODO this seems to not be updating in the actual list
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
// self.as_mut().emit_title_changed();
println!("rust-title: {:?}", updated_title);
true
@ -302,8 +361,13 @@ mod presentation_model {
updated_page_count: i32,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::PageCountRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::PageCountRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(presentations.filter(id.eq(index)))
@ -318,13 +382,22 @@ mod presentation_model {
.filter(|x| x.id == index)
{
presentation.page_count = updated_page_count;
println!("rust-page_count: {:?}", presentation.page_count);
println!(
"rust-page_count: {:?}",
presentation.page_count
);
}
// TODO this seems to not be updating in the actual list
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
// self.as_mut().emit_page_count_changed();
println!("rust-page_count: {:?}", updated_page_count);
println!(
"rust-page_count: {:?}",
updated_page_count
);
true
}
Err(_e) => false,
@ -352,7 +425,9 @@ mod presentation_model {
first: i32,
last: i32,
);
unsafe fn end_insert_rows(self: Pin<&mut qobject::PresentationModel>);
unsafe fn end_insert_rows(
self: Pin<&mut qobject::PresentationModel>,
);
unsafe fn begin_remove_rows(
self: Pin<&mut qobject::PresentationModel>,
@ -360,16 +435,25 @@ mod presentation_model {
first: i32,
last: i32,
);
unsafe fn end_remove_rows(self: Pin<&mut qobject::PresentationModel>);
unsafe fn end_remove_rows(
self: Pin<&mut qobject::PresentationModel>,
);
unsafe fn begin_reset_model(self: Pin<&mut qobject::PresentationModel>);
unsafe fn end_reset_model(self: Pin<&mut qobject::PresentationModel>);
unsafe fn begin_reset_model(
self: Pin<&mut qobject::PresentationModel>,
);
unsafe fn end_reset_model(
self: Pin<&mut qobject::PresentationModel>,
);
}
#[cxx_qt::inherit]
unsafe extern "C++" {
#[cxx_name = "canFetchMore"]
fn base_can_fetch_more(self: &qobject::PresentationModel, parent: &QModelIndex) -> bool;
fn base_can_fetch_more(
self: &qobject::PresentationModel,
parent: &QModelIndex,
) -> bool;
fn index(
self: &qobject::PresentationModel,
@ -383,11 +467,17 @@ mod presentation_model {
impl qobject::PresentationModel {
#[qinvokable(cxx_override)]
fn data(&self, index: &QModelIndex, role: i32) -> QVariant {
if let Some(presentation) = self.presentations().get(index.row() as usize) {
if let Some(presentation) =
self.presentations().get(index.row() as usize)
{
return match role {
0 => QVariant::from(&presentation.id),
1 => QVariant::from(&QString::from(&presentation.title)),
2 => QVariant::from(&QString::from(&presentation.path)),
1 => QVariant::from(&QString::from(
&presentation.title,
)),
2 => QVariant::from(&QString::from(
&presentation.path,
)),
3 => QVariant::from(&presentation.html),
4 => QVariant::from(&presentation.page_count),
_ => QVariant::default(),
@ -410,7 +500,8 @@ mod presentation_model {
roles.insert(1, cxx_qt_lib::QByteArray::from("title"));
roles.insert(2, cxx_qt_lib::QByteArray::from("filePath"));
roles.insert(3, cxx_qt_lib::QByteArray::from("html"));
roles.insert(4, cxx_qt_lib::QByteArray::from("pageCount"));
roles
.insert(4, cxx_qt_lib::QByteArray::from("pageCount"));
roles
}

477
src/rust/song_model.rs
View file

@ -11,9 +11,11 @@ mod song_model {
unsafe extern "C++" {
include!(< QAbstractListModel >);
include!("cxx-qt-lib/qhash.h");
type QHash_i32_QByteArray = cxx_qt_lib::QHash<cxx_qt_lib::QHashPair_i32_QByteArray>;
type QHash_i32_QByteArray =
cxx_qt_lib::QHash<cxx_qt_lib::QHashPair_i32_QByteArray>;
include!("cxx-qt-lib/qmap.h");
type QMap_QString_QVariant = cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
type QMap_QString_QVariant =
cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
include!("cxx-qt-lib/qvariant.h");
type QVariant = cxx_qt_lib::QVariant;
include!("cxx-qt-lib/qstring.h");
@ -107,7 +109,10 @@ mod song_model {
for song in results {
println!("{}", song.title);
println!("{}", song.id);
println!("{}", song.background.clone().unwrap_or_default());
println!(
"{}",
song.background.clone().unwrap_or_default()
);
println!("--------------");
if self.as_mut().highest_id() < &song.id {
self.as_mut().set_highest_id(song.id);
@ -122,9 +127,15 @@ mod song_model {
audio: song.audio.unwrap_or_default(),
verse_order: song.verse_order.unwrap_or_default(),
background: song.background.unwrap_or_default(),
background_type: song.background_type.unwrap_or_default(),
horizontal_text_alignment: song.horizontal_text_alignment.unwrap_or_default(),
vertical_text_alignment: song.vertical_text_alignment.unwrap_or_default(),
background_type: song
.background_type
.unwrap_or_default(),
horizontal_text_alignment: song
.horizontal_text_alignment
.unwrap_or_default(),
vertical_text_alignment: song
.vertical_text_alignment
.unwrap_or_default(),
font: song.font.unwrap_or_default(),
font_size: song.font_size.unwrap_or_default(),
};
@ -137,22 +148,32 @@ mod song_model {
}
#[qinvokable]
pub fn remove_item(mut self: Pin<&mut Self>, index: i32) -> bool {
pub fn remove_item(
mut self: Pin<&mut Self>,
index: i32,
) -> bool {
if index < 0 || (index as usize) >= self.songs().len() {
return false;
}
let db = &mut self.as_mut().get_db();
let song_id = self.songs().get(index as usize).unwrap().id;
let song_id =
self.songs().get(index as usize).unwrap().id;
let result = delete(songs.filter(id.eq(song_id))).execute(db);
let result =
delete(songs.filter(id.eq(song_id))).execute(db);
match result {
Ok(_i) => {
unsafe {
self.as_mut().begin_remove_rows(
&QModelIndex::default(),
index,
index,
);
self.as_mut()
.begin_remove_rows(&QModelIndex::default(), index, index);
self.as_mut().songs_mut().remove(index as usize);
.songs_mut()
.remove(index as usize);
self.as_mut().end_remove_rows();
}
println!("removed-item-at-index: {:?}", song_id);
@ -168,14 +189,15 @@ mod song_model {
fn get_db(self: Pin<&mut Self>) -> SqliteConnection {
let mut data = dirs::data_local_dir().unwrap();
data.push("librepresenter");
data.push("lumina");
data.push("library-db.sqlite3");
let mut db_url = String::from("sqlite://");
db_url.push_str(data.to_str().unwrap());
println!("DB: {:?}", db_url);
SqliteConnection::establish(&db_url)
.unwrap_or_else(|_| panic!("error connecting to {}", db_url))
SqliteConnection::establish(&db_url).unwrap_or_else(
|_| panic!("error connecting to {}", db_url),
)
}
#[qinvokable]
@ -201,8 +223,10 @@ mod song_model {
verse_order.eq(&song.verse_order),
background.eq(&song.background),
background_type.eq(&song.background_type),
horizontal_text_alignment.eq(&song.horizontal_text_alignment),
vertical_text_alignment.eq(&song.vertical_text_alignment),
horizontal_text_alignment
.eq(&song.horizontal_text_alignment),
vertical_text_alignment
.eq(&song.vertical_text_alignment),
font.eq(&song.font),
font_size.eq(&song.font_size),
))
@ -226,18 +250,30 @@ mod song_model {
let index = self.as_ref().songs().len() as i32;
println!("{:?}", song);
unsafe {
self.as_mut()
.begin_insert_rows(&QModelIndex::default(), index, index);
self.as_mut().begin_insert_rows(
&QModelIndex::default(),
index,
index,
);
self.as_mut().songs_mut().push(song);
self.as_mut().end_insert_rows();
}
}
#[qinvokable]
pub fn update_title(mut self: Pin<&mut Self>, index: i32, updated_title: QString) -> bool {
pub fn update_title(
mut self: Pin<&mut Self>,
index: i32,
updated_title: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::TitleRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::TitleRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -245,7 +281,11 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.title = updated_title.to_string();
self.as_mut().emit(Signals::DataChanged {
top_left: &model_index,
@ -269,8 +309,13 @@ mod song_model {
updated_lyrics: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::LyricsRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::LyricsRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -278,10 +323,17 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.lyrics = updated_lyrics.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -298,8 +350,13 @@ mod song_model {
updated_author: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::AuthorRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::AuthorRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -307,10 +364,17 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.author = updated_author.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -321,10 +385,19 @@ mod song_model {
}
#[qinvokable]
pub fn update_audio(mut self: Pin<&mut Self>, index: i32, updated_audio: QString) -> bool {
pub fn update_audio(
mut self: Pin<&mut Self>,
index: i32,
updated_audio: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::AudioRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::AudioRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -332,10 +405,17 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.audio = updated_audio.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -346,10 +426,19 @@ mod song_model {
}
#[qinvokable]
pub fn update_ccli(mut self: Pin<&mut Self>, index: i32, updated_ccli: QString) -> bool {
pub fn update_ccli(
mut self: Pin<&mut Self>,
index: i32,
updated_ccli: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::CcliRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::CcliRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -357,10 +446,17 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.ccli = updated_ccli.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -377,8 +473,13 @@ mod song_model {
updated_verse_order: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::VerseOrderRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::VerseOrderRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -386,10 +487,18 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
song.verse_order = updated_verse_order.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.verse_order =
updated_verse_order.to_string();
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -406,8 +515,13 @@ mod song_model {
updated_background: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::BackgroundRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::BackgroundRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -415,10 +529,18 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
song.background = updated_background.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.background =
updated_background.to_string();
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -435,19 +557,36 @@ mod song_model {
updated_background_type: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::BackgroundTypeRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles.append(
self.as_ref().get_role(Role::BackgroundTypeRole),
);
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
.set(background_type.eq(updated_background_type.to_string()))
.set(
background_type
.eq(updated_background_type.to_string()),
)
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
song.background_type = updated_background_type.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.background_type =
updated_background_type.to_string();
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -464,20 +603,37 @@ mod song_model {
updated_horizontal_text_alignment: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::HorizontalTextAlignmentRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles.append(
self.as_ref()
.get_role(Role::HorizontalTextAlignmentRole),
);
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
.set(horizontal_text_alignment.eq(updated_horizontal_text_alignment.to_string()))
.set(horizontal_text_alignment.eq(
updated_horizontal_text_alignment.to_string(),
))
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.horizontal_text_alignment =
updated_horizontal_text_alignment.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
updated_horizontal_text_alignment
.to_string();
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -494,19 +650,38 @@ mod song_model {
updated_vertical_text_alignment: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::VerticalTextAlignmentRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles.append(
self.as_ref()
.get_role(Role::VerticalTextAlignmentRole),
);
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
.set(vertical_text_alignment.eq(updated_vertical_text_alignment.to_string()))
let result =
update(songs.filter(id.eq(index)))
.set(vertical_text_alignment.eq(
updated_vertical_text_alignment.to_string(),
))
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
song.vertical_text_alignment = updated_vertical_text_alignment.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.vertical_text_alignment =
updated_vertical_text_alignment
.to_string();
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -517,10 +692,19 @@ mod song_model {
}
#[qinvokable]
pub fn update_font(mut self: Pin<&mut Self>, index: i32, updated_font: QString) -> bool {
pub fn update_font(
mut self: Pin<&mut Self>,
index: i32,
updated_font: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::FontRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::FontRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -528,10 +712,17 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.font = updated_font.to_string();
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -548,8 +739,13 @@ mod song_model {
updated_font_size: i32,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::FontSizeRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::FontSizeRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(songs.filter(id.eq(index)))
@ -557,10 +753,17 @@ mod song_model {
.execute(db);
match result {
Ok(_i) => {
if let Some(song) = self.as_mut().songs_mut().get_mut(index as usize) {
if let Some(song) = self
.as_mut()
.songs_mut()
.get_mut(index as usize)
{
song.font_size = updated_font_size;
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
true
} else {
false
@ -571,7 +774,10 @@ mod song_model {
}
#[qinvokable]
pub fn get_item(self: Pin<&mut Self>, index: i32) -> QMap_QString_QVariant {
pub fn get_item(
self: Pin<&mut Self>,
index: i32,
) -> QMap_QString_QVariant {
println!("{index}");
let mut qvariantmap = QMap_QString_QVariant::default();
let idx = self.index(index, 0, &QModelIndex::default());
@ -580,7 +786,8 @@ mod song_model {
}
let role_names = self.as_ref().role_names();
let role_names_iter = role_names.iter();
if let Some(song) = self.rust().songs.get(index as usize) {
if let Some(song) = self.rust().songs.get(index as usize)
{
for i in role_names_iter {
qvariantmap.insert(
QString::from(&i.1.to_string()),
@ -592,25 +799,32 @@ mod song_model {
}
#[qinvokable]
pub fn get_lyric_list(mut self: Pin<&mut Self>, index: i32) -> QStringList {
pub fn get_lyric_list(
mut self: Pin<&mut Self>,
index: i32,
) -> QStringList {
println!("LYRIC_LIST: {index}");
let mut lyric_list = QList_QString::default();
let idx = self.index(index, 0, &QModelIndex::default());
if !idx.is_valid() {
return QStringList::default();
}
if let Some(song) = self.rust().songs.get(index as usize) {
if let Some(song) = self.rust().songs.get(index as usize)
{
if song.lyrics.is_empty() {
return QStringList::default();
}
let raw_lyrics = song.lyrics.clone();
println!("raw-lyrics: {:?}", raw_lyrics);
let vorder: Vec<&str> = song.verse_order.split(' ').collect();
let vorder: Vec<&str> =
song.verse_order.split(' ').collect();
let keywords = vec![
"Verse 1", "Verse 2", "Verse 3", "Verse 4", "Verse 5", "Verse 6", "Verse 7",
"Verse 8", "Chorus 1", "Chorus 2", "Chorus 3", "Chorus 4", "Bridge 1",
"Bridge 2", "Bridge 3", "Bridge 4", "Intro 1", "Intro 2", "Ending 1",
"Ending 2", "Other 1", "Other 2", "Other 3", "Other 4",
"Verse 1", "Verse 2", "Verse 3", "Verse 4",
"Verse 5", "Verse 6", "Verse 7", "Verse 8",
"Chorus 1", "Chorus 2", "Chorus 3", "Chorus 4",
"Bridge 1", "Bridge 2", "Bridge 3", "Bridge 4",
"Intro 1", "Intro 2", "Ending 1", "Ending 2",
"Other 1", "Other 2", "Other 3", "Other 4",
];
let mut first_item = true;
@ -649,7 +863,9 @@ mod song_model {
"verse: {:?}, beginning: {:?}, end: {:?}, word: {:?}",
verse, beg_verse, end_verse, word
);
if word.starts_with(beg_verse) && word.ends_with(end_verse) {
if word.starts_with(beg_verse)
&& word.ends_with(end_verse)
{
verse_name = word;
println!("TITLE: {verse_name}");
continue;
@ -657,12 +873,14 @@ mod song_model {
}
if let Some(lyric) = lyric_map.get(verse_name) {
if lyric.contains("\n\n") {
let split_lyrics: Vec<&str> = lyric.split("\n\n").collect();
let split_lyrics: Vec<&str> =
lyric.split("\n\n").collect();
for lyric in split_lyrics {
if lyric == "" {
continue;
}
lyric_list.append(QString::from(lyric));
lyric_list
.append(QString::from(lyric));
}
continue;
}
@ -717,14 +935,19 @@ mod song_model {
);
unsafe fn end_remove_rows(self: Pin<&mut qobject::SongModel>);
unsafe fn begin_reset_model(self: Pin<&mut qobject::SongModel>);
unsafe fn begin_reset_model(
self: Pin<&mut qobject::SongModel>,
);
unsafe fn end_reset_model(self: Pin<&mut qobject::SongModel>);
}
#[cxx_qt::inherit]
unsafe extern "C++" {
#[cxx_name = "canFetchMore"]
fn base_can_fetch_more(self: &qobject::SongModel, parent: &QModelIndex) -> bool;
fn base_can_fetch_more(
self: &qobject::SongModel,
parent: &QModelIndex,
) -> bool;
fn index(
self: &qobject::SongModel,
@ -738,7 +961,8 @@ mod song_model {
impl qobject::SongModel {
#[qinvokable(cxx_override)]
fn data(&self, index: &QModelIndex, role: i32) -> QVariant {
if let Some(song) = self.songs().get(index.row() as usize) {
if let Some(song) = self.songs().get(index.row() as usize)
{
return match role {
0 => QVariant::from(&song.id),
1 => QVariant::from(&QString::from(&song.title)),
@ -746,11 +970,21 @@ mod song_model {
3 => QVariant::from(&QString::from(&song.author)),
4 => QVariant::from(&QString::from(&song.ccli)),
5 => QVariant::from(&QString::from(&song.audio)),
6 => QVariant::from(&QString::from(&song.verse_order)),
7 => QVariant::from(&QString::from(&song.background)),
8 => QVariant::from(&QString::from(&song.background_type)),
9 => QVariant::from(&QString::from(&song.horizontal_text_alignment)),
10 => QVariant::from(&QString::from(&song.vertical_text_alignment)),
6 => QVariant::from(&QString::from(
&song.verse_order,
)),
7 => QVariant::from(&QString::from(
&song.background,
)),
8 => QVariant::from(&QString::from(
&song.background_type,
)),
9 => QVariant::from(&QString::from(
&song.horizontal_text_alignment,
)),
10 => QVariant::from(&QString::from(
&song.vertical_text_alignment,
)),
11 => QVariant::from(&QString::from(&song.font)),
12 => QVariant::from(&song.font_size),
_ => QVariant::default(),
@ -776,12 +1010,27 @@ mod song_model {
roles.insert(4, cxx_qt_lib::QByteArray::from("ccli"));
roles.insert(5, cxx_qt_lib::QByteArray::from("audio"));
roles.insert(6, cxx_qt_lib::QByteArray::from("vorder"));
roles.insert(7, cxx_qt_lib::QByteArray::from("background"));
roles.insert(8, cxx_qt_lib::QByteArray::from("backgroundType"));
roles.insert(9, cxx_qt_lib::QByteArray::from("horizontalTextAlignment"));
roles.insert(10, cxx_qt_lib::QByteArray::from("verticalTextAlignment"));
roles.insert(
7,
cxx_qt_lib::QByteArray::from("background"),
);
roles.insert(
8,
cxx_qt_lib::QByteArray::from("backgroundType"),
);
roles.insert(
9,
cxx_qt_lib::QByteArray::from(
"horizontalTextAlignment",
),
);
roles.insert(
10,
cxx_qt_lib::QByteArray::from("verticalTextAlignment"),
);
roles.insert(11, cxx_qt_lib::QByteArray::from("font"));
roles.insert(12, cxx_qt_lib::QByteArray::from("fontSize"));
roles
.insert(12, cxx_qt_lib::QByteArray::from("fontSize"));
roles
}

189
src/rust/video_model.rs
View file

@ -10,9 +10,11 @@ mod video_model {
unsafe extern "C++" {
include!(< QAbstractListModel >);
include!("cxx-qt-lib/qhash.h");
type QHash_i32_QByteArray = cxx_qt_lib::QHash<cxx_qt_lib::QHashPair_i32_QByteArray>;
type QHash_i32_QByteArray =
cxx_qt_lib::QHash<cxx_qt_lib::QHashPair_i32_QByteArray>;
include!("cxx-qt-lib/qmap.h");
type QMap_QString_QVariant = cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
type QMap_QString_QVariant =
cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
include!("cxx-qt-lib/qvariant.h");
type QVariant = cxx_qt_lib::QVariant;
include!("cxx-qt-lib/qstring.h");
@ -111,22 +113,32 @@ mod video_model {
}
#[qinvokable]
pub fn remove_item(mut self: Pin<&mut Self>, index: i32) -> bool {
pub fn remove_item(
mut self: Pin<&mut Self>,
index: i32,
) -> bool {
if index < 0 || (index as usize) >= self.videos().len() {
return false;
}
let db = &mut self.as_mut().get_db();
let video_id = self.videos().get(index as usize).unwrap().id;
let video_id =
self.videos().get(index as usize).unwrap().id;
let result = delete(videos.filter(id.eq(video_id))).execute(db);
let result =
delete(videos.filter(id.eq(video_id))).execute(db);
match result {
Ok(_i) => {
unsafe {
self.as_mut().begin_remove_rows(
&QModelIndex::default(),
index,
index,
);
self.as_mut()
.begin_remove_rows(&QModelIndex::default(), index, index);
self.as_mut().videos_mut().remove(index as usize);
.videos_mut()
.remove(index as usize);
self.as_mut().end_remove_rows();
}
println!("removed-item-at-index: {:?}", video_id);
@ -142,26 +154,32 @@ mod video_model {
fn get_db(self: Pin<&mut Self>) -> SqliteConnection {
let mut data = dirs::data_local_dir().unwrap();
data.push("librepresenter");
data.push("lumina");
data.push("library-db.sqlite3");
let mut db_url = String::from("sqlite://");
db_url.push_str(data.to_str().unwrap());
println!("DB: {:?}", db_url);
SqliteConnection::establish(&db_url)
.unwrap_or_else(|_| panic!("error connecting to {}", db_url))
SqliteConnection::establish(&db_url).unwrap_or_else(
|_| panic!("error connecting to {}", db_url),
)
}
#[qinvokable]
pub fn new_item(mut self: Pin<&mut Self>, url: QUrl) {
println!("LETS INSERT THIS SUCKER!");
let file_path = PathBuf::from(url.path().to_string());
let name = file_path.file_stem().unwrap().to_str().unwrap();
let name =
file_path.file_stem().unwrap().to_str().unwrap();
let video_id = self.rust().highest_id + 1;
let video_title = QString::from(name);
let video_path = url.to_qstring();
if self.as_mut().add_item(video_id, video_title, video_path) {
if self.as_mut().add_item(
video_id,
video_title,
video_path,
) {
println!("filename: {:?}", name);
self.as_mut().set_highest_id(video_id);
} else {
@ -219,15 +237,21 @@ mod video_model {
let index = self.as_ref().videos().len() as i32;
println!("{:?}", video);
unsafe {
self.as_mut()
.begin_insert_rows(&QModelIndex::default(), index, index);
self.as_mut().begin_insert_rows(
&QModelIndex::default(),
index,
index,
);
self.as_mut().videos_mut().push(video);
self.as_mut().end_insert_rows();
}
}
#[qinvokable]
pub fn get_item(self: Pin<&mut Self>, index: i32) -> QMap_QString_QVariant {
pub fn get_item(
self: Pin<&mut Self>,
index: i32,
) -> QMap_QString_QVariant {
println!("{index}");
let mut qvariantmap = QMap_QString_QVariant::default();
let idx = self.index(index, 0, &QModelIndex::default());
@ -236,7 +260,9 @@ mod video_model {
}
let role_names = self.as_ref().role_names();
let role_names_iter = role_names.iter();
if let Some(video) = self.rust().videos.get(index as usize) {
if let Some(video) =
self.rust().videos.get(index as usize)
{
for i in role_names_iter {
qvariantmap.insert(
QString::from(&i.1.to_string()),
@ -261,10 +287,19 @@ mod video_model {
}
#[qinvokable]
pub fn update_loop(mut self: Pin<&mut Self>, index: i32, loop_value: bool) -> bool {
pub fn update_loop(
mut self: Pin<&mut Self>,
index: i32,
loop_value: bool,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::LoopingRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::LoopingRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
println!("rust-video: {:?}", index);
println!("rust-loop: {:?}", loop_value);
@ -283,8 +318,11 @@ mod video_model {
video.looping = loop_value.clone();
println!("rust-video: {:?}", video.title);
}
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
println!("rust-looping: {:?}", loop_value);
true
}
@ -299,8 +337,13 @@ mod video_model {
updated_end_time: f32,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::EndTimeRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::EndTimeRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(videos.filter(id.eq(index)))
@ -316,8 +359,11 @@ mod video_model {
{
video.end_time = updated_end_time.clone();
}
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
println!("rust-end-time: {:?}", updated_end_time);
true
}
@ -332,8 +378,13 @@ mod video_model {
updated_start_time: f32,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::StartTimeRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::StartTimeRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(videos.filter(id.eq(index)))
@ -349,9 +400,15 @@ mod video_model {
{
video.start_time = updated_start_time.clone();
}
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
println!("rust-start-time: {:?}", updated_start_time);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
println!(
"rust-start-time: {:?}",
updated_start_time
);
true
}
Err(_e) => false,
@ -359,10 +416,19 @@ mod video_model {
}
#[qinvokable]
pub fn update_title(mut self: Pin<&mut Self>, index: i32, updated_title: QString) -> bool {
pub fn update_title(
mut self: Pin<&mut Self>,
index: i32,
updated_title: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::TitleRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::TitleRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(videos.filter(id.eq(index)))
@ -380,8 +446,11 @@ mod video_model {
println!("rust-title: {:?}", video.title);
}
// TODO this seems to not be updating in the actual list
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
// self.as_mut().emit_title_changed();
println!("rust-title: {:?}", updated_title);
true
@ -391,10 +460,19 @@ mod video_model {
}
#[qinvokable]
pub fn update_path(mut self: Pin<&mut Self>, index: i32, updated_path: QString) -> bool {
pub fn update_path(
mut self: Pin<&mut Self>,
index: i32,
updated_path: QString,
) -> bool {
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.as_ref().get_role(Role::PathRole));
let model_index = &self.as_ref().index(index, 0, &QModelIndex::default());
vector_roles
.append(self.as_ref().get_role(Role::PathRole));
let model_index = &self.as_ref().index(
index,
0,
&QModelIndex::default(),
);
let db = &mut self.as_mut().get_db();
let result = update(videos.filter(id.eq(index)))
@ -411,8 +489,11 @@ mod video_model {
video.path = updated_path.clone();
println!("rust-title: {:?}", video.title);
}
self.as_mut()
.emit_data_changed(model_index, model_index, &vector_roles);
self.as_mut().emit_data_changed(
model_index,
model_index,
&vector_roles,
);
println!("rust-path: {:?}", updated_path);
true
}
@ -430,7 +511,9 @@ mod video_model {
first: i32,
last: i32,
);
unsafe fn end_insert_rows(self: Pin<&mut qobject::VideoModel>);
unsafe fn end_insert_rows(
self: Pin<&mut qobject::VideoModel>,
);
unsafe fn begin_remove_rows(
self: Pin<&mut qobject::VideoModel>,
@ -438,16 +521,25 @@ mod video_model {
first: i32,
last: i32,
);
unsafe fn end_remove_rows(self: Pin<&mut qobject::VideoModel>);
unsafe fn end_remove_rows(
self: Pin<&mut qobject::VideoModel>,
);
unsafe fn begin_reset_model(self: Pin<&mut qobject::VideoModel>);
unsafe fn end_reset_model(self: Pin<&mut qobject::VideoModel>);
unsafe fn begin_reset_model(
self: Pin<&mut qobject::VideoModel>,
);
unsafe fn end_reset_model(
self: Pin<&mut qobject::VideoModel>,
);
}
#[cxx_qt::inherit]
unsafe extern "C++" {
#[cxx_name = "canFetchMore"]
fn base_can_fetch_more(self: &qobject::VideoModel, parent: &QModelIndex) -> bool;
fn base_can_fetch_more(
self: &qobject::VideoModel,
parent: &QModelIndex,
) -> bool;
fn index(
self: &qobject::VideoModel,
@ -461,7 +553,9 @@ mod video_model {
impl qobject::VideoModel {
#[qinvokable(cxx_override)]
fn data(&self, index: &QModelIndex, role: i32) -> QVariant {
if let Some(video) = self.videos().get(index.row() as usize) {
if let Some(video) =
self.videos().get(index.row() as usize)
{
return match role {
0 => QVariant::from(&video.id),
1 => QVariant::from(&video.title),
@ -488,7 +582,8 @@ mod video_model {
roles.insert(0, cxx_qt_lib::QByteArray::from("id"));
roles.insert(1, cxx_qt_lib::QByteArray::from("title"));
roles.insert(2, cxx_qt_lib::QByteArray::from("filePath"));
roles.insert(3, cxx_qt_lib::QByteArray::from("startTime"));
roles
.insert(3, cxx_qt_lib::QByteArray::from("startTime"));
roles.insert(4, cxx_qt_lib::QByteArray::from("endTime"));
roles.insert(5, cxx_qt_lib::QByteArray::from("loop"));
roles