2021-11-25 20:36:49 +13:00
|
|
|
use std::cell::RefCell;
|
|
|
|
use std::collections::HashMap;
|
2021-11-28 08:49:20 +13:00
|
|
|
use std::path::PathBuf;
|
|
|
|
use std::rc::Rc;
|
2020-11-01 02:23:31 +13:00
|
|
|
|
|
|
|
use chrono::NaiveDateTime;
|
2021-11-28 08:49:20 +13:00
|
|
|
use glib::Receiver;
|
2022-05-22 20:59:09 +12:00
|
|
|
use gtk4::prelude::*;
|
2023-04-05 18:08:43 +12:00
|
|
|
use gtk4::{Entry, ListStore, TextView, TreeView, Widget};
|
2023-07-10 18:36:03 +12:00
|
|
|
use humansize::{format_size, BINARY};
|
2021-11-28 08:49:20 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
use czkawka_core::bad_extensions::BadExtensions;
|
|
|
|
use czkawka_core::big_file::BigFile;
|
|
|
|
use czkawka_core::broken_files::BrokenFiles;
|
2022-06-05 07:20:21 +12:00
|
|
|
use czkawka_core::common::split_path;
|
2023-04-05 18:08:43 +12:00
|
|
|
use czkawka_core::common_dir_traversal::{CheckingMethod, FileEntry};
|
|
|
|
use czkawka_core::duplicate::DuplicateFinder;
|
|
|
|
use czkawka_core::empty_files::EmptyFiles;
|
|
|
|
use czkawka_core::empty_folder::EmptyFolder;
|
|
|
|
use czkawka_core::invalid_symlinks::InvalidSymlinks;
|
2022-06-01 03:52:55 +12:00
|
|
|
use czkawka_core::localizer_core::generate_translation_hashmap;
|
2023-04-05 18:08:43 +12:00
|
|
|
use czkawka_core::same_music::{MusicSimilarity, SameMusic};
|
2021-07-25 08:00:39 +12:00
|
|
|
use czkawka_core::similar_images;
|
2023-04-05 18:08:43 +12:00
|
|
|
use czkawka_core::similar_images::SimilarImages;
|
|
|
|
use czkawka_core::similar_videos::SimilarVideos;
|
|
|
|
use czkawka_core::temporary::Temporary;
|
2021-11-28 08:49:20 +13:00
|
|
|
|
2022-01-20 10:35:07 +13:00
|
|
|
use crate::flg;
|
2022-01-14 03:58:33 +13:00
|
|
|
use crate::gui_structs::gui_data::GuiData;
|
2021-12-14 07:13:53 +13:00
|
|
|
use crate::help_combo_box::IMAGES_HASH_SIZE_COMBO_BOX;
|
2021-11-28 08:49:20 +13:00
|
|
|
use crate::help_functions::*;
|
|
|
|
use crate::notebook_enums::*;
|
2023-04-05 18:08:43 +12:00
|
|
|
use crate::notebook_info::NOTEBOOKS_INFO;
|
2021-12-24 21:18:55 +13:00
|
|
|
use crate::opening_selecting_records::*;
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2020-12-02 22:25:27 +13:00
|
|
|
pub fn connect_compute_results(gui_data: &GuiData, glib_stop_receiver: Receiver<Message>) {
|
2021-12-14 07:13:53 +13:00
|
|
|
let combo_box_image_hash_size = gui_data.main_notebook.combo_box_image_hash_size.clone();
|
2021-01-11 08:12:08 +13:00
|
|
|
let buttons_search = gui_data.bottom_buttons.buttons_search.clone();
|
|
|
|
let notebook_main = gui_data.main_notebook.notebook_main.clone();
|
2020-11-01 02:23:31 +13:00
|
|
|
let entry_info = gui_data.entry_info.clone();
|
2021-01-11 01:45:05 +13:00
|
|
|
let tree_view_empty_folder_finder = gui_data.main_notebook.tree_view_empty_folder_finder.clone();
|
|
|
|
let tree_view_empty_files_finder = gui_data.main_notebook.tree_view_empty_files_finder.clone();
|
|
|
|
let tree_view_duplicate_finder = gui_data.main_notebook.tree_view_duplicate_finder.clone();
|
|
|
|
let tree_view_similar_images_finder = gui_data.main_notebook.tree_view_similar_images_finder.clone();
|
2021-11-23 23:10:24 +13:00
|
|
|
let tree_view_similar_videos_finder = gui_data.main_notebook.tree_view_similar_videos_finder.clone();
|
2021-01-11 08:12:08 +13:00
|
|
|
let buttons_array = gui_data.bottom_buttons.buttons_array.clone();
|
2020-11-01 02:23:31 +13:00
|
|
|
let text_view_errors = gui_data.text_view_errors.clone();
|
|
|
|
let shared_duplication_state = gui_data.shared_duplication_state.clone();
|
|
|
|
let shared_buttons = gui_data.shared_buttons.clone();
|
|
|
|
let shared_empty_folders_state = gui_data.shared_empty_folders_state.clone();
|
|
|
|
let shared_empty_files_state = gui_data.shared_empty_files_state.clone();
|
2021-01-13 08:06:12 +13:00
|
|
|
let shared_broken_files_state = gui_data.shared_broken_files_state.clone();
|
2021-01-11 01:45:05 +13:00
|
|
|
let tree_view_big_files_finder = gui_data.main_notebook.tree_view_big_files_finder.clone();
|
2021-01-13 08:06:12 +13:00
|
|
|
let tree_view_broken_files = gui_data.main_notebook.tree_view_broken_files.clone();
|
2021-01-11 01:45:05 +13:00
|
|
|
let tree_view_invalid_symlinks = gui_data.main_notebook.tree_view_invalid_symlinks.clone();
|
2020-11-01 02:23:31 +13:00
|
|
|
let shared_big_files_state = gui_data.shared_big_files_state.clone();
|
2020-12-22 04:09:39 +13:00
|
|
|
let shared_same_invalid_symlinks = gui_data.shared_same_invalid_symlinks.clone();
|
2021-01-11 01:45:05 +13:00
|
|
|
let tree_view_temporary_files_finder = gui_data.main_notebook.tree_view_temporary_files_finder.clone();
|
2022-04-23 07:46:33 +12:00
|
|
|
let tree_view_bad_extensions = gui_data.main_notebook.tree_view_bad_extensions.clone();
|
2020-11-01 02:23:31 +13:00
|
|
|
let shared_temporary_files_state = gui_data.shared_temporary_files_state.clone();
|
|
|
|
let shared_similar_images_state = gui_data.shared_similar_images_state.clone();
|
2021-11-23 23:10:24 +13:00
|
|
|
let shared_similar_videos_state = gui_data.shared_similar_videos_state.clone();
|
2022-04-23 07:46:33 +12:00
|
|
|
let shared_bad_extensions_state = gui_data.shared_bad_extensions_state.clone();
|
2021-01-11 01:45:05 +13:00
|
|
|
let tree_view_same_music_finder = gui_data.main_notebook.tree_view_same_music_finder.clone();
|
2020-11-03 09:56:07 +13:00
|
|
|
let shared_same_music_state = gui_data.shared_same_music_state.clone();
|
2022-01-14 18:34:43 +13:00
|
|
|
let buttons_names = gui_data.bottom_buttons.buttons_names;
|
2021-01-26 06:23:42 +13:00
|
|
|
let window_progress = gui_data.progress_window.window_progress.clone();
|
2021-02-21 00:24:36 +13:00
|
|
|
let taskbar_state = gui_data.taskbar_state.clone();
|
2021-12-04 08:27:59 +13:00
|
|
|
let notebook_upper = gui_data.upper_notebook.notebook_upper.clone();
|
|
|
|
let button_settings = gui_data.header.button_settings.clone();
|
|
|
|
let button_app_info = gui_data.header.button_app_info.clone();
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2021-06-26 04:07:13 +12:00
|
|
|
let main_context = glib::MainContext::default();
|
|
|
|
let _guard = main_context.acquire().unwrap();
|
|
|
|
|
2020-12-02 22:25:27 +13:00
|
|
|
glib_stop_receiver.attach(None, move |msg| {
|
2020-11-01 02:23:31 +13:00
|
|
|
buttons_search.show();
|
|
|
|
|
2021-12-04 08:27:59 +13:00
|
|
|
notebook_main.set_sensitive(true);
|
|
|
|
notebook_upper.set_sensitive(true);
|
|
|
|
button_settings.set_sensitive(true);
|
|
|
|
button_app_info.set_sensitive(true);
|
|
|
|
|
2021-01-26 06:23:42 +13:00
|
|
|
window_progress.hide();
|
2020-12-02 22:25:27 +13:00
|
|
|
|
2021-02-21 00:24:36 +13:00
|
|
|
taskbar_state.borrow().hide();
|
|
|
|
|
2021-12-14 07:13:53 +13:00
|
|
|
let hash_size_index = combo_box_image_hash_size.active().unwrap() as usize;
|
|
|
|
let hash_size = IMAGES_HASH_SIZE_COMBO_BOX[hash_size_index] as u8;
|
2021-11-19 18:35:26 +13:00
|
|
|
|
2020-11-01 02:23:31 +13:00
|
|
|
match msg {
|
|
|
|
Message::Duplicates(df) => {
|
2023-04-05 18:08:43 +12:00
|
|
|
computer_duplicate_finder(
|
|
|
|
df,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_duplicate_finder,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_duplication_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::EmptyFolders(ef) => {
|
|
|
|
computer_empty_folders(
|
|
|
|
ef,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_empty_folder_finder,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_empty_folders_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::EmptyFiles(vf) => {
|
|
|
|
computer_empty_files(
|
|
|
|
vf,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_empty_files_finder,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_empty_files_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::BigFiles(bf) => {
|
|
|
|
computer_big_files(
|
|
|
|
bf,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_big_files_finder,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_big_files_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::Temporary(tf) => {
|
|
|
|
computer_temporary_files(
|
|
|
|
tf,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_temporary_files_finder,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_temporary_files_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::SimilarImages(sf) => {
|
|
|
|
computer_similar_images(
|
|
|
|
sf,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_similar_images_finder,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_similar_images_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
hash_size,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::SimilarVideos(ff) => {
|
|
|
|
computer_similar_videos(
|
|
|
|
ff,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_similar_videos_finder,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_similar_videos_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::SameMusic(mf) => {
|
|
|
|
computer_same_music(
|
|
|
|
mf,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_same_music_finder,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_same_music_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::InvalidSymlinks(ifs) => {
|
|
|
|
computer_invalid_symlinks(
|
|
|
|
ifs,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_invalid_symlinks,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_same_invalid_symlinks,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::BrokenFiles(br) => {
|
|
|
|
computer_broken_files(
|
|
|
|
br,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_broken_files,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_broken_files_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Message::BadExtensions(be) => {
|
|
|
|
computer_bad_extensions(
|
|
|
|
be,
|
|
|
|
&entry_info,
|
|
|
|
&tree_view_bad_extensions,
|
|
|
|
&text_view_errors,
|
|
|
|
&shared_bad_extensions_state,
|
|
|
|
&shared_buttons,
|
|
|
|
&buttons_array,
|
|
|
|
&buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Returning false here would close the receiver and have senders fail
|
|
|
|
Continue(true)
|
|
|
|
});
|
|
|
|
}
|
2021-12-24 21:18:55 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn computer_bad_extensions(
|
|
|
|
be: BadExtensions,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<BadExtensions>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
const COLUMNS_NUMBER: usize = 7;
|
|
|
|
if be.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
let information = be.get_information();
|
|
|
|
let text_messages = be.get_text_messages();
|
|
|
|
|
|
|
|
let bad_extensions_number: usize = information.number_of_files_with_bad_extension;
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_bad_extensions",
|
|
|
|
generate_translation_hashmap(vec![("number_files", bad_extensions_number.to_string()),])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
let vector = be.get_bad_extensions_files();
|
|
|
|
|
|
|
|
// Sort
|
|
|
|
let mut vector = vector.clone();
|
|
|
|
vector.sort_unstable_by_key(|e| {
|
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
|
|
|
|
|
|
|
for file_entry in vector {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsBadExtensions::SelectionButton as u32, &false),
|
|
|
|
(ColumnsBadExtensions::Name as u32, &file),
|
|
|
|
(ColumnsBadExtensions::Path as u32, &directory),
|
|
|
|
(ColumnsBadExtensions::CurrentExtension as u32, &file_entry.current_extension),
|
|
|
|
(ColumnsBadExtensions::ValidExtensions as u32, &file_entry.proper_extensions),
|
|
|
|
(
|
|
|
|
ColumnsBadExtensions::Modification as u32,
|
|
|
|
&(NaiveDateTime::from_timestamp_opt(file_entry.modified_date as i64, 0).unwrap().to_string()),
|
|
|
|
),
|
|
|
|
(ColumnsBadExtensions::ModificationAsSecs as u32, &(file_entry.modified_date as i64)),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = be;
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::Temporary, bad_extensions_number > 0);
|
2021-12-22 06:44:20 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::Temporary).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn computer_broken_files(
|
|
|
|
br: BrokenFiles,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<BrokenFiles>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
const COLUMNS_NUMBER: usize = 6;
|
|
|
|
if br.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
let information = br.get_information();
|
|
|
|
let text_messages = br.get_text_messages();
|
|
|
|
|
|
|
|
let broken_files_number: usize = information.number_of_broken_files;
|
|
|
|
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_broken_files",
|
|
|
|
generate_translation_hashmap(vec![("number_files", broken_files_number.to_string()),])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
let vector = br.get_broken_files();
|
|
|
|
|
|
|
|
// Sort
|
|
|
|
let mut vector = vector.clone();
|
|
|
|
vector.sort_unstable_by_key(|e| {
|
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
|
|
|
|
|
|
|
for file_entry in vector {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsBrokenFiles::SelectionButton as u32, &false),
|
|
|
|
(ColumnsBrokenFiles::Name as u32, &file),
|
|
|
|
(ColumnsBrokenFiles::Path as u32, &directory),
|
|
|
|
(ColumnsBrokenFiles::ErrorType as u32, &file_entry.error_string),
|
|
|
|
(
|
|
|
|
ColumnsBrokenFiles::Modification as u32,
|
|
|
|
&(NaiveDateTime::from_timestamp_opt(file_entry.modified_date as i64, 0).unwrap().to_string()),
|
|
|
|
),
|
|
|
|
(ColumnsBrokenFiles::ModificationAsSecs as u32, &(file_entry.modified_date as i64)),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = br;
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::BrokenFiles, broken_files_number > 0);
|
2021-04-09 04:28:29 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::BrokenFiles).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn computer_invalid_symlinks(
|
|
|
|
ifs: InvalidSymlinks,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<InvalidSymlinks>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
const COLUMNS_NUMBER: usize = 7;
|
|
|
|
if ifs.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
let information = ifs.get_information();
|
|
|
|
let text_messages = ifs.get_text_messages();
|
|
|
|
|
|
|
|
let invalid_symlinks: usize = information.number_of_invalid_symlinks;
|
|
|
|
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_invalid_symlinks",
|
|
|
|
generate_translation_hashmap(vec![("number_files", invalid_symlinks.to_string()),])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
let vector = vector_sort_simple_unstable_entry_by_path(ifs.get_invalid_symlinks());
|
|
|
|
|
|
|
|
for file_entry in vector {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
let symlink_info = file_entry.symlink_info.clone().expect("invalid traversal result");
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsInvalidSymlinks::SelectionButton as u32, &false),
|
|
|
|
(ColumnsInvalidSymlinks::Name as u32, &file),
|
|
|
|
(ColumnsInvalidSymlinks::Path as u32, &directory),
|
|
|
|
(ColumnsInvalidSymlinks::DestinationPath as u32, &symlink_info.destination_path.to_string_lossy().to_string()),
|
|
|
|
(
|
|
|
|
ColumnsInvalidSymlinks::TypeOfError as u32,
|
|
|
|
&get_text_from_invalid_symlink_cause(&symlink_info.type_of_error),
|
|
|
|
),
|
|
|
|
(
|
|
|
|
ColumnsInvalidSymlinks::Modification as u32,
|
|
|
|
&(NaiveDateTime::from_timestamp_opt(file_entry.modified_date as i64, 0).unwrap().to_string()),
|
|
|
|
),
|
|
|
|
(ColumnsInvalidSymlinks::ModificationAsSecs as u32, &(file_entry.modified_date as i64)),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = ifs;
|
2021-12-22 06:44:20 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::Symlinks, invalid_symlinks > 0);
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::Symlinks).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn computer_same_music(
|
|
|
|
mf: SameMusic,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<SameMusic>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
if mf.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
if mf.get_use_reference() {
|
|
|
|
tree_view.selection().set_select_function(select_function_always_true);
|
|
|
|
} else {
|
|
|
|
tree_view.selection().set_select_function(select_function_same_music);
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
let information = mf.get_information();
|
|
|
|
let text_messages = mf.get_text_messages();
|
|
|
|
|
|
|
|
let same_music_number: usize = information.number_of_duplicates;
|
|
|
|
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_music",
|
|
|
|
generate_translation_hashmap(vec![
|
|
|
|
("number_files", information.number_of_duplicates.to_string()),
|
|
|
|
("number_groups", information.number_of_groups.to_string()),
|
|
|
|
])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
let music_similarity = *mf.get_music_similarity();
|
|
|
|
|
|
|
|
let is_track_title = (MusicSimilarity::TRACK_TITLE & music_similarity) != MusicSimilarity::NONE;
|
|
|
|
let is_track_artist = (MusicSimilarity::TRACK_ARTIST & music_similarity) != MusicSimilarity::NONE;
|
|
|
|
let is_year = (MusicSimilarity::YEAR & music_similarity) != MusicSimilarity::NONE;
|
|
|
|
let is_bitrate = (MusicSimilarity::BITRATE & music_similarity) != MusicSimilarity::NONE;
|
|
|
|
let is_length = (MusicSimilarity::LENGTH & music_similarity) != MusicSimilarity::NONE;
|
|
|
|
let is_genre = (MusicSimilarity::GENRE & music_similarity) != MusicSimilarity::NONE;
|
|
|
|
|
|
|
|
if mf.get_use_reference() {
|
|
|
|
let vector = mf.get_similar_music_referenced();
|
|
|
|
|
|
|
|
for (base_file_entry, vec_file_entry) in vector {
|
|
|
|
// Sort
|
|
|
|
let vec_file_entry = if vec_file_entry.len() >= 2 {
|
|
|
|
let mut vec_file_entry = vec_file_entry.clone();
|
|
|
|
vec_file_entry.sort_unstable_by_key(|e| {
|
2021-04-09 04:28:29 +12:00
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
2023-04-05 18:08:43 +12:00
|
|
|
vec_file_entry
|
|
|
|
} else {
|
|
|
|
vec_file_entry.clone()
|
|
|
|
};
|
|
|
|
|
|
|
|
let (directory, file) = split_path(&base_file_entry.path);
|
|
|
|
same_music_add_to_list_store(
|
|
|
|
&list_store,
|
|
|
|
&file,
|
|
|
|
&directory,
|
|
|
|
base_file_entry.size,
|
|
|
|
base_file_entry.modified_date,
|
|
|
|
&base_file_entry.track_title,
|
|
|
|
&base_file_entry.track_artist,
|
|
|
|
&base_file_entry.year,
|
|
|
|
base_file_entry.bitrate,
|
|
|
|
&format!("{} kbps", base_file_entry.bitrate),
|
|
|
|
&base_file_entry.genre,
|
|
|
|
&base_file_entry.length,
|
|
|
|
true,
|
|
|
|
true,
|
|
|
|
);
|
|
|
|
for file_entry in vec_file_entry {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
same_music_add_to_list_store(
|
|
|
|
&list_store,
|
|
|
|
&file,
|
|
|
|
&directory,
|
|
|
|
file_entry.size,
|
|
|
|
file_entry.modified_date,
|
|
|
|
&file_entry.track_title,
|
|
|
|
&file_entry.track_artist,
|
|
|
|
&file_entry.year,
|
|
|
|
file_entry.bitrate,
|
|
|
|
&format!("{} kbps", file_entry.bitrate),
|
|
|
|
&file_entry.genre,
|
|
|
|
&file_entry.length,
|
|
|
|
false,
|
|
|
|
true,
|
2021-12-22 06:44:20 +13:00
|
|
|
);
|
2020-11-01 02:23:31 +13:00
|
|
|
}
|
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
} else {
|
|
|
|
let vector = mf.get_duplicated_music_entries();
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-05-08 06:54:05 +12:00
|
|
|
let text: &str = if mf.get_check_type() == CheckingMethod::AudioTags { "-----" } else { "" };
|
2021-12-22 06:44:20 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for vec_file_entry in vector {
|
|
|
|
// Sort
|
|
|
|
let vec_file_entry = if vec_file_entry.len() >= 2 {
|
|
|
|
let mut vec_file_entry = vec_file_entry.clone();
|
|
|
|
vec_file_entry.sort_unstable_by_key(|e| {
|
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
|
|
|
vec_file_entry
|
|
|
|
} else {
|
|
|
|
vec_file_entry.clone()
|
|
|
|
};
|
|
|
|
|
|
|
|
same_music_add_to_list_store(
|
|
|
|
&list_store,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
if is_track_title { text } else { "" },
|
|
|
|
if is_track_artist { text } else { "" },
|
|
|
|
if is_year { text } else { "" },
|
|
|
|
0,
|
|
|
|
if is_bitrate { text } else { "" },
|
|
|
|
if is_genre { text } else { "" },
|
|
|
|
if is_length { text } else { "" },
|
|
|
|
true,
|
|
|
|
false,
|
|
|
|
);
|
|
|
|
for file_entry in vec_file_entry {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
same_music_add_to_list_store(
|
|
|
|
&list_store,
|
|
|
|
&file,
|
|
|
|
&directory,
|
|
|
|
file_entry.size,
|
|
|
|
file_entry.modified_date,
|
|
|
|
&file_entry.track_title,
|
|
|
|
&file_entry.track_artist,
|
|
|
|
&file_entry.year,
|
|
|
|
file_entry.bitrate,
|
|
|
|
&format!("{} kbps", file_entry.bitrate),
|
|
|
|
&file_entry.genre,
|
|
|
|
&file_entry.length,
|
|
|
|
false,
|
|
|
|
false,
|
2021-12-22 06:44:20 +13:00
|
|
|
);
|
2020-11-01 02:23:31 +13:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = mf;
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::SameMusic, same_music_number > 0);
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::SameMusic).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn computer_similar_videos(
|
|
|
|
ff: SimilarVideos,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<SimilarVideos>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
if ff.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
if ff.get_use_reference() {
|
|
|
|
tree_view.selection().set_select_function(select_function_always_true);
|
|
|
|
} else {
|
|
|
|
tree_view.selection().set_select_function(select_function_similar_videos);
|
|
|
|
}
|
|
|
|
let information = ff.get_information();
|
|
|
|
let text_messages = ff.get_text_messages();
|
|
|
|
let found_any_duplicates = information.number_of_duplicates > 0;
|
|
|
|
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_videos",
|
|
|
|
generate_translation_hashmap(vec![
|
|
|
|
("number_files", information.number_of_duplicates.to_string()),
|
|
|
|
("number_groups", information.number_of_groups.to_string()),
|
|
|
|
])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
if ff.get_use_reference() {
|
|
|
|
let vec_struct_similar = ff.get_similar_videos_referenced();
|
|
|
|
|
2023-09-16 05:04:05 +12:00
|
|
|
for (base_file_entry, vec_file_entry) in vec_struct_similar {
|
2023-04-05 18:08:43 +12:00
|
|
|
// Sort
|
|
|
|
let vec_file_entry = if vec_file_entry.len() >= 2 {
|
|
|
|
let mut vec_file_entry = vec_file_entry.clone();
|
|
|
|
vec_file_entry.sort_unstable_by_key(|e| {
|
2021-04-09 04:28:29 +12:00
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
2023-04-05 18:08:43 +12:00
|
|
|
vec_file_entry
|
|
|
|
} else {
|
|
|
|
vec_file_entry.clone()
|
|
|
|
};
|
2021-01-15 22:43:23 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
similar_videos_add_to_list_store(&list_store, "", "", base_file_entry.size, base_file_entry.modified_date, true, true);
|
|
|
|
for file_entry in &vec_file_entry {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
similar_videos_add_to_list_store(&list_store, &file, &directory, file_entry.size, file_entry.modified_date, false, true);
|
2020-11-01 02:23:31 +13:00
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
let vec_struct_similar = ff.get_similar_videos();
|
|
|
|
|
2023-09-16 05:04:05 +12:00
|
|
|
for vec_file_entry in vec_struct_similar {
|
2023-04-05 18:08:43 +12:00
|
|
|
// Sort
|
|
|
|
let vec_file_entry = if vec_file_entry.len() >= 2 {
|
|
|
|
let mut vec_file_entry = vec_file_entry.clone();
|
|
|
|
vec_file_entry.sort_unstable_by_key(|e| {
|
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
|
|
|
vec_file_entry
|
|
|
|
} else {
|
|
|
|
vec_file_entry.clone()
|
|
|
|
};
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
similar_videos_add_to_list_store(&list_store, "", "", 0, 0, true, false);
|
|
|
|
for file_entry in &vec_file_entry {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
similar_videos_add_to_list_store(&list_store, &file, &directory, file_entry.size, file_entry.modified_date, false, false);
|
2020-11-01 02:23:31 +13:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = ff;
|
2020-11-01 02:23:31 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::SimilarVideos, found_any_duplicates);
|
2021-12-22 06:44:20 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::SimilarVideos).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn computer_similar_images(
|
|
|
|
sf: SimilarImages,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<SimilarImages>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
hash_size: u8,
|
|
|
|
) {
|
|
|
|
if sf.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
if sf.get_use_reference() {
|
|
|
|
tree_view.selection().set_select_function(select_function_always_true);
|
|
|
|
} else {
|
|
|
|
tree_view.selection().set_select_function(select_function_similar_images);
|
|
|
|
}
|
|
|
|
let information = sf.get_information();
|
|
|
|
let text_messages = sf.get_text_messages();
|
|
|
|
|
|
|
|
let found_any_duplicates = information.number_of_duplicates > 0;
|
|
|
|
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_images",
|
|
|
|
generate_translation_hashmap(vec![
|
|
|
|
("number_files", information.number_of_duplicates.to_string()),
|
|
|
|
("number_groups", information.number_of_groups.to_string()),
|
|
|
|
])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
if sf.get_use_reference() {
|
|
|
|
let vec_struct_similar: &Vec<(similar_images::FileEntry, Vec<similar_images::FileEntry>)> = sf.get_similar_images_referenced();
|
2023-09-16 05:04:05 +12:00
|
|
|
for (base_file_entry, vec_file_entry) in vec_struct_similar {
|
2023-04-05 18:08:43 +12:00
|
|
|
// Sort
|
|
|
|
let vec_file_entry = if vec_file_entry.len() >= 2 {
|
|
|
|
let mut vec_file_entry = vec_file_entry.clone();
|
|
|
|
// Use comparison by similarity, because it is more important that path here
|
|
|
|
vec_file_entry.sort_unstable_by_key(|e| e.similarity);
|
|
|
|
vec_file_entry
|
|
|
|
} else {
|
|
|
|
vec_file_entry.clone()
|
|
|
|
};
|
|
|
|
|
|
|
|
// Header
|
|
|
|
let (directory, file) = split_path(&base_file_entry.path);
|
2023-06-10 08:11:47 +12:00
|
|
|
similar_images_add_to_list_store(
|
|
|
|
&list_store,
|
|
|
|
&file,
|
|
|
|
&directory,
|
|
|
|
base_file_entry.size,
|
|
|
|
base_file_entry.modified_date,
|
|
|
|
&base_file_entry.dimensions,
|
|
|
|
0,
|
|
|
|
hash_size,
|
|
|
|
true,
|
|
|
|
true,
|
|
|
|
);
|
2023-04-05 18:08:43 +12:00
|
|
|
for file_entry in &vec_file_entry {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
similar_images_add_to_list_store(
|
|
|
|
&list_store,
|
|
|
|
&file,
|
|
|
|
&directory,
|
|
|
|
file_entry.size,
|
|
|
|
file_entry.modified_date,
|
|
|
|
&file_entry.dimensions,
|
|
|
|
file_entry.similarity,
|
|
|
|
hash_size,
|
|
|
|
false,
|
|
|
|
true,
|
2021-12-22 06:44:20 +13:00
|
|
|
);
|
2020-11-01 02:23:31 +13:00
|
|
|
}
|
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
} else {
|
|
|
|
let vec_struct_similar = sf.get_similar_images();
|
2023-09-16 05:04:05 +12:00
|
|
|
for vec_file_entry in vec_struct_similar {
|
2023-04-05 18:08:43 +12:00
|
|
|
// Sort
|
|
|
|
let vec_file_entry = if vec_file_entry.len() >= 2 {
|
|
|
|
let mut vec_file_entry = vec_file_entry.clone();
|
|
|
|
// Use comparison by similarity, because it is more important that path here
|
|
|
|
vec_file_entry.sort_unstable_by_key(|e| e.similarity);
|
|
|
|
vec_file_entry
|
2021-12-24 21:18:55 +13:00
|
|
|
} else {
|
2023-04-05 18:08:43 +12:00
|
|
|
vec_file_entry.clone()
|
|
|
|
};
|
|
|
|
|
|
|
|
similar_images_add_to_list_store(&list_store, "", "", 0, 0, "", 0, 0, true, false);
|
|
|
|
for file_entry in &vec_file_entry {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
similar_images_add_to_list_store(
|
|
|
|
&list_store,
|
|
|
|
&file,
|
|
|
|
&directory,
|
|
|
|
file_entry.size,
|
|
|
|
file_entry.modified_date,
|
|
|
|
&file_entry.dimensions,
|
|
|
|
file_entry.similarity,
|
|
|
|
hash_size,
|
|
|
|
false,
|
|
|
|
false,
|
|
|
|
);
|
2021-12-24 21:18:55 +13:00
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
}
|
|
|
|
}
|
2021-11-23 23:10:24 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2021-11-23 23:10:24 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = sf;
|
2021-11-23 23:10:24 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::SimilarImages, found_any_duplicates);
|
2021-12-22 06:44:20 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::SimilarImages).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn computer_temporary_files(
|
|
|
|
tf: Temporary,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<Temporary>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
const COLUMNS_NUMBER: usize = 5;
|
|
|
|
if tf.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
let information = tf.get_information();
|
|
|
|
let text_messages = tf.get_text_messages();
|
|
|
|
|
|
|
|
let temporary_files_number: usize = information.number_of_temporary_files;
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_temporary_files",
|
|
|
|
generate_translation_hashmap(vec![("number_files", temporary_files_number.to_string()),])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
let vector = tf.get_temporary_files();
|
|
|
|
|
|
|
|
// Sort // TODO maybe simplify this via common file entry
|
|
|
|
let mut vector = vector.clone();
|
|
|
|
vector.sort_unstable_by_key(|e| {
|
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
|
|
|
|
|
|
|
for file_entry in vector {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsTemporaryFiles::SelectionButton as u32, &false),
|
|
|
|
(ColumnsTemporaryFiles::Name as u32, &file),
|
|
|
|
(ColumnsTemporaryFiles::Path as u32, &directory),
|
|
|
|
(
|
|
|
|
ColumnsTemporaryFiles::Modification as u32,
|
|
|
|
&(NaiveDateTime::from_timestamp_opt(file_entry.modified_date as i64, 0).unwrap().to_string()),
|
|
|
|
),
|
|
|
|
(ColumnsTemporaryFiles::ModificationAsSecs as u32, &(file_entry.modified_date as i64)),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
2021-11-23 23:10:24 +13:00
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2021-12-24 21:18:55 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = tf;
|
2020-11-03 09:56:07 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::Temporary, temporary_files_number > 0);
|
2020-11-03 09:56:07 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::Temporary).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-11-03 09:56:07 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn computer_big_files(
|
|
|
|
bf: BigFile,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<BigFile>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
const COLUMNS_NUMBER: usize = 7;
|
|
|
|
if bf.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
let information = bf.get_information();
|
|
|
|
let text_messages = bf.get_text_messages();
|
|
|
|
|
|
|
|
let biggest_files_number: usize = information.number_of_real_files;
|
|
|
|
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_big_files",
|
|
|
|
generate_translation_hashmap(vec![("number_files", biggest_files_number.to_string()),])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
let vector = bf.get_big_files();
|
|
|
|
|
2023-09-16 05:04:05 +12:00
|
|
|
for (size, file_entry) in vector {
|
2023-04-05 18:08:43 +12:00
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsBigFiles::SelectionButton as u32, &false),
|
|
|
|
(ColumnsBigFiles::Size as u32, &(format_size(*size, BINARY))),
|
|
|
|
(ColumnsBigFiles::Name as u32, &file),
|
|
|
|
(ColumnsBigFiles::Path as u32, &directory),
|
|
|
|
(
|
|
|
|
ColumnsBigFiles::Modification as u32,
|
|
|
|
&(NaiveDateTime::from_timestamp_opt(file_entry.modified_date as i64, 0).unwrap().to_string()),
|
|
|
|
),
|
|
|
|
(ColumnsBigFiles::ModificationAsSecs as u32, &(file_entry.modified_date as i64)),
|
|
|
|
(ColumnsBigFiles::SizeAsBytes as u32, &(size)),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2021-12-24 21:18:55 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = bf;
|
2020-11-03 09:56:07 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::BigFiles, biggest_files_number > 0);
|
2021-12-22 06:44:20 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::BigFiles).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn computer_empty_files(
|
|
|
|
vf: EmptyFiles,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<EmptyFiles>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
const COLUMNS_NUMBER: usize = 5;
|
|
|
|
if vf.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
let information = vf.get_information();
|
|
|
|
let text_messages = vf.get_text_messages();
|
|
|
|
|
|
|
|
let empty_files_number: usize = information.number_of_empty_files;
|
|
|
|
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_empty_files",
|
|
|
|
generate_translation_hashmap(vec![("number_files", empty_files_number.to_string()),])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
let vector = vf.get_empty_files();
|
|
|
|
let vector = vector_sort_simple_unstable_entry_by_path(vector);
|
|
|
|
|
|
|
|
for file_entry in vector {
|
|
|
|
let (directory, file) = split_path(&file_entry.path);
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsEmptyFiles::SelectionButton as u32, &false),
|
|
|
|
(ColumnsEmptyFiles::Name as u32, &file),
|
|
|
|
(ColumnsEmptyFiles::Path as u32, &directory),
|
|
|
|
(
|
|
|
|
ColumnsEmptyFiles::Modification as u32,
|
|
|
|
&(NaiveDateTime::from_timestamp_opt(file_entry.modified_date as i64, 0).unwrap().to_string()),
|
|
|
|
),
|
|
|
|
(ColumnsEmptyFiles::ModificationAsSecs as u32, &(file_entry.modified_date as i64)),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
2020-11-03 09:56:07 +13:00
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2020-12-22 04:09:39 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = vf;
|
2020-12-22 04:09:39 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::EmptyFiles, empty_files_number > 0);
|
2020-12-22 04:09:39 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::EmptyFiles).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-04-09 04:28:29 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn computer_empty_folders(
|
|
|
|
ef: EmptyFolder,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<EmptyFolder>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
const COLUMNS_NUMBER: usize = 5;
|
|
|
|
if ef.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
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(
|
|
|
|
flg!(
|
|
|
|
"compute_found_empty_folders",
|
|
|
|
generate_translation_hashmap(vec![("number_files", empty_folder_number.to_string()),])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view);
|
|
|
|
|
|
|
|
let hashmap = ef.get_empty_folder_list();
|
|
|
|
let mut vector = hashmap.keys().cloned().collect::<Vec<PathBuf>>();
|
|
|
|
|
|
|
|
vector.sort_unstable_by_key(|e| {
|
|
|
|
let t = split_path(e.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
|
|
|
|
|
|
|
for path in vector {
|
|
|
|
let (directory, file) = split_path(&path);
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsEmptyFolders::SelectionButton as u32, &false),
|
|
|
|
(ColumnsEmptyFolders::Name as u32, &file),
|
|
|
|
(ColumnsEmptyFolders::Path as u32, &directory),
|
|
|
|
(
|
|
|
|
ColumnsEmptyFolders::Modification as u32,
|
|
|
|
&(NaiveDateTime::from_timestamp_opt(hashmap.get(&path).unwrap().modified_date as i64, 0).unwrap().to_string()),
|
|
|
|
),
|
|
|
|
(ColumnsEmptyFolders::ModificationAsSecs as u32, &(hashmap.get(&path).unwrap().modified_date)),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
|
|
|
}
|
2021-01-15 22:43:23 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = ef;
|
2020-12-22 04:09:39 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::EmptyDirectories, empty_folder_number > 0);
|
2020-12-22 04:09:39 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::EmptyDirectories).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-11-25 20:36:49 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn computer_duplicate_finder(
|
|
|
|
df: DuplicateFinder,
|
|
|
|
entry_info: &Entry,
|
|
|
|
tree_view_duplicate_finder: &TreeView,
|
|
|
|
text_view_errors: &TextView,
|
|
|
|
shared_state: &Rc<RefCell<DuplicateFinder>>,
|
|
|
|
shared_buttons: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>,
|
|
|
|
buttons_array: &[Widget; 9],
|
|
|
|
buttons_names: &[BottomButtonsEnum; 9],
|
|
|
|
) {
|
|
|
|
if df.get_stopped_search() {
|
|
|
|
entry_info.set_text(&flg!("compute_stopped_by_user"));
|
|
|
|
} else {
|
|
|
|
if df.get_use_reference() {
|
|
|
|
tree_view_duplicate_finder.selection().set_select_function(select_function_always_true);
|
|
|
|
} else {
|
|
|
|
tree_view_duplicate_finder.selection().set_select_function(select_function_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 df.get_check_method() {
|
|
|
|
CheckingMethod::Name => {
|
|
|
|
duplicates_number = information.number_of_duplicated_files_by_name;
|
|
|
|
duplicates_size = 0;
|
|
|
|
duplicates_group = information.number_of_groups_by_name;
|
2020-12-22 04:09:39 +13:00
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
CheckingMethod::Hash => {
|
|
|
|
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::SizeName => {
|
|
|
|
duplicates_number = information.number_of_duplicated_files_by_size_name;
|
|
|
|
duplicates_size = information.lost_space_by_size;
|
|
|
|
duplicates_group = information.number_of_groups_by_size_name;
|
|
|
|
}
|
2023-05-08 06:54:05 +12:00
|
|
|
_ => panic!(),
|
2023-04-05 18:08:43 +12:00
|
|
|
}
|
|
|
|
if duplicates_size == 0 {
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_duplicates_name",
|
|
|
|
generate_translation_hashmap(vec![("number_files", duplicates_number.to_string()), ("number_groups", duplicates_group.to_string())])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
entry_info.set_text(
|
|
|
|
flg!(
|
|
|
|
"compute_found_duplicates_hash_size",
|
|
|
|
generate_translation_hashmap(vec![
|
|
|
|
("number_files", duplicates_number.to_string()),
|
|
|
|
("number_groups", duplicates_group.to_string()),
|
|
|
|
("size", format_size(duplicates_size, BINARY))
|
|
|
|
])
|
|
|
|
)
|
|
|
|
.as_str(),
|
|
|
|
);
|
|
|
|
}
|
2021-01-13 08:06:12 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
// Create GUI
|
|
|
|
{
|
|
|
|
let list_store = get_list_store(tree_view_duplicate_finder);
|
2021-01-13 08:06:12 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
if df.get_use_reference() {
|
|
|
|
match df.get_check_method() {
|
|
|
|
CheckingMethod::Name => {
|
|
|
|
let btreemap = df.get_files_with_identical_name_referenced();
|
2021-01-13 08:06:12 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for (_name, (base_file_entry, vector)) in btreemap.iter().rev() {
|
|
|
|
let vector = vector_sort_unstable_entry_by_path(vector);
|
|
|
|
let (directory, file) = split_path(&base_file_entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, base_file_entry.size, base_file_entry.modified_date, true, true);
|
2021-01-15 22:43:23 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for entry in vector {
|
|
|
|
let (directory, file) = split_path(&entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, entry.size, entry.modified_date, false, true);
|
|
|
|
}
|
2021-01-13 08:06:12 +13:00
|
|
|
}
|
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
CheckingMethod::Hash => {
|
|
|
|
let btreemap = df.get_files_with_identical_hashes_referenced();
|
2021-01-13 08:06:12 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for (_size, vectors_vector) in btreemap.iter().rev() {
|
|
|
|
for (base_file_entry, vector) in vectors_vector {
|
|
|
|
let vector = vector_sort_unstable_entry_by_path(vector);
|
|
|
|
let (directory, file) = split_path(&base_file_entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, base_file_entry.size, base_file_entry.modified_date, true, true);
|
|
|
|
for entry in vector {
|
|
|
|
let (directory, file) = split_path(&entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, entry.size, entry.modified_date, false, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CheckingMethod::Size => {
|
|
|
|
let btreemap = df.get_files_with_identical_size_referenced();
|
|
|
|
|
|
|
|
for (_size, (base_file_entry, vector)) in btreemap.iter().rev() {
|
|
|
|
let vector = vector_sort_unstable_entry_by_path(vector);
|
|
|
|
let (directory, file) = split_path(&base_file_entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, base_file_entry.size, base_file_entry.modified_date, true, true);
|
|
|
|
for entry in vector {
|
|
|
|
let (directory, file) = split_path(&entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, entry.size, entry.modified_date, false, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CheckingMethod::SizeName => {
|
|
|
|
let btreemap = df.get_files_with_identical_size_names_referenced();
|
|
|
|
|
|
|
|
for (_size, (base_file_entry, vector)) in btreemap.iter().rev() {
|
|
|
|
let vector = vector_sort_unstable_entry_by_path(vector);
|
|
|
|
let (directory, file) = split_path(&base_file_entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, base_file_entry.size, base_file_entry.modified_date, true, true);
|
|
|
|
for entry in vector {
|
|
|
|
let (directory, file) = split_path(&entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, entry.size, entry.modified_date, false, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-05-08 06:54:05 +12:00
|
|
|
_ => panic!(),
|
2021-01-13 08:06:12 +13:00
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
} else {
|
|
|
|
match df.get_check_method() {
|
|
|
|
CheckingMethod::Name => {
|
|
|
|
let btreemap = df.get_files_sorted_by_names();
|
|
|
|
|
|
|
|
for (_name, vector) in btreemap.iter().rev() {
|
|
|
|
let vector = vector_sort_unstable_entry_by_path(vector);
|
|
|
|
duplicates_add_to_list_store(&list_store, "", "", 0, 0, true, false);
|
|
|
|
for entry in vector {
|
|
|
|
let (directory, file) = split_path(&entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, entry.size, entry.modified_date, false, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CheckingMethod::Hash => {
|
|
|
|
let btreemap = df.get_files_sorted_by_hash();
|
2022-04-23 07:46:33 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for (_size, vectors_vector) in btreemap.iter().rev() {
|
|
|
|
for vector in vectors_vector {
|
|
|
|
let vector = vector_sort_unstable_entry_by_path(vector);
|
|
|
|
duplicates_add_to_list_store(&list_store, "", "", 0, 0, true, false);
|
2022-04-23 07:46:33 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for entry in vector {
|
|
|
|
let (directory, file) = split_path(&entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, entry.size, entry.modified_date, false, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CheckingMethod::Size => {
|
|
|
|
let btreemap = df.get_files_sorted_by_size();
|
2022-04-23 07:46:33 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for (_size, vector) in btreemap.iter().rev() {
|
|
|
|
let vector = vector_sort_unstable_entry_by_path(vector);
|
|
|
|
duplicates_add_to_list_store(&list_store, "", "", 0, 0, true, false);
|
2022-04-23 07:46:33 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for entry in vector {
|
|
|
|
let (directory, file) = split_path(&entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, entry.size, entry.modified_date, false, false);
|
|
|
|
}
|
2022-04-23 07:46:33 +12:00
|
|
|
}
|
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
CheckingMethod::SizeName => {
|
|
|
|
let btreemap = df.get_files_sorted_by_size_name();
|
2022-04-23 07:46:33 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for (_size, vector) in btreemap.iter().rev() {
|
|
|
|
let vector = vector_sort_unstable_entry_by_path(vector);
|
|
|
|
duplicates_add_to_list_store(&list_store, "", "", 0, 0, true, false);
|
2022-04-23 07:46:33 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
for entry in vector {
|
|
|
|
let (directory, file) = split_path(&entry.path);
|
|
|
|
duplicates_add_to_list_store(&list_store, &file, &directory, entry.size, entry.modified_date, false, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-05-08 06:54:05 +12:00
|
|
|
_ => panic!(),
|
2022-04-23 07:46:33 +12:00
|
|
|
}
|
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
print_text_messages_to_text_view(text_messages, text_view_errors);
|
2020-11-01 02:23:31 +13:00
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
|
|
|
|
// Set state
|
|
|
|
{
|
|
|
|
*shared_state.borrow_mut() = df;
|
|
|
|
|
|
|
|
set_specific_buttons_as_active(shared_buttons, &NotebookMainEnum::Duplicate, duplicates_number > 0);
|
|
|
|
|
|
|
|
set_buttons(
|
|
|
|
&mut *shared_buttons.borrow_mut().get_mut(&NotebookMainEnum::Duplicate).unwrap(),
|
|
|
|
buttons_array,
|
|
|
|
buttons_names,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn vector_sort_unstable_entry_by_path(vector: &Vec<FileEntry>) -> Vec<FileEntry> {
|
|
|
|
if vector.len() >= 2 {
|
|
|
|
let mut vector = vector.clone();
|
|
|
|
vector.sort_unstable_by_key(|e| {
|
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
|
|
|
});
|
|
|
|
vector
|
|
|
|
} else {
|
|
|
|
vector.clone()
|
|
|
|
}
|
|
|
|
}
|
2023-05-03 08:37:12 +12:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn vector_sort_simple_unstable_entry_by_path(vector: &[FileEntry]) -> Vec<FileEntry> {
|
|
|
|
let mut vector = vector.to_owned();
|
|
|
|
vector.sort_unstable_by_key(|e| {
|
|
|
|
let t = split_path(e.path.as_path());
|
|
|
|
(t.0, t.1)
|
2020-11-01 02:23:31 +13:00
|
|
|
});
|
2023-04-05 18:08:43 +12:00
|
|
|
vector
|
2020-11-01 02:23:31 +13:00
|
|
|
}
|
2021-11-25 20:36:49 +13:00
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
fn duplicates_add_to_list_store(list_store: &ListStore, file: &str, directory: &str, size: u64, modified_date: u64, is_header: bool, is_reference_folder: bool) {
|
|
|
|
const COLUMNS_NUMBER: usize = 11;
|
|
|
|
let size_str;
|
|
|
|
let string_date;
|
|
|
|
let color = if is_header { HEADER_ROW_COLOR } else { MAIN_ROW_COLOR };
|
|
|
|
|
|
|
|
if is_header && !is_reference_folder {
|
|
|
|
size_str = String::new();
|
|
|
|
string_date = String::new();
|
|
|
|
} else {
|
|
|
|
size_str = format_size(size, BINARY);
|
|
|
|
string_date = NaiveDateTime::from_timestamp_opt(modified_date as i64, 0).unwrap().to_string();
|
|
|
|
};
|
|
|
|
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsDuplicates::ActivatableSelectButton as u32, &(!is_header)),
|
|
|
|
(ColumnsDuplicates::SelectionButton as u32, &false),
|
|
|
|
(ColumnsDuplicates::Size as u32, &size_str),
|
|
|
|
(ColumnsDuplicates::SizeAsBytes as u32, &size),
|
|
|
|
(ColumnsDuplicates::Name as u32, &file),
|
|
|
|
(ColumnsDuplicates::Path as u32, &directory),
|
|
|
|
(ColumnsDuplicates::Modification as u32, &string_date),
|
|
|
|
(ColumnsDuplicates::ModificationAsSecs as u32, &modified_date),
|
|
|
|
(ColumnsDuplicates::Color as u32, &color),
|
|
|
|
(ColumnsDuplicates::IsHeader as u32, &is_header),
|
|
|
|
(ColumnsDuplicates::TextColor as u32, &TEXT_COLOR),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn similar_images_add_to_list_store(
|
|
|
|
list_store: &ListStore,
|
|
|
|
file: &str,
|
|
|
|
directory: &str,
|
|
|
|
size: u64,
|
|
|
|
modified_date: u64,
|
|
|
|
dimensions: &str,
|
|
|
|
similarity: u32,
|
|
|
|
hash_size: u8,
|
|
|
|
is_header: bool,
|
|
|
|
is_reference_folder: bool,
|
2021-12-22 06:44:20 +13:00
|
|
|
) {
|
2023-04-05 18:08:43 +12:00
|
|
|
const COLUMNS_NUMBER: usize = 13;
|
|
|
|
let size_str;
|
|
|
|
let string_date;
|
|
|
|
let similarity_string;
|
|
|
|
let color = if is_header { HEADER_ROW_COLOR } else { MAIN_ROW_COLOR };
|
2023-06-10 08:11:47 +12:00
|
|
|
|
|
|
|
if is_header {
|
|
|
|
similarity_string = String::new();
|
|
|
|
} else {
|
|
|
|
similarity_string = similar_images::get_string_from_similarity(&similarity, hash_size);
|
|
|
|
};
|
|
|
|
|
2023-04-05 18:08:43 +12:00
|
|
|
if is_header && !is_reference_folder {
|
|
|
|
size_str = String::new();
|
|
|
|
string_date = String::new();
|
|
|
|
} else {
|
|
|
|
size_str = format_size(size, BINARY);
|
|
|
|
string_date = NaiveDateTime::from_timestamp_opt(modified_date as i64, 0).unwrap().to_string();
|
2023-06-10 08:11:47 +12:00
|
|
|
}
|
2023-04-05 18:08:43 +12:00
|
|
|
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsSimilarImages::ActivatableSelectButton as u32, &(!is_header)),
|
|
|
|
(ColumnsSimilarImages::SelectionButton as u32, &false),
|
|
|
|
(ColumnsSimilarImages::Similarity as u32, &similarity_string),
|
|
|
|
(ColumnsSimilarImages::Size as u32, &size_str),
|
|
|
|
(ColumnsSimilarImages::SizeAsBytes as u32, &size),
|
|
|
|
(ColumnsSimilarImages::Dimensions as u32, &dimensions),
|
|
|
|
(ColumnsSimilarImages::Name as u32, &file),
|
|
|
|
(ColumnsSimilarImages::Path as u32, &directory),
|
|
|
|
(ColumnsSimilarImages::Modification as u32, &string_date),
|
|
|
|
(ColumnsSimilarImages::ModificationAsSecs as u32, &modified_date),
|
|
|
|
(ColumnsSimilarImages::Color as u32, &color),
|
|
|
|
(ColumnsSimilarImages::IsHeader as u32, &is_header),
|
|
|
|
(ColumnsSimilarImages::TextColor as u32, &TEXT_COLOR),
|
|
|
|
];
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn similar_videos_add_to_list_store(list_store: &ListStore, file: &str, directory: &str, size: u64, modified_date: u64, is_header: bool, is_reference_folder: bool) {
|
|
|
|
const COLUMNS_NUMBER: usize = 11;
|
|
|
|
let size_str;
|
|
|
|
let string_date;
|
|
|
|
let color = if is_header { HEADER_ROW_COLOR } else { MAIN_ROW_COLOR };
|
|
|
|
if is_header && !is_reference_folder {
|
|
|
|
size_str = String::new();
|
|
|
|
string_date = String::new();
|
|
|
|
} else {
|
|
|
|
size_str = format_size(size, BINARY);
|
|
|
|
string_date = NaiveDateTime::from_timestamp_opt(modified_date as i64, 0).unwrap().to_string();
|
|
|
|
};
|
|
|
|
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsSimilarVideos::ActivatableSelectButton as u32, &(!is_header)),
|
|
|
|
(ColumnsSimilarVideos::SelectionButton as u32, &false),
|
|
|
|
(ColumnsSimilarVideos::Size as u32, &size_str),
|
|
|
|
(ColumnsSimilarVideos::SizeAsBytes as u32, &size),
|
|
|
|
(ColumnsSimilarVideos::Name as u32, &file),
|
|
|
|
(ColumnsSimilarVideos::Path as u32, &directory),
|
|
|
|
(ColumnsSimilarVideos::Modification as u32, &string_date),
|
|
|
|
(ColumnsSimilarVideos::ModificationAsSecs as u32, &modified_date),
|
|
|
|
(ColumnsSimilarVideos::Color as u32, &color),
|
2023-07-10 18:36:03 +12:00
|
|
|
(ColumnsSimilarVideos::IsHeader as u32, &is_header),
|
2023-04-05 18:08:43 +12:00
|
|
|
(ColumnsSimilarVideos::TextColor as u32, &TEXT_COLOR),
|
|
|
|
];
|
|
|
|
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn same_music_add_to_list_store(
|
|
|
|
list_store: &ListStore,
|
|
|
|
file: &str,
|
|
|
|
directory: &str,
|
|
|
|
size: u64,
|
|
|
|
modified_date: u64,
|
|
|
|
track_title: &str,
|
|
|
|
track_artist: &str,
|
|
|
|
track_year: &str,
|
|
|
|
track_bitrate: u32,
|
|
|
|
bitrate_string: &str,
|
|
|
|
track_genre: &str,
|
|
|
|
track_length: &str,
|
|
|
|
is_header: bool,
|
|
|
|
is_reference_folder: bool,
|
|
|
|
) {
|
|
|
|
const COLUMNS_NUMBER: usize = 18;
|
|
|
|
let size_str;
|
|
|
|
let string_date;
|
|
|
|
let color = if is_header { HEADER_ROW_COLOR } else { MAIN_ROW_COLOR };
|
|
|
|
if is_header && !is_reference_folder {
|
|
|
|
size_str = String::new();
|
|
|
|
string_date = String::new();
|
|
|
|
} else {
|
|
|
|
size_str = format_size(size, BINARY);
|
|
|
|
string_date = NaiveDateTime::from_timestamp_opt(modified_date as i64, 0).unwrap().to_string();
|
|
|
|
};
|
|
|
|
|
|
|
|
let values: [(u32, &dyn ToValue); COLUMNS_NUMBER] = [
|
|
|
|
(ColumnsSameMusic::ActivatableSelectButton as u32, &(!is_header)),
|
|
|
|
(ColumnsSameMusic::SelectionButton as u32, &false),
|
|
|
|
(ColumnsSameMusic::Size as u32, &size_str),
|
|
|
|
(ColumnsSameMusic::SizeAsBytes as u32, &size),
|
|
|
|
(ColumnsSameMusic::Name as u32, &file),
|
|
|
|
(ColumnsSameMusic::Path as u32, &directory),
|
|
|
|
(ColumnsSameMusic::Title as u32, &track_title),
|
|
|
|
(ColumnsSameMusic::Artist as u32, &track_artist),
|
|
|
|
(ColumnsSameMusic::Year as u32, &track_year),
|
|
|
|
(ColumnsSameMusic::Genre as u32, &track_genre),
|
|
|
|
(ColumnsSameMusic::Bitrate as u32, &bitrate_string),
|
|
|
|
(ColumnsSameMusic::BitrateAsNumber as u32, &track_bitrate),
|
|
|
|
(ColumnsSameMusic::Length as u32, &track_length),
|
|
|
|
(ColumnsSameMusic::Modification as u32, &string_date),
|
|
|
|
(ColumnsSameMusic::ModificationAsSecs as u32, &modified_date),
|
|
|
|
(ColumnsSameMusic::Color as u32, &color),
|
|
|
|
(ColumnsSameMusic::IsHeader as u32, &is_header),
|
|
|
|
(ColumnsSameMusic::TextColor as u32, &TEXT_COLOR),
|
|
|
|
];
|
|
|
|
|
|
|
|
list_store.set(&list_store.append(), &values);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn set_specific_buttons_as_active(buttons_array: &Rc<RefCell<HashMap<NotebookMainEnum, HashMap<BottomButtonsEnum, bool>>>>, notebook_enum: &NotebookMainEnum, value_to_set: bool) {
|
|
|
|
let mut b_mut = buttons_array.borrow_mut();
|
|
|
|
let butt = b_mut.get_mut(notebook_enum).unwrap();
|
|
|
|
let allowed_buttons = NOTEBOOKS_INFO[*notebook_enum as usize].bottom_buttons;
|
|
|
|
for i in allowed_buttons {
|
|
|
|
*butt.get_mut(i).unwrap() = value_to_set;
|
2021-11-25 20:36:49 +13:00
|
|
|
}
|
|
|
|
}
|