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

trying to debug slide moving with service_item moves

Browse source
This commit is contained in:
Chris Cochrun 2024-01-19 10:40:05 -06:00
parent 49b9fdc16c
commit 2e43cd87eb
2 changed files with 286 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

364
src/rust/service_item_model.rs
View file

@ -59,17 +59,37 @@ mod service_item_model {
); );
#[qsignal] #[qsignal]
fn active_changed(self: Pin<&mut ServiceItemModel>, index: &i32); fn active_changed(
self: Pin<&mut ServiceItemModel>,
index: &i32,
);
#[qsignal] #[qsignal]
fn selected_changed(self: Pin<&mut ServiceItemModel>); fn selected_changed(self: Pin<&mut ServiceItemModel>);
#[qsignal] #[qsignal]
fn item_inserted(self: Pin<&mut ServiceItemModel>, index: &i32, item: &QMap_QString_QVariant); fn item_inserted(
self: Pin<&mut ServiceItemModel>,
index: &i32,
item: &QMap_QString_QVariant,
);
#[qsignal] #[qsignal]
fn item_added(self: Pin<&mut ServiceItemModel>, index: &i32, item: &QMap_QString_QVariant); fn item_added(
self: Pin<&mut ServiceItemModel>,
index: &i32,
item: &QMap_QString_QVariant,
);
#[qsignal] #[qsignal]
fn item_removed(self: Pin<&mut ServiceItemModel>, index: &i32, item: &QMap_QString_QVariant); fn item_removed(
self: Pin<&mut ServiceItemModel>,
index: &i32,
item: &QMap_QString_QVariant,
);
#[qsignal] #[qsignal]
fn item_moved(self: Pin<&mut ServiceItemModel>, source_index: &i32, dest_index: &i32, item: &QMap_QString_QVariant); fn item_moved(
self: Pin<&mut ServiceItemModel>,
source_index: &i32,
dest_index: &i32,
item: &QMap_QString_QVariant,
);
#[qsignal] #[qsignal]
fn cleared(self: Pin<&mut ServiceItemModel>); fn cleared(self: Pin<&mut ServiceItemModel>);
@ -113,7 +133,7 @@ mod service_item_model {
video_start_time: f32, video_start_time: f32,
video_end_time: f32, video_end_time: f32,
); );
#[qinvokable] #[qinvokable]
fn get_item( fn get_item(
self: Pin<&mut ServiceItemModel>, self: Pin<&mut ServiceItemModel>,
@ -129,10 +149,16 @@ mod service_item_model {
) -> bool; ) -> bool;
#[qinvokable] #[qinvokable]
fn move_up(self: Pin<&mut ServiceItemModel>, index: i32) -> bool; fn move_up(
self: Pin<&mut ServiceItemModel>,
index: i32,
) -> bool;
#[qinvokable] #[qinvokable]
fn move_down(self: Pin<&mut ServiceItemModel>, index: i32) -> bool; fn move_down(
self: Pin<&mut ServiceItemModel>,
index: i32,
) -> bool;
#[qinvokable] #[qinvokable]
fn select(self: Pin<&mut ServiceItemModel>, index: i32); fn select(self: Pin<&mut ServiceItemModel>, index: i32);
@ -156,10 +182,12 @@ mod service_item_model {
) -> bool; ) -> bool;
#[qinvokable] #[qinvokable]
fn save(self: Pin<&mut ServiceItemModel>, file: QUrl) -> bool; fn save(self: Pin<&mut ServiceItemModel>, file: QUrl)
-> bool;
#[qinvokable] #[qinvokable]
fn load(self: Pin<&mut ServiceItemModel>, file: QUrl) -> bool; fn load(self: Pin<&mut ServiceItemModel>, file: QUrl)
-> bool;
} }
impl cxx_qt::Threading for ServiceItemModel {} impl cxx_qt::Threading for ServiceItemModel {}
@ -184,7 +212,6 @@ mod service_item_model {
last: i32, last: i32,
); );
#[inherit] #[inherit]
unsafe fn begin_move_rows( unsafe fn begin_move_rows(
self: Pin<&mut ServiceItemModel>, self: Pin<&mut ServiceItemModel>,
@ -196,10 +223,7 @@ mod service_item_model {
) -> bool; ) -> bool;
#[inherit] #[inherit]
unsafe fn end_move_rows( unsafe fn end_move_rows(self: Pin<&mut ServiceItemModel>);
self: Pin<&mut ServiceItemModel>,
);
#[inherit] #[inherit]
unsafe fn end_remove_rows(self: Pin<&mut ServiceItemModel>); unsafe fn end_remove_rows(self: Pin<&mut ServiceItemModel>);
@ -234,20 +258,28 @@ mod service_item_model {
#[qinvokable] #[qinvokable]
#[cxx_override] #[cxx_override]
fn role_names(self: &ServiceItemModel) -> QHash_i32_QByteArray; fn role_names(
self: &ServiceItemModel,
) -> QHash_i32_QByteArray;
#[qinvokable] #[qinvokable]
#[cxx_override] #[cxx_override]
fn row_count(self: &ServiceItemModel, _parent: &QModelIndex) fn row_count(
-> i32; self: &ServiceItemModel,
_parent: &QModelIndex,
) -> i32;
} }
} }
use crate::obs::Obs;
use crate::service_item_model::service_item_model::QList_QString;
use cxx_qt::CxxQtType; use cxx_qt::CxxQtType;
use cxx_qt_lib::{QModelIndex, QStringList, QString, QByteArray, QUrl, QVariant}; use cxx_qt_lib::{
QByteArray, QModelIndex, QString, QStringList, QUrl, QVariant,
};
use dirs; use dirs;
use serde::{Deserialize, Serialize};
use serde_json::{json, Deserializer, Map, Serializer, Value}; use serde_json::{json, Deserializer, Map, Serializer, Value};
use std::ffi::{OsStr, OsString}; use std::ffi::{OsStr, OsString};
use std::io::{self, Read, Write}; use std::io::{self, Read, Write};
@ -259,11 +291,11 @@ use std::{fs, println};
use tar::{Archive, Builder}; use tar::{Archive, Builder};
use tracing::{debug, debug_span, error, info, instrument}; use tracing::{debug, debug_span, error, info, instrument};
use zstd::{Decoder, Encoder}; use zstd::{Decoder, Encoder};
use crate::obs::Obs;
use crate::service_item_model::service_item_model::QList_QString;
use serde::{Deserialize, Serialize};
use self::service_item_model::{QMap_QString_QVariant, QVector_i32, QHash_i32_QByteArray, ServiceRoles}; use self::service_item_model::{
QHash_i32_QByteArray, QMap_QString_QVariant, QVector_i32,
ServiceRoles,
};
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct ServiceItem { pub struct ServiceItem {
@ -284,6 +316,12 @@ pub struct ServiceItem {
obs_scene: QString, obs_scene: QString,
} }
impl ServiceItem {
fn debug(self) {
debug!(?self);
}
}
impl Default for ServiceItem { impl Default for ServiceItem {
fn default() -> Self { fn default() -> Self {
Self { Self {
@ -316,9 +354,8 @@ pub struct ServiceItemModelRust {
impl Default for ServiceItemModelRust { impl Default for ServiceItemModelRust {
fn default() -> Self { fn default() -> Self {
let obs = tokio::runtime::Runtime::new() let obs =
.unwrap() tokio::runtime::Runtime::new().unwrap().block_on(async {
.block_on(async {
match Obs::new().await { match Obs::new().await {
Ok(o) => Some(o), Ok(o) => Some(o),
Err(e) => { Err(e) => {
@ -352,9 +389,7 @@ impl service_item_model::ServiceItemModel {
} }
pub fn remove_item(mut self: Pin<&mut Self>, index: i32) { pub fn remove_item(mut self: Pin<&mut Self>, index: i32) {
if index < 0 if index < 0 || (index as usize) >= self.service_items.len() {
|| (index as usize) >= self.service_items.len()
{
return; return;
} }
@ -364,7 +399,8 @@ impl service_item_model::ServiceItemModel {
index, index,
index, index,
); );
self.as_mut().rust_mut() self.as_mut()
.rust_mut()
.service_items .service_items
.remove(index as usize); .remove(index as usize);
self.as_mut().end_remove_rows(); self.as_mut().end_remove_rows();
@ -476,7 +512,8 @@ impl service_item_model::ServiceItemModel {
id, id,
id, id,
); );
self.as_mut().rust_mut() self.as_mut()
.rust_mut()
.service_items .service_items
.insert(id as usize, service_item); .insert(id as usize, service_item);
self.as_mut().end_insert_rows(); self.as_mut().end_insert_rows();
@ -525,6 +562,8 @@ impl service_item_model::ServiceItemModel {
self.index(source_index, 0, &QModelIndex::default()); self.index(source_index, 0, &QModelIndex::default());
let parent = model_index.parent(); let parent = model_index.parent();
let source_id = source_index as usize; let source_id = source_index as usize;
let source_first = source_index;
let source_last = source_index + count - 1;
let dest_id = dest_index as usize; let dest_id = dest_index as usize;
let cnt = count as usize; let cnt = count as usize;
let end_service_item = source_id + cnt - 1; let end_service_item = source_id + cnt - 1;
@ -536,14 +575,24 @@ impl service_item_model::ServiceItemModel {
dest_index dest_index
}; };
debug!(
?model_index,
?parent,
source_id,
dest_id,
cnt,
end_service_item,
qt_dest_index
);
println!("rust-end-service_item: {:?}", end_service_item); println!("rust-end-service_item: {:?}", end_service_item);
println!("qt-dest-service_item: {:?}", qt_dest_index); println!("qt-dest-service_item: {:?}", qt_dest_index);
unsafe { unsafe {
// this function doesn't build // this function doesn't build
self.as_mut().begin_move_rows( self.as_mut().begin_move_rows(
&parent, &parent,
source_index, source_first,
source_index + count - 1, source_last,
&parent, &parent,
qt_dest_index, qt_dest_index,
); );
@ -565,7 +614,12 @@ impl service_item_model::ServiceItemModel {
self.as_mut().end_move_rows(); self.as_mut().end_move_rows();
let item = self.as_mut().get_item(dest_index); let item = self.as_mut().get_item(dest_index);
self.as_mut().item_moved(&source_index, &dest_index, &item); debug!(source_index, dest_index);
self.as_mut().item_moved(
&source_index,
&dest_index,
&item,
);
true true
} }
} }
@ -580,10 +634,8 @@ impl service_item_model::ServiceItemModel {
pub fn select(mut self: Pin<&mut Self>, index: i32) { pub fn select(mut self: Pin<&mut Self>, index: i32) {
let rc = self.as_ref().count() - 1; let rc = self.as_ref().count() - 1;
let tl = let tl = &self.as_ref().index(0, 0, &QModelIndex::default());
&self.as_ref().index(0, 0, &QModelIndex::default()); let br = &self.as_ref().index(rc, 0, &QModelIndex::default());
let br =
&self.as_ref().index(rc, 0, &QModelIndex::default());
let mut vector_roles = QVector_i32::default(); let mut vector_roles = QVector_i32::default();
vector_roles.append(self.get_role(ServiceRoles::Selected)); vector_roles.append(self.get_role(ServiceRoles::Selected));
for service_item in for service_item in
@ -593,7 +645,8 @@ impl service_item_model::ServiceItemModel {
service_item.selected = false; service_item.selected = false;
} }
if let Some(service_item) = self if let Some(service_item) = self
.as_mut().rust_mut() .as_mut()
.rust_mut()
.service_items .service_items
.get_mut(index as usize) .get_mut(index as usize)
{ {
@ -642,7 +695,8 @@ impl service_item_model::ServiceItemModel {
&QModelIndex::default(), &QModelIndex::default(),
); );
for (index, item) in self for (index, item) in self
.as_mut().rust_mut() .as_mut()
.rust_mut()
.service_items .service_items
.iter_mut() .iter_mut()
.enumerate() .enumerate()
@ -654,7 +708,11 @@ impl service_item_model::ServiceItemModel {
item.selected = true; item.selected = true;
debug!(selected_item = ?item, index = index); debug!(selected_item = ?item, index = index);
} }
self.as_mut().data_changed(top_left, bottom_right, &vector_roles); self.as_mut().data_changed(
top_left,
bottom_right,
&vector_roles,
);
// self.as_mut().emit_selected_changed(); // self.as_mut().emit_selected_changed();
} else { } else {
let top_left = &self.as_ref().index( let top_left = &self.as_ref().index(
@ -668,7 +726,8 @@ impl service_item_model::ServiceItemModel {
&QModelIndex::default(), &QModelIndex::default(),
); );
for (index, item) in self for (index, item) in self
.as_mut().rust_mut() .as_mut()
.rust_mut()
.service_items .service_items
.iter_mut() .iter_mut()
.enumerate() .enumerate()
@ -680,7 +739,11 @@ impl service_item_model::ServiceItemModel {
item.selected = true; item.selected = true;
debug!(selected_item = ?item, index = index); debug!(selected_item = ?item, index = index);
} }
self.as_mut().data_changed(top_left, bottom_right, &vector_roles); self.as_mut().data_changed(
top_left,
bottom_right,
&vector_roles,
);
} }
true true
@ -689,18 +752,16 @@ impl service_item_model::ServiceItemModel {
// final item. Since we don't know which one is selected, // final item. Since we don't know which one is selected,
// assume that the first one is "selected" // assume that the first one is "selected"
let top_left = &self.as_ref().index( let top_left =
0, &self.as_ref().index(0, 0, &QModelIndex::default());
0,
&QModelIndex::default(),
);
let bottom_right = &self.as_ref().index( let bottom_right = &self.as_ref().index(
final_index, final_index,
0, 0,
&QModelIndex::default(), &QModelIndex::default(),
); );
for (index, item) in self for (index, item) in self
.as_mut().rust_mut() .as_mut()
.rust_mut()
.service_items .service_items
.iter_mut() .iter_mut()
.enumerate() .enumerate()
@ -709,7 +770,11 @@ impl service_item_model::ServiceItemModel {
item.selected = true; item.selected = true;
debug!(selected_item = ?item, index = index); debug!(selected_item = ?item, index = index);
} }
self.as_mut().data_changed(top_left, bottom_right, &vector_roles); self.as_mut().data_changed(
top_left,
bottom_right,
&vector_roles,
);
debug!( debug!(
first_item = 0, first_item = 0,
final_item = final_index, final_item = final_index,
@ -719,15 +784,10 @@ impl service_item_model::ServiceItemModel {
} }
} }
pub fn activate( pub fn activate(mut self: Pin<&mut Self>, index: i32) -> bool {
mut self: Pin<&mut Self>,
index: i32,
) -> bool {
let rc = self.as_ref().count() - 1; let rc = self.as_ref().count() - 1;
let tl = let tl = &self.as_ref().index(0, 0, &QModelIndex::default());
&self.as_ref().index(0, 0, &QModelIndex::default()); let br = &self.as_ref().index(rc, 0, &QModelIndex::default());
let br =
&self.as_ref().index(rc, 0, &QModelIndex::default());
let mut vector_roles = QVector_i32::default(); let mut vector_roles = QVector_i32::default();
vector_roles.append(self.get_role(ServiceRoles::Active)); vector_roles.append(self.get_role(ServiceRoles::Active));
for service_item in for service_item in
@ -739,7 +799,8 @@ impl service_item_model::ServiceItemModel {
let obs = self.as_mut().obs.clone(); let obs = self.as_mut().obs.clone();
if let Some(service_item) = self if let Some(service_item) = self
.as_mut().rust_mut() .as_mut()
.rust_mut()
.service_items .service_items
.get_mut(index as usize) .get_mut(index as usize)
{ {
@ -766,27 +827,20 @@ impl service_item_model::ServiceItemModel {
} }
} }
pub fn deactivate( pub fn deactivate(mut self: Pin<&mut Self>, index: i32) -> bool {
mut self: Pin<&mut Self>,
index: i32,
) -> bool {
let rc = self.as_ref().count() - 1; let rc = self.as_ref().count() - 1;
let tl = let tl = &self.as_ref().index(0, 0, &QModelIndex::default());
&self.as_ref().index(0, 0, &QModelIndex::default()); let br = &self.as_ref().index(rc, 0, &QModelIndex::default());
let br =
&self.as_ref().index(rc, 0, &QModelIndex::default());
let mut vector_roles = QVector_i32::default(); let mut vector_roles = QVector_i32::default();
vector_roles.append(self.get_role(ServiceRoles::Active)); vector_roles.append(self.get_role(ServiceRoles::Active));
if let Some(service_item) = self if let Some(service_item) = self
.as_mut().rust_mut() .as_mut()
.rust_mut()
.service_items .service_items
.get_mut(index as usize) .get_mut(index as usize)
{ {
println!("service_item is activating {:?}", index); println!("service_item is activating {:?}", index);
println!( println!("service_item_title: {:?}", service_item.name);
"service_item_title: {:?}",
service_item.name
);
println!( println!(
"service_item_background: {:?}", "service_item_background: {:?}",
service_item.background service_item.background
@ -821,8 +875,8 @@ impl service_item_model::ServiceItemModel {
temp_dir.push("lumina"); temp_dir.push("lumina");
let mut s: String = let mut s: String =
iter::repeat_with(fastrand::alphanumeric) iter::repeat_with(fastrand::alphanumeric)
.take(5) .take(5)
.collect(); .collect();
s.insert_str(0, "temp_"); s.insert_str(0, "temp_");
temp_dir.push(s); temp_dir.push(s);
match fs::create_dir_all(&temp_dir) { match fs::create_dir_all(&temp_dir) {
@ -854,16 +908,13 @@ impl service_item_model::ServiceItemModel {
Some(name) => { Some(name) => {
println!("bg: {:?}", &name); println!("bg: {:?}", &name);
if name.to_str().unwrap() != "temp" { if name.to_str().unwrap() != "temp" {
flat_background = flat_background = name.to_str().unwrap()
name.to_str().unwrap()
} else { } else {
flat_background = ""; flat_background = "";
} }
} }
_ => { _ => {
println!( println!("save-background: no background");
"save-background: no background"
);
flat_background = ""; flat_background = "";
} }
} }
@ -909,8 +960,7 @@ impl service_item_model::ServiceItemModel {
Err(e) => println!("audio-copy-error: {e}"), Err(e) => println!("audio-copy-error: {e}"),
} }
for (index, line) in text_list.iter().enumerate() for (index, line) in text_list.iter().enumerate() {
{
text_vec.insert(index, line.to_string()) text_vec.insert(index, line.to_string())
} }
@ -932,10 +982,9 @@ impl service_item_model::ServiceItemModel {
println!("{:?}", &temp_service_file); println!("{:?}", &temp_service_file);
match fs::File::create(&temp_service_file) { match fs::File::create(&temp_service_file) {
Ok(o) => println!("created: {:?}", o), Ok(o) => println!("created: {:?}", o),
Err(e) => println!( Err(e) => {
"error-creating-service-file: {:?}", println!("error-creating-service-file: {:?}", e)
e }
),
} }
match fs::File::options() match fs::File::options()
.write(true) .write(true)
@ -949,15 +998,17 @@ impl service_item_model::ServiceItemModel {
) { ) {
Ok(e) => { Ok(e) => {
println!("json: file written"); println!("json: file written");
match tar match tar.append_dir_all("./", &temp_dir)
.append_dir_all("./", &temp_dir)
{ {
Ok(i) => { Ok(i) => {
println!("idk"); println!("idk");
match tar.finish() { match tar.finish() {
Ok(i) => { Ok(i) => {
println!("tar-written: {:?}", &lf); println!(
"tar-written: {:?}",
&lf
);
fs::remove_dir_all( fs::remove_dir_all(
&temp_dir, &temp_dir,
); );
@ -1038,9 +1089,8 @@ impl service_item_model::ServiceItemModel {
// older save files use servicelist.json instead of serviceitems.json // older save files use servicelist.json instead of serviceitems.json
// Let's check to see if that's the case and change it's name in the // Let's check to see if that's the case and change it's name in the
// temp dir. // temp dir.
for mut file in fs::read_dir(datadir.clone()) for mut file in
.unwrap() fs::read_dir(datadir.clone()).unwrap().filter(|f| {
.filter(|f| {
f.as_ref() f.as_ref()
.map(|e| { .map(|e| {
String::from( String::from(
@ -1053,10 +1103,7 @@ impl service_item_model::ServiceItemModel {
{ {
let mut service_path = datadir.clone(); let mut service_path = datadir.clone();
service_path.push("serviceitems.json"); service_path.push("serviceitems.json");
match fs::rename( match fs::rename(file.unwrap().path(), service_path) {
file.unwrap().path(),
service_path,
) {
Ok(i) => println!("We did it captain"), Ok(i) => println!("We did it captain"),
Err(e) => println!("error: {:?}", e), Err(e) => println!("error: {:?}", e),
} }
@ -1102,17 +1149,12 @@ impl service_item_model::ServiceItemModel {
.as_str() .as_str()
.unwrap(); .unwrap();
if !string.is_empty() { if !string.is_empty() {
println!( println!("before_audio_str: {:?}", string);
"before_audio_str: {:?}",
string
);
let mut audio_path = datadir.clone(); let mut audio_path = datadir.clone();
audio_path.push(string); audio_path.push(string);
// Needed to ensure QML images and mpv will find the audio // Needed to ensure QML images and mpv will find the audio
let mut final_string = audio_path let mut final_string =
.to_str() audio_path.to_str().unwrap().to_owned();
.unwrap()
.to_owned();
final_string.insert_str(0, "file://"); final_string.insert_str(0, "file://");
audio = QString::from(&final_string); audio = QString::from(&final_string);
println!( println!(
@ -1126,11 +1168,8 @@ impl service_item_model::ServiceItemModel {
audio = QString::from(audio_string); audio = QString::from(audio_string);
} }
let bgstr = obj let bgstr =
.get("background") obj.get("background").unwrap().as_str().unwrap();
.unwrap()
.as_str()
.unwrap();
let mut background; let mut background;
println!("background_on_disk: {bgstr}"); println!("background_on_disk: {bgstr}");
let bgpath = let bgpath =
@ -1156,10 +1195,7 @@ impl service_item_model::ServiceItemModel {
bgpath.to_str().unwrap().to_owned(); bgpath.to_str().unwrap().to_owned();
final_string.insert_str(0, "file://"); final_string.insert_str(0, "file://");
background = QString::from(&final_string); background = QString::from(&final_string);
println!( println!("after_bgstr: {:?}", final_string);
"after_bgstr: {:?}",
final_string
);
} else { } else {
background = QString::default(); background = QString::default();
} }
@ -1177,12 +1213,9 @@ impl service_item_model::ServiceItemModel {
let font = QString::from( let font = QString::from(
obj.get("font").unwrap().as_str().unwrap(), obj.get("font").unwrap().as_str().unwrap(),
); );
let font_size = obj let font_size =
.get("fontSize") obj.get("fontSize").unwrap().as_i64().unwrap()
.unwrap() as i32;
.as_i64()
.unwrap()
as i32;
let looping; let looping;
if let Some(lp) = obj.get("loop") { if let Some(lp) = obj.get("loop") {
looping = lp.as_bool().unwrap(); looping = lp.as_bool().unwrap();
@ -1200,8 +1233,7 @@ impl service_item_model::ServiceItemModel {
obj.get("video_start_time") obj.get("video_start_time")
{ {
video_start_time = video_start_time =
video_start_value.as_f64().unwrap() video_start_value.as_f64().unwrap() as f32;
as f32;
} }
let mut video_end_time = f32::default(); let mut video_end_time = f32::default();
if let Some(video_end_value) = if let Some(video_end_value) =
@ -1214,9 +1246,8 @@ impl service_item_model::ServiceItemModel {
obj.get("text").unwrap().as_array().unwrap(); obj.get("text").unwrap().as_array().unwrap();
let mut text_list = QList_QString::default(); let mut text_list = QList_QString::default();
for txt in text_array { for txt in text_array {
text_list.append(QString::from( text_list
txt.as_str().unwrap(), .append(QString::from(txt.as_str().unwrap()));
));
} }
let text = QStringList::from(&text_list); let text = QStringList::from(&text_list);
@ -1281,20 +1312,42 @@ impl service_item_model::ServiceItemModel {
self.service_items.get(index.row() as usize) self.service_items.get(index.row() as usize)
{ {
return match role { return match role {
ServiceRoles::Name => QVariant::from(&service_item.name), ServiceRoles::Name => {
ServiceRoles::Type => QVariant::from(&service_item.ty), QVariant::from(&service_item.name)
ServiceRoles::Audio => QVariant::from(&service_item.audio), }
ServiceRoles::Background => QVariant::from(&service_item.background), ServiceRoles::Type => {
QVariant::from(&service_item.ty)
}
ServiceRoles::Audio => {
QVariant::from(&service_item.audio)
}
ServiceRoles::Background => {
QVariant::from(&service_item.background)
}
ServiceRoles::BackgroundType => { ServiceRoles::BackgroundType => {
QVariant::from(&service_item.background_type) QVariant::from(&service_item.background_type)
} }
ServiceRoles::Text => QVariant::from(&service_item.text), ServiceRoles::Text => {
ServiceRoles::Font => QVariant::from(&service_item.font), QVariant::from(&service_item.text)
ServiceRoles::FontSize => QVariant::from(&service_item.font_size), }
ServiceRoles::SlideCount => QVariant::from(&service_item.slide_count), ServiceRoles::Font => {
ServiceRoles::Active => QVariant::from(&service_item.active), QVariant::from(&service_item.font)
ServiceRoles::Selected => QVariant::from(&service_item.selected), }
ServiceRoles::Looping => QVariant::from(&service_item.looping), ServiceRoles::FontSize => {
QVariant::from(&service_item.font_size)
}
ServiceRoles::SlideCount => {
QVariant::from(&service_item.slide_count)
}
ServiceRoles::Active => {
QVariant::from(&service_item.active)
}
ServiceRoles::Selected => {
QVariant::from(&service_item.selected)
}
ServiceRoles::Looping => {
QVariant::from(&service_item.looping)
}
ServiceRoles::VideoStartTime => { ServiceRoles::VideoStartTime => {
QVariant::from(&service_item.video_start_time) QVariant::from(&service_item.video_start_time)
} }
@ -1315,9 +1368,15 @@ impl service_item_model::ServiceItemModel {
pub fn role_names(&self) -> QHash_i32_QByteArray { pub fn role_names(&self) -> QHash_i32_QByteArray {
let mut roles = QHash_i32_QByteArray::default(); let mut roles = QHash_i32_QByteArray::default();
roles.insert(ServiceRoles::Name.repr, QByteArray::from("name")); roles.insert(
ServiceRoles::Name.repr,
QByteArray::from("name"),
);
roles.insert(ServiceRoles::Type.repr, QByteArray::from("ty")); roles.insert(ServiceRoles::Type.repr, QByteArray::from("ty"));
roles.insert(ServiceRoles::Audio.repr, QByteArray::from("audio")); roles.insert(
ServiceRoles::Audio.repr,
QByteArray::from("audio"),
);
roles.insert( roles.insert(
ServiceRoles::Background.repr, ServiceRoles::Background.repr,
QByteArray::from("background"), QByteArray::from("background"),
@ -1326,17 +1385,34 @@ impl service_item_model::ServiceItemModel {
ServiceRoles::BackgroundType.repr, ServiceRoles::BackgroundType.repr,
QByteArray::from("backgroundType"), QByteArray::from("backgroundType"),
); );
roles.insert(ServiceRoles::Text.repr, QByteArray::from("text")); roles.insert(
roles.insert(ServiceRoles::Font.repr, QByteArray::from("font")); ServiceRoles::Text.repr,
roles.insert(ServiceRoles::FontSize.repr, QByteArray::from("fontSize")); QByteArray::from("text"),
);
roles.insert(
ServiceRoles::Font.repr,
QByteArray::from("font"),
);
roles.insert(
ServiceRoles::FontSize.repr,
QByteArray::from("fontSize"),
);
roles.insert( roles.insert(
ServiceRoles::SlideCount.repr, ServiceRoles::SlideCount.repr,
QByteArray::from("slideCount"), QByteArray::from("slideCount"),
); );
roles.insert(ServiceRoles::Active.repr, QByteArray::from("active")); roles.insert(
roles ServiceRoles::Active.repr,
.insert(ServiceRoles::Selected.repr, QByteArray::from("selected")); QByteArray::from("active"),
roles.insert(ServiceRoles::Looping.repr, QByteArray::from("looping")); );
roles.insert(
ServiceRoles::Selected.repr,
QByteArray::from("selected"),
);
roles.insert(
ServiceRoles::Looping.repr,
QByteArray::from("looping"),
);
roles.insert( roles.insert(
ServiceRoles::VideoStartTime.repr, ServiceRoles::VideoStartTime.repr,
QByteArray::from("videoStartTime"), QByteArray::from("videoStartTime"),

85
src/rust/slide_model.rs
View file

@ -156,6 +156,19 @@ mod slide_model {
#[inherit] #[inherit]
unsafe fn end_reset_model(self: Pin<&mut SlideModel>); unsafe fn end_reset_model(self: Pin<&mut SlideModel>);
#[inherit]
unsafe fn begin_move_rows(
self: Pin<&mut SlideModel>,
source_parent: &QModelIndex,
source_first: i32,
source_last: i32,
destination_parent: &QModelIndex,
destination_child: i32,
) -> bool;
#[inherit]
unsafe fn end_move_rows(self: Pin<&mut SlideModel>);
#[inherit] #[inherit]
fn can_fetch_more( fn can_fetch_more(
self: &SlideModel, self: &SlideModel,
@ -814,6 +827,8 @@ impl slide_model::SlideModel {
return; return;
} }
debug!(source_index, destination_index);
let move_down = source_index < destination_index; let move_down = source_index < destination_index;
let slides = self.slides.clone(); let slides = self.slides.clone();
let slides_iter = slides.iter(); let slides_iter = slides.iter();
@ -825,8 +840,13 @@ impl slide_model::SlideModel {
for (i, slide) in slides_iter.clone().enumerate() { for (i, slide) in slides_iter.clone().enumerate() {
if slide.service_item_id == source_index { if slide.service_item_id == source_index {
debug!(index = i, ?slide);
first_slide = i as i32; first_slide = i as i32;
count = slide.slide_count; count = if slide.slide_count == 0 {
1
} else {
slide.slide_count
};
break; break;
} }
} }
@ -869,15 +889,26 @@ impl slide_model::SlideModel {
let slides = self.slides.clone(); let slides = self.slides.clone();
let slides_iter = slides.iter(); let slides_iter = slides.iter();
unsafe {
self.as_mut().begin_reset_model();
}
self.as_mut().move_items( self.as_mut().move_items(
first_slide as usize, first_slide as usize,
dest_slide as usize, dest_slide as usize,
count as usize, count as usize,
); );
// unsafe {
// self.as_mut().begin_reset_model();
// }
let rc = self.as_ref().count() - 1;
let tl = &self.as_ref().index(
source_index,
0,
&QModelIndex::default(),
);
let br = &self.as_ref().index(rc, 0, &QModelIndex::default());
let mut vector_roles = QVector_i32::default();
vector_roles.append(self.get_role(SlideRoles::ServiceItemId));
if count > 1 { if count > 1 {
if move_down { if move_down {
for (i, slide) in slides_iter for (i, slide) in slides_iter
@ -944,14 +975,13 @@ impl slide_model::SlideModel {
if let Some(slide) = if let Some(slide) =
self.as_mut().rust_mut().slides.get_mut(i) self.as_mut().rust_mut().slides.get_mut(i)
{ {
println!( debug!(
"rust-switching-service: {:?} to {:?}", old_service_id = slide.service_item_id,
slide.service_item_id, new_service_id = slide.service_item_id - 1,
slide.service_item_id - 1 "rust-switching-service",
); );
slide.service_item_id -= 1; slide.service_item_id -= 1;
} }
println!("rust-did:");
} }
} else { } else {
for (i, slide) in slides_iter for (i, slide) in slides_iter
@ -965,20 +995,19 @@ impl slide_model::SlideModel {
if let Some(slide) = if let Some(slide) =
self.as_mut().rust_mut().slides.get_mut(i) self.as_mut().rust_mut().slides.get_mut(i)
{ {
println!( debug!(
"rust-switching-service-of: {:?} to {:?}", old_service_id = slide.service_item_id,
slide.service_item_id, new_service_id = slide.service_item_id + 1,
slide.service_item_id + 1 "rust-switching-service",
); );
slide.service_item_id += 1; slide.service_item_id += 1;
} }
println!("rust-did:");
} }
} }
unsafe { // unsafe {
self.as_mut().end_reset_model(); // self.as_mut().end_reset_model();
} // }
println!("rust-move: {first_slide} to {dest_slide} with {count} slides"); println!("rust-move: {first_slide} to {dest_slide} with {count} slides");
} }
@ -989,11 +1018,29 @@ impl slide_model::SlideModel {
dest_index: usize, dest_index: usize,
count: usize, count: usize,
) { ) {
debug!(source_index, dest_index, count);
let end_slide = source_index + count - 1; let end_slide = source_index + count - 1;
println!("rust-end-slide: {:?}", end_slide); println!("rust-end-slide: {:?}", end_slide);
println!("rust-dest-slide: {:?}", dest_index); println!("rust-dest-slide: {:?}", dest_index);
let model_index = self.index(
source_index as i32,
0,
&QModelIndex::default(),
);
let parent = model_index.parent();
let qt_dest_index = if source_index < dest_index {
(dest_index + 1) as i32
} else {
dest_index as i32
};
unsafe { unsafe {
self.as_mut().begin_reset_model(); self.as_mut().begin_move_rows(
&parent,
source_index as i32,
(source_index + count - 1) as i32,
&parent,
qt_dest_index,
);
if source_index < dest_index { if source_index < dest_index {
let move_amount = let move_amount =
dest_index - source_index - count + 1; dest_index - source_index - count + 1;
@ -1008,7 +1055,7 @@ impl slide_model::SlideModel {
[dest_index..=end_slide] [dest_index..=end_slide]
.rotate_left(move_amount); .rotate_left(move_amount);
} }
self.as_mut().end_reset_model(); self.as_mut().end_move_rows();
} }
} }