Basic deleting

czkawka_slint_gui/src/common.rs

@@ -0,0 +1,3 @@
+use slint::{ModelRc, SharedString};
+
+pub type ModelType = (bool, bool, bool, ModelRc<SharedString>);

czkawka_slint_gui/src/connect_delete.rs

@@ -1,15 +1,16 @@
+use crate::common::ModelType;
 use crate::MainWindow;
 use slint::{ComponentHandle, Model, ModelRc, VecModel};
-use std::borrow::BorrowMut;
+use std::borrow::Borrow;
 
 pub fn connect_delete_button(app: &MainWindow) {
     let a = app.as_weak();
     app.on_deleted(move || {
         let app = a.upgrade().unwrap();
 
-        let mut r = app.get_empty_folder_model();
-        let m = r.borrow_mut();
-        let (entries_to_delete, mut entries_left): (Vec<_>, Vec<_>) = m.iter().partition(|(checked, _header_row, _selected_row, _data)| *checked);
+        let r = app.get_empty_folder_model();
+        let m = r.borrow();
+        let (entries_to_delete, mut entries_left): (Vec<ModelType>, Vec<ModelType>) = m.iter().partition(|(checked, _header_row, _selected_row, _data)| *checked);
 
         if !entries_to_delete.is_empty() {
             dbg!(format!("Items to remove {}", entries_to_delete.len()));
@@ -24,3 +25,113 @@ pub fn connect_delete_button(app: &MainWindow) {
         }
     });
 }
+
+fn filter_out_checked_items(items: &ModelRc<ModelType>, have_header: bool) -> (Vec<ModelType>, Vec<ModelType>) {
+    if cfg!(debug_assertions) {
+        check_if_header_is_checked(items);
+        check_if_header_is_selected_but_should_not_be(items, have_header);
+    }
+
+    let (entries_to_delete, mut entries_left): (Vec<_>, Vec<_>) = items.iter().partition(|(checked, _header_row, _selected_row, _data)| *checked);
+
+    if have_header && !entries_left.is_empty() {
+        // First row must be header
+        assert!(entries_left[0].1);
+
+        if entries_left.len() == 3 {
+            // First row is header, so if second or third is also header, then there is no enough items to fill model
+            if entries_left[1].1 || entries_left[2].1 {
+                entries_left = Vec::new();
+            }
+        } else if entries_left.len() < 3 {
+            // Not have enough items to fill model
+            entries_left = Vec::new();
+        } else {
+            let mut last_header = 0;
+            let mut new_items: Vec<ModelType> = Vec::new();
+            for i in 1..entries_left.len() {
+                if entries_left[i].1 {
+                    if i - last_header > 2 {
+                        new_items.extend(entries_left[last_header..i].iter().cloned());
+                    }
+                    last_header = i;
+                }
+            }
+            if entries_left.len() - last_header > 2 {
+                new_items.extend(entries_left[last_header..].iter().cloned());
+            }
+
+            entries_left = new_items;
+        }
+    }
+
+    (entries_to_delete, entries_left)
+}
+
+// Function to verify if really headers are not checked
+// Checked header is big bug
+#[cfg(debug_assertions)]
+fn check_if_header_is_checked(items: &ModelRc<ModelType>) {
+    for i in items.iter() {
+        let (checked, header_row, _selected_row, _data) = i;
+        if header_row {
+            assert!(!checked);
+        }
+    }
+}
+
+// In some modes header should not be visible
+#[cfg(debug_assertions)]
+fn check_if_header_is_selected_but_should_not_be(items: &ModelRc<ModelType>, can_have_header: bool) {
+    if !can_have_header {
+        for i in items.iter() {
+            let (_checked, header_row, _selected_row, _data) = i;
+            assert!(!header_row);
+        }
+    }
+}
+
+#[test]
+fn test_filter_out_checked_items_empty() {
+    let vec_items = Vec::new();
+    let items: ModelRc<ModelType> = ModelRc::new(VecModel::from(vec_items));
+    let (to_delete, left) = filter_out_checked_items(&items, false);
+    assert!(to_delete.is_empty());
+    assert!(left.is_empty());
+    let (to_delete, left) = filter_out_checked_items(&items, true);
+    assert!(to_delete.is_empty());
+    assert!(left.is_empty());
+}
+
+#[test]
+fn test_filter_out_checked_items_one_element_valid_normal() {
+    let vec_items = vec![(false, false, false, ModelRc::new(VecModel::default()))];
+    let items: ModelRc<ModelType> = ModelRc::new(VecModel::from(vec_items));
+    let (to_delete, left) = filter_out_checked_items(&items, false);
+    assert!(to_delete.is_empty());
+    assert_eq!(left.len(), items.iter().count());
+}
+
+#[test]
+fn test_filter_out_checked_items_one_element_valid_header() {
+    let vec_items = vec![(false, true, false, ModelRc::new(VecModel::default()))];
+    let items: ModelRc<ModelType> = ModelRc::new(VecModel::from(vec_items));
+    let (to_delete, left) = filter_out_checked_items(&items, true);
+    assert!(to_delete.is_empty());
+    assert_eq!(left.len(), items.iter().count());
+}
+
+#[test]
+#[should_panic]
+fn test_filter_out_checked_items_one_element_invalid_normal() {
+    let vec_items = vec![(false, true, false, ModelRc::new(VecModel::default()))];
+    let items: ModelRc<ModelType> = ModelRc::new(VecModel::from(vec_items));
+    filter_out_checked_items(&items, false);
+}
+#[test]
+#[should_panic]
+fn test_filter_out_checked_items_one_element_invalid_header() {
+    let vec_items = vec![(false, false, false, ModelRc::new(VecModel::default()))];
+    let items: ModelRc<ModelType> = ModelRc::new(VecModel::from(vec_items));
+    filter_out_checked_items(&items, true);
+}

czkawka_slint_gui/src/main.rs

@@ -1,3 +1,4 @@
+mod common;
 mod connect_delete;
 mod connect_open;
 mod connect_progress_receiver;
@@ -12,13 +13,16 @@ use crate::connect_delete::connect_delete_button;
 use crate::connect_open::connect_open_items;
 use crate::connect_scan::connect_scan_button;
 
+use crate::common::ModelType;
 use crate::connect_progress_receiver::connect_progress_gathering;
 use crate::connect_stop::connect_stop_button;
 use czkawka_core::common_dir_traversal::ProgressData;
-use slint::{ModelRc, SharedString, VecModel};
+use slint::{ModelRc, VecModel};
 
 slint::include_modules!();
 fn main() {
+    handsome_logger::init().unwrap();
+
     let app = MainWindow::new().unwrap(); //.run().unwrap();
 
     let (progress_sender, progress_receiver): (Sender<ProgressData>, Receiver<ProgressData>) = unbounded();
@@ -35,19 +39,19 @@ fn main() {
     app.run().unwrap();
 }
 
-type ModelType = VecModel<(bool, bool, bool, ModelRc<SharedString>)>;
 // TODO remove this after trying
 pub fn to_remove_debug(app: &MainWindow) {
-    let row_data: Rc<ModelType> = Rc::new(VecModel::default());
-
-    for r in 0..20_000_000 {
+    let row_data: Rc<VecModel<ModelType>> = Rc::new(VecModel::default());
+    for r in 0..100_000 {
         let items = VecModel::default();
 
         for c in 0..3 {
             items.push(slint::format!("Item {r}.{c}"));
         }
 
-        row_data.push((r % 2 == 0, r % 3 == 0, false, ModelRc::new(items)));
+        let is_header = r % 3 == 0;
+        let is_checked = (r % 2 == 0) && !is_header;
+        row_data.push((is_checked, is_header, false, ModelRc::new(items)));
     }
     app.set_empty_folder_model(row_data.into());
 }