mod help_functions; use czkawka_core::*; use humansize::{file_size_opts as options, FileSize}; extern crate gtk; use crate::help_functions::*; use chrono::NaiveDateTime; use czkawka_core::common_traits::SaveResults; use czkawka_core::duplicate::CheckingMethod; use czkawka_core::empty_folder::EmptyFolder; use duplicate::DuplicateFinder; use gtk::prelude::*; use gtk::{Builder, SelectionMode, TreeIter, TreeView}; use std::cell::RefCell; use std::collections::HashMap; use std::rc::Rc; use std::{env, fs, process}; fn main() { // Printing version { let all_arguments: Vec = env::args().skip(1).collect(); // Not need to check program name for i in all_arguments { if i == "--v" || i == "--version" { println!("Czkawka CLI {}", CZKAWKA_VERSION); process::exit(0); } } } gtk::init().expect("Failed to initialize GTK."); //// Loading glade file content and build with it help UI let glade_src = include_str!("../czkawka.glade"); let builder = Builder::from_string(glade_src); //// Windows let main_window: gtk::Window = builder.get_object("main_window").unwrap(); main_window.show_all(); main_window.set_title("Czkawka GTK GUI"); //////////////////////////////////////////////////////////////////////////////////////////////// //// States // Buttons State - to remember existence of different buttons on pages let shared_buttons: Rc> = Rc::new(RefCell::new(HashMap::>::new())); shared_buttons.borrow_mut().clear(); // Show by default only search button for i in ["duplicate", "empty_folder"].iter() { let mut temp_hashmap: HashMap = Default::default(); for j in ["search", "stop", "resume", "pause", "select", "delete", "save"].iter() { if *j == "search" { temp_hashmap.insert(j.to_string(), true); } else { temp_hashmap.insert(j.to_string(), false); } } shared_buttons.borrow_mut().insert(i.to_string(), temp_hashmap); } // State of search results - probably are not necessary due let shared_duplication_state: Rc> = Rc::new(RefCell::new(DuplicateFinder::new())); let shared_empty_folders_state: Rc> = Rc::new(RefCell::new(EmptyFolder::new())); //////////////////////////////////////////////////////////////////////////////////////////////// //// GUI Entry let entry_duplicate_minimal_size: gtk::Entry = builder.get_object("entry_duplicate_minimal_size").unwrap(); let entry_allowed_extensions: gtk::Entry = builder.get_object("entry_allowed_extensions").unwrap(); let entry_excluded_items: gtk::Entry = builder.get_object("entry_excluded_items").unwrap(); //// GUI Buttons let buttons_search: gtk::Button = builder.get_object("buttons_search").unwrap(); let buttons_stop: gtk::Button = builder.get_object("buttons_stop").unwrap(); let buttons_resume: gtk::Button = builder.get_object("buttons_resume").unwrap(); let buttons_pause: gtk::Button = builder.get_object("buttons_pause").unwrap(); let buttons_select: gtk::Button = builder.get_object("buttons_select").unwrap(); let buttons_delete: gtk::Button = builder.get_object("buttons_delete").unwrap(); let buttons_save: gtk::Button = builder.get_object("buttons_save").unwrap(); let buttons_add_included_directory: gtk::Button = builder.get_object("buttons_add_included_directory").unwrap(); let buttons_remove_included_directory: gtk::Button = builder.get_object("buttons_remove_included_directory").unwrap(); let buttons_add_excluded_directory: gtk::Button = builder.get_object("buttons_add_excluded_directory").unwrap(); let buttons_remove_excluded_directory: gtk::Button = builder.get_object("buttons_remove_excluded_directory").unwrap(); // Buttons search popover buttons let buttons_popover_select_all: gtk::Button = builder.get_object("buttons_popover_select_all").unwrap(); let buttons_popover_unselect_all: gtk::Button = builder.get_object("buttons_popover_unselect_all").unwrap(); let buttons_popover_reverse: gtk::Button = builder.get_object("buttons_popover_reverse").unwrap(); // let buttons_popover_select_all_except_oldest: gtk::Button = builder.get_object("buttons_popover_select_all_except_oldest").unwrap(); // let buttons_popover_select_all_except_newest: gtk::Button = builder.get_object("buttons_popover_select_all_except_newest").unwrap(); // let buttons_popover_select_one_oldest: gtk::Button = builder.get_object("buttons_popover_select_one_oldest").unwrap(); // let buttons_popover_select_one_newest: gtk::Button = builder.get_object("buttons_popover_select_one_newest").unwrap(); //// Popovers let popover_select: gtk::Popover = builder.get_object("popover_select").unwrap(); //// Check Buttons let check_button_recursive: gtk::CheckButton = builder.get_object("check_button_recursive").unwrap(); //// Radio Buttons let radio_button_size: gtk::RadioButton = builder.get_object("radio_button_size").unwrap(); let radio_button_hashmb: gtk::RadioButton = builder.get_object("radio_button_hashmb").unwrap(); let radio_button_hash: gtk::RadioButton = builder.get_object("radio_button_hash").unwrap(); //// Notebooks let notebook_chooser_tool: gtk::Notebook = builder.get_object("notebook_chooser_tool").unwrap(); let mut notebook_chooser_tool_children_names: Vec = Vec::new(); for i in notebook_chooser_tool.get_children() { notebook_chooser_tool_children_names.push(i.get_buildable_name().unwrap().to_string()); } //// Entry let entry_info: gtk::Entry = builder.get_object("entry_info").unwrap(); // To show default //// Text View let text_view_errors: gtk::TextView = builder.get_object("text_view_errors").unwrap(); //// Scrolled windows // Main notebook let scrolled_window_duplicate_finder: gtk::ScrolledWindow = builder.get_object("scrolled_window_duplicate_finder").unwrap(); let scrolled_window_empty_folder_finder: gtk::ScrolledWindow = builder.get_object("scrolled_window_empty_folder_finder").unwrap(); // Upper notebook let scrolled_window_included_directories: gtk::ScrolledWindow = builder.get_object("scrolled_window_included_directories").unwrap(); let scrolled_window_excluded_directories: gtk::ScrolledWindow = builder.get_object("scrolled_window_excluded_directories").unwrap(); //// Set starting information in bottom panel { entry_info.set_text("Duplicated Files"); // Disable and show buttons buttons_search.show(); buttons_save.hide(); buttons_delete.hide(); buttons_stop.hide(); buttons_resume.hide(); buttons_pause.hide(); buttons_select.hide(); // Set Main ScrolledWindow Treeviews { // Duplicate Files { let col_types: [glib::types::Type; 4] = [glib::types::Type::String, glib::types::Type::String, glib::types::Type::String, glib::types::Type::String]; let list_store: gtk::ListStore = gtk::ListStore::new(&col_types); let mut tree_view: gtk::TreeView = TreeView::with_model(&list_store); tree_view.get_selection().set_mode(SelectionMode::Multiple); tree_view.get_selection().set_select_function(Some(Box::new(select_function_3column))); create_tree_view_duplicates(&mut tree_view); scrolled_window_duplicate_finder.add(&tree_view); scrolled_window_duplicate_finder.show_all(); } // Empty Folders { let col_types: [glib::types::Type; 4] = [glib::types::Type::String, glib::types::Type::String, glib::types::Type::String, glib::types::Type::String]; let list_store: gtk::ListStore = gtk::ListStore::new(&col_types); let mut tree_view: gtk::TreeView = TreeView::with_model(&list_store); tree_view.get_selection().set_mode(SelectionMode::Multiple); create_tree_view_empty_folders(&mut tree_view); scrolled_window_empty_folder_finder.add(&tree_view); scrolled_window_empty_folder_finder.show_all(); } } // Set Included Directory { let col_types: [glib::types::Type; 2] = [glib::types::Type::String, glib::types::Type::String]; let list_store: gtk::ListStore = gtk::ListStore::new(&col_types); let mut tree_view_included_directory: gtk::TreeView = TreeView::with_model(&list_store); tree_view_included_directory.get_selection().set_mode(SelectionMode::Single); create_tree_view_directories(&mut tree_view_included_directory); let col_indices = [0, 1]; let values: [&dyn ToValue; 2] = [&("/home/rafal/Pulpit"), &(MAIN_ROW_COLOR.to_string())]; list_store.set(&list_store.append(), &col_indices, &values); scrolled_window_included_directories.add(&tree_view_included_directory); scrolled_window_included_directories.show_all(); } // Set Excluded Directory { let col_types: [glib::types::Type; 2] = [glib::types::Type::String, glib::types::Type::String]; let list_store: gtk::ListStore = gtk::ListStore::new(&col_types); let mut tree_view_excluded_directory: gtk::TreeView = TreeView::with_model(&list_store); tree_view_excluded_directory.get_selection().set_mode(SelectionMode::Single); create_tree_view_directories(&mut tree_view_excluded_directory); let col_indices = [0, 1]; for i in ["/proc", "/dev"].iter() { let values: [&dyn ToValue; 2] = [&i, &(MAIN_ROW_COLOR.to_string())]; list_store.set(&list_store.append(), &col_indices, &values); } scrolled_window_excluded_directories.add(&tree_view_excluded_directory); scrolled_window_excluded_directories.show_all(); } } // Connecting events { // Connect Notebook Tabs { let shared_buttons = shared_buttons.clone(); #[allow(clippy::redundant_clone)] let buttons_search = buttons_search.clone(); #[allow(clippy::redundant_clone)] let buttons_stop = buttons_stop.clone(); #[allow(clippy::redundant_clone)] let buttons_resume = buttons_resume.clone(); #[allow(clippy::redundant_clone)] let buttons_pause = buttons_pause.clone(); #[allow(clippy::redundant_clone)] let buttons_select = buttons_select.clone(); #[allow(clippy::redundant_clone)] let buttons_delete = buttons_delete.clone(); #[allow(clippy::redundant_clone)] let buttons_save = buttons_save.clone(); let notebook_chooser_tool_children_names = notebook_chooser_tool_children_names.clone(); notebook_chooser_tool.connect_switch_page(move |_, _, number| { let page: &str; match notebook_chooser_tool_children_names.get(number as usize).unwrap().as_str() { "notebook_duplicate_finder_label" => { page = "duplicate"; } "scrolled_window_empty_folder_finder" => { page = "empty_folder"; } e => { panic!("Not existent page {}", e); } }; if *shared_buttons.borrow_mut().get_mut(page).unwrap().get_mut("search").unwrap() { buttons_search.show(); } else { buttons_search.hide(); } if *shared_buttons.borrow_mut().get_mut(page).unwrap().get_mut("stop").unwrap() { buttons_stop.show(); } else { buttons_stop.hide(); } if *shared_buttons.borrow_mut().get_mut(page).unwrap().get_mut("resume").unwrap() { buttons_resume.show(); } else { buttons_resume.hide(); } if *shared_buttons.borrow_mut().get_mut(page).unwrap().get_mut("pause").unwrap() { buttons_pause.show(); } else { buttons_pause.hide(); } if *shared_buttons.borrow_mut().get_mut(page).unwrap().get_mut("select").unwrap() { buttons_select.show(); } else { buttons_select.hide(); } if *shared_buttons.borrow_mut().get_mut(page).unwrap().get_mut("delete").unwrap() { buttons_delete.show(); } else { buttons_delete.hide(); } if *shared_buttons.borrow_mut().get_mut(page).unwrap().get_mut("save").unwrap() { buttons_save.show(); } else { buttons_save.hide(); } }); } //// Connect Buttons // Down notepad { assert!(notebook_chooser_tool_children_names.contains(&"notebook_duplicate_finder_label".to_string())); assert!(notebook_chooser_tool_children_names.contains(&"scrolled_window_empty_folder_finder".to_string())); // Search button { let buttons_delete = buttons_delete.clone(); let buttons_save = buttons_save.clone(); let buttons_select = buttons_select.clone(); let entry_info = entry_info.clone(); let notebook_chooser_tool_children_names = notebook_chooser_tool_children_names.clone(); let notebook_chooser_tool = notebook_chooser_tool.clone(); let scrolled_window_duplicate_finder = scrolled_window_duplicate_finder.clone(); let scrolled_window_empty_folder_finder = scrolled_window_empty_folder_finder.clone(); let scrolled_window_included_directories = scrolled_window_included_directories.clone(); let scrolled_window_excluded_directories = scrolled_window_excluded_directories.clone(); let text_view_errors = text_view_errors.clone(); let shared_duplication_state = shared_duplication_state.clone(); let shared_empty_folders_state = shared_empty_folders_state.clone(); let shared_buttons = shared_buttons.clone(); buttons_search.connect_clicked(move |_| { match notebook_chooser_tool_children_names.get(notebook_chooser_tool.get_current_page().unwrap() as usize).unwrap().as_str() { "notebook_duplicate_finder_label" => { // Find duplicates let mut df = DuplicateFinder::new(); let check_method; if radio_button_size.get_active() { check_method = duplicate::CheckingMethod::Size; } else if radio_button_hashmb.get_active() { check_method = duplicate::CheckingMethod::HashMB; } else if radio_button_hash.get_active() { check_method = duplicate::CheckingMethod::Hash; } else { panic!("No radio button is pressed"); } { df.set_included_directory(get_string_from_list_store(&scrolled_window_included_directories)); df.set_excluded_directory(get_string_from_list_store(&scrolled_window_excluded_directories)); df.set_recursive_search(check_button_recursive.get_active()); df.set_excluded_items(entry_excluded_items.get_text().as_str().to_string()); df.set_allowed_extensions(entry_allowed_extensions.get_text().as_str().to_string()); df.set_min_file_size(match entry_duplicate_minimal_size.get_text().as_str().parse::() { Ok(t) => t, Err(_) => 1024, // By default }); df.set_check_method(check_method.clone()); df.set_delete_method(duplicate::DeleteMethod::None); df.find_duplicates(); } let information = df.get_information(); let text_messages = df.get_text_messages(); let duplicates_number: usize; let duplicates_size: u64; let duplicates_group: usize; match check_method { CheckingMethod::Hash | CheckingMethod::HashMB => { duplicates_number = information.number_of_duplicated_files_by_hash; duplicates_size = information.lost_space_by_hash; duplicates_group = information.number_of_groups_by_hash; } CheckingMethod::Size => { duplicates_number = information.number_of_duplicated_files_by_size; duplicates_size = information.lost_space_by_size; duplicates_group = information.number_of_groups_by_size; } CheckingMethod::None => { panic!(); } } entry_info.set_text(format!("Found {} duplicates files in {} groups which took {}.", duplicates_number, duplicates_group, duplicates_size.file_size(options::BINARY).unwrap()).as_str()); // Create GUI { let list_store = scrolled_window_duplicate_finder .get_children() .get(0) .unwrap() .clone() .downcast::() .unwrap() .get_model() .unwrap() .downcast::() .unwrap(); list_store.clear(); let col_indices = [0, 1, 2, 3]; match check_method { CheckingMethod::Hash | CheckingMethod::HashMB => { let btreemap = df.get_files_sorted_by_hash(); for (size, vectors_vector) in btreemap.iter().rev() { for vector in vectors_vector { let values: [&dyn ToValue; 4] = [ &(vector.len().to_string() + " x " + size.to_string().as_str()), &("(".to_string() + ((vector.len() - 1) as u64 * *size as u64).to_string().as_str() + ")"), &"Bytes lost".to_string(), &(HEADER_ROW_COLOR.to_string()), ]; list_store.set(&list_store.append(), &col_indices, &values); for entry in vector { let path = &entry.path; let index = path.rfind('/').unwrap(); let values: [&dyn ToValue; 4] = [ &(path[index + 1..].to_string()), &(path[..index].to_string()), &(NaiveDateTime::from_timestamp(entry.modified_date as i64, 0).to_string()), &(MAIN_ROW_COLOR.to_string()), ]; list_store.set(&list_store.append(), &col_indices, &values); } } } } CheckingMethod::Size => { let btreemap = df.get_files_sorted_by_size(); for (size, vector) in btreemap.iter().rev() { let values: [&dyn ToValue; 4] = [ &(vector.len().to_string() + " x " + size.to_string().as_str()), &("(".to_string() + ((vector.len() - 1) as u64 * *size as u64).to_string().as_str() + ")"), &"Bytes lost".to_string(), &(HEADER_ROW_COLOR.to_string()), ]; list_store.set(&list_store.append(), &col_indices, &values); for entry in vector { let path = &entry.path; let index = path.rfind('/').unwrap(); let values: [&dyn ToValue; 4] = [ &(path[index + 1..].to_string()), &(path[..index].to_string()), &(NaiveDateTime::from_timestamp(entry.modified_date as i64, 0).to_string()), &(MAIN_ROW_COLOR.to_string()), ]; list_store.set(&list_store.append(), &col_indices, &values); } } } CheckingMethod::None => { panic!(); } } print_text_messages_to_text_view(&text_messages, &text_view_errors); } // Set state { *shared_duplication_state.borrow_mut() = df; if duplicates_size > 0 { buttons_save.show(); buttons_delete.show(); buttons_select.show(); *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("save").unwrap() = true; *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("delete").unwrap() = true; *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("select").unwrap() = true; } else { buttons_save.hide(); buttons_delete.hide(); buttons_select.hide(); *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("save").unwrap() = false; *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("delete").unwrap() = false; *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("select").unwrap() = false; } } } "scrolled_window_empty_folder_finder" => { // Find empty folders // TODO Change to proper value let mut ef = EmptyFolder::new(); ef.set_included_directory("/home/rafal/Pulpit".to_string()); ef.set_delete_folder(false); ef.find_empty_folders(); let information = ef.get_information(); let text_messages = ef.get_text_messages(); let empty_folder_number: usize = information.number_of_empty_folders; entry_info.set_text(format!("Found {} empty folders.", empty_folder_number).as_str()); // Create GUI { let list_store = scrolled_window_empty_folder_finder .get_children() .get(0) .unwrap() .clone() .downcast::() .unwrap() .get_model() .unwrap() .downcast::() .unwrap(); list_store.clear(); let col_indices = [0, 1, 2, 3]; let hashmap = ef.get_empty_folder_list(); for (name, entry) in hashmap { let name: String = name[..(name.len() - 1)].to_string(); let index = name.rfind('/').unwrap(); let values: [&dyn ToValue; 4] = [ &(name[index + 1..].to_string()), &(name[..index].to_string()), &(NaiveDateTime::from_timestamp(entry.modified_date as i64, 0).to_string()), &(MAIN_ROW_COLOR.to_string()), ]; list_store.set(&list_store.append(), &col_indices, &values); } print_text_messages_to_text_view(&text_messages, &text_view_errors); } // Set state { *shared_empty_folders_state.borrow_mut() = ef; if empty_folder_number > 0 { buttons_save.show(); buttons_delete.show(); *shared_buttons.borrow_mut().get_mut("empty_folder").unwrap().get_mut("save").unwrap() = true; *shared_buttons.borrow_mut().get_mut("empty_folder").unwrap().get_mut("delete").unwrap() = true; } else { buttons_save.hide(); buttons_delete.hide(); *shared_buttons.borrow_mut().get_mut("empty_folder").unwrap().get_mut("save").unwrap() = false; *shared_buttons.borrow_mut().get_mut("empty_folder").unwrap().get_mut("delete").unwrap() = false; } } } e => panic!("Not existent {}", e), } }); } // Delete button { let scrolled_window_duplicate_finder = scrolled_window_duplicate_finder.clone(); let notebook_chooser_tool_children_names = notebook_chooser_tool_children_names.clone(); let notebook_chooser_tool = notebook_chooser_tool.clone(); let buttons_delete_clone = buttons_delete.clone(); let buttons_select = buttons_select.clone(); let shared_buttons = shared_buttons.clone(); buttons_delete_clone.connect_clicked(move |_| match notebook_chooser_tool_children_names.get(notebook_chooser_tool.get_current_page().unwrap() as usize).unwrap().as_str() { "notebook_duplicate_finder_label" => { let tree_view = scrolled_window_duplicate_finder.get_children().get(0).unwrap().clone().downcast::().unwrap(); let selection = tree_view.get_selection(); let (selection_rows, tree_model) = selection.get_selected_rows(); let list_store = tree_model.clone().downcast::().unwrap(); // let new_tree_model = TreeModel::new(); // TODO - maybe create new model when inserting a new data, because this seems to be not optimal when using thousands of rows let mut messages: String = "".to_string(); // Must be deleted from end to start, because when deleting entries, TreePath(and also TreeIter) will points to invalid data for tree_path in selection_rows.iter().rev() { let name = tree_model.get_value(&tree_model.get_iter(&tree_path).unwrap(), Columns3Default::Name as i32).get::().unwrap().unwrap(); let path = tree_model.get_value(&tree_model.get_iter(&tree_path).unwrap(), Columns3Default::Path as i32).get::().unwrap().unwrap(); if fs::remove_file(format!("{}/{}", path, name)).is_err() { messages += format!("Failed to remove file {}/{} because file doesn't exists or you don't have permissions.\n", path, name).as_str() } list_store.remove(&list_store.get_iter(&tree_path).unwrap()); } text_view_errors.get_buffer().unwrap().set_text(messages.as_str()); selection.unselect_all(); buttons_delete.hide(); buttons_select.hide(); *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("delete").unwrap() = false; *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("select").unwrap() = false; } "scrolled_window_empty_folder_finder" => { let tree_view = scrolled_window_empty_folder_finder.get_children().get(0).unwrap().clone().downcast::().unwrap(); let selection = tree_view.get_selection(); let (selection_rows, tree_model) = selection.get_selected_rows(); let list_store = tree_model.clone().downcast::().unwrap(); // let new_tree_model = TreeModel::new(); // TODO - maybe create new model when inserting a new data, because this seems to be not optimal when using thousands of rows let mut messages: String = "".to_string(); // Must be deleted from end to start, because when deleting entries, TreePath(and also TreeIter) will points to invalid data for tree_path in selection_rows.iter().rev() { let name = tree_model.get_value(&tree_model.get_iter(&tree_path).unwrap(), Columns3Default::Name as i32).get::().unwrap().unwrap(); let path = tree_model.get_value(&tree_model.get_iter(&tree_path).unwrap(), Columns3Default::Path as i32).get::().unwrap().unwrap(); if fs::remove_dir(format!("{}/{}", path, name)).is_err() { messages += format!("Failed to folder {}/{} due lack of permissions, selected dir is not empty or doesn't exists.\n", path, name).as_str() } list_store.remove(&list_store.get_iter(&tree_path).unwrap()); } text_view_errors.get_buffer().unwrap().set_text(messages.as_str()); selection.unselect_all(); } e => panic!("Not existent {}", e), }); } // Select button { let notebook_chooser_tool_children_names = notebook_chooser_tool_children_names.clone(); let notebook_chooser_tool = notebook_chooser_tool.clone(); let buttons_select_clone = buttons_select.clone(); let popover_select = popover_select.clone(); buttons_select_clone.connect_clicked(move |_| match notebook_chooser_tool_children_names.get(notebook_chooser_tool.get_current_page().unwrap() as usize).unwrap().as_str() { "notebook_duplicate_finder_label" => { // Only popup popup popover_select.set_relative_to(Some(&buttons_select)); popover_select.popup(); } "scrolled_window_empty_folder_finder" => { // Do nothing } e => panic!("Not existent {}", e), }); } // Save button { let buttons_save_clone = buttons_save.clone(); buttons_save_clone.connect_clicked(move |_| match notebook_chooser_tool_children_names.get(notebook_chooser_tool.get_current_page().unwrap() as usize).unwrap().as_str() { "notebook_duplicate_finder_label" => { let file_name = "results_duplicates.txt"; let mut df = shared_duplication_state.borrow_mut(); df.save_results_to_file(file_name); entry_info.set_text(format!("Saved results to file {}", file_name).as_str()); // Set state { buttons_save.hide(); *shared_buttons.borrow_mut().get_mut("duplicate").unwrap().get_mut("save").unwrap() = false; } } "scrolled_window_empty_folder_finder" => { let file_name = "results_empty_folder.txt"; let mut ef = shared_empty_folders_state.borrow_mut(); ef.save_results_to_file(file_name); entry_info.set_text(format!("Saved results to file {}", file_name).as_str()); // Set state { buttons_save.hide(); *shared_buttons.borrow_mut().get_mut("empty_folder").unwrap().get_mut("save").unwrap() = false; } } e => panic!("Not existent {}", e), }); } } // Popover Buttons { // Select all button { let scrolled_window_duplicate_finder = scrolled_window_duplicate_finder.clone(); let popover_select = popover_select.clone(); buttons_popover_select_all.connect_clicked(move |_| { let tree_view = scrolled_window_duplicate_finder.get_children().get(0).unwrap().clone().downcast::().unwrap(); let selection = tree_view.get_selection(); selection.select_all(); popover_select.popdown(); }); } // Unselect all button { let scrolled_window_duplicate_finder = scrolled_window_duplicate_finder.clone(); let popover_select = popover_select.clone(); buttons_popover_unselect_all.connect_clicked(move |_| { let tree_view = scrolled_window_duplicate_finder.get_children().get(0).unwrap().clone().downcast::().unwrap(); let selection = tree_view.get_selection(); selection.unselect_all(); popover_select.popdown(); }); } // Reverse selection { // let scrolled_window_duplicate_finder = scrolled_window_duplicate_finder.clone(); // let popover_select = popover_select.clone(); buttons_popover_reverse.connect_clicked(move |_| { let tree_view = scrolled_window_duplicate_finder.get_children().get(0).unwrap().clone().downcast::().unwrap(); let selection = tree_view.get_selection(); let (vector_tree_path, tree_model) = selection.get_selected_rows(); if vector_tree_path.is_empty() { selection.select_all(); } else { let tree_iter_all = tree_model.get_iter_first().unwrap(); // Never should be available button where there is no available records let mut current_path_index = 0; let mut tree_iter_selected: TreeIter; loop { if current_path_index >= vector_tree_path.len() { selection.select_iter(&tree_iter_all); } else { tree_iter_selected = tree_model.get_iter(vector_tree_path.get(current_path_index).unwrap()).unwrap(); if tree_model.get_path(&tree_iter_all).unwrap() == tree_model.get_path(&tree_iter_selected).unwrap() { selection.unselect_iter(&tree_iter_selected); current_path_index += 1; } else { selection.select_iter(&tree_iter_all); } } if !tree_model.iter_next(&tree_iter_all) { break; } } } popover_select.popdown(); }); } // // All except oldest // { // // let scrolled_window_duplicate_finder = scrolled_window_duplicate_finder.clone(); // // let popover_select = popover_select.clone(); // buttons_popover_reverse.connect_clicked(move |_| { // let tree_view = scrolled_window_duplicate_finder.get_children().get(0).unwrap().clone().downcast::().unwrap(); // let selection = tree_view.get_selection(); // // let (vector_tree_path, tree_model) = selection.get_selected_rows(); // // { // let tree_iter_all = tree_model.get_iter_first().unwrap(); // Never should be available button where there is no available records // // let mut current_path_index = 0; // let mut tree_iter_selected: TreeIter; // // let color = tree_model.get_value(&tree_model.get_iter(tree_path).unwrap(), Columns3Default::Color as i32).get::().unwrap().unwrap(); // // loop { // let array_to_have: Vec = Vec::new(); // let oldest_index : Option = None; // // loop { // if color == HEADER_ROW_COLOR { // break; // } // // // // if current_path_index >= vector_tree_path.len() { // selection.select_iter(&tree_iter_all); // } else { // tree_iter_selected = tree_model.get_iter(vector_tree_path.get(current_path_index).unwrap()).unwrap(); // if tree_model.get_path(&tree_iter_all).unwrap() == tree_model.get_path(&tree_iter_selected).unwrap() { // selection.unselect_iter(&tree_iter_selected); // current_path_index += 1; // } else { // selection.select_iter(&tree_iter_all); // } // } // if !tree_model.iter_next(&tree_iter_all) { // break; // } // } // if arry // } // } // // popover_select.popdown(); // }); // } } // Upper Notepad { // Add included directory { let scrolled_window_included_directories = scrolled_window_included_directories.clone(); let main_window = main_window.clone(); buttons_add_included_directory.connect_clicked(move |_| { let chooser = gtk::FileChooserDialog::with_buttons( Option::from("Folders to include"), Option::from(&main_window), gtk::FileChooserAction::SelectFolder, &[("Ok", gtk::ResponseType::Ok), ("Close", gtk::ResponseType::Cancel)], ); chooser.show_all(); let response_type = chooser.run(); if response_type == gtk::ResponseType::Ok { let folder = chooser.get_filename().unwrap().to_str().unwrap().to_string(); let tree_view = scrolled_window_included_directories.get_children().get(0).unwrap().clone().downcast::().unwrap(); let list_store = tree_view.get_model().unwrap().downcast::().unwrap(); let col_indices = [0, 1]; let values: [&dyn ToValue; 2] = [&folder, &(MAIN_ROW_COLOR.to_string())]; list_store.set(&list_store.append(), &col_indices, &values); } chooser.close(); }); } // Add excluded directory { let scrolled_window_excluded_directories = scrolled_window_excluded_directories.clone(); let main_window = main_window.clone(); buttons_add_excluded_directory.connect_clicked(move |_| { let chooser = gtk::FileChooserDialog::with_buttons( Option::from("Folders to exclude"), Option::from(&main_window), gtk::FileChooserAction::SelectFolder, &[("Ok", gtk::ResponseType::Ok), ("Close", gtk::ResponseType::Cancel)], ); chooser.show_all(); let response_type = chooser.run(); if response_type == gtk::ResponseType::Ok { let folder = chooser.get_filename().unwrap().to_str().unwrap().to_string(); let tree_view = scrolled_window_excluded_directories.get_children().get(0).unwrap().clone().downcast::().unwrap(); let list_store = tree_view.get_model().unwrap().downcast::().unwrap(); let col_indices = [0, 1]; let values: [&dyn ToValue; 2] = [&folder, &(MAIN_ROW_COLOR.to_string())]; list_store.set(&list_store.append(), &col_indices, &values); } chooser.close(); }); } // Remove Excluded Folder { //let scrolled_window_excluded_directories = scrolled_window_excluded_directories.clone(); buttons_remove_excluded_directory.connect_clicked(move |_| { let tree_view = scrolled_window_excluded_directories.get_children().get(0).unwrap().clone().downcast::().unwrap(); let list_store = tree_view.get_model().unwrap().downcast::().unwrap(); let selection = tree_view.get_selection(); let (_, tree_iter) = match selection.get_selected() { Some(t) => t, None => { return; } }; list_store.remove(&tree_iter); }); } // Remove Included Folder { //let scrolled_window_included_directories = scrolled_window_included_directories.clone(); buttons_remove_included_directory.connect_clicked(move |_| { let tree_view = scrolled_window_included_directories.get_children().get(0).unwrap().clone().downcast::().unwrap(); let list_store = tree_view.get_model().unwrap().downcast::().unwrap(); let selection = tree_view.get_selection(); let (_, tree_iter) = match selection.get_selected() { Some(t) => t, None => { return; } }; list_store.remove(&tree_iter); }); } } } // Quit the program when X in main window was clicked main_window.connect_delete_event(|_, _| { gtk::main_quit(); Inhibit(false) }); // We start the gtk main loop. gtk::main(); }