CodeMirror/czkawka
1
0
Fork 0
mirror of synced 2024-06-01 18:19:46 +12:00
Code Issues Projects Releases Wiki Activity

Split into multiple files

Browse source
This commit is contained in:
Rafał Mikrut 2023-05-06 19:54:57 +02:00
parent fd38b4fac6
commit 5eb6d6fafe
11 changed files with 565 additions and 525 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
Cargo.lock generated
View file

@ -1780,9 +1780,9 @@ checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
[[package]] [[package]]
name = "libc" name = "libc"
version = "0.2.142" version = "0.2.143"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317" checksum = "edc207893e85c5d6be840e969b496b53d94cec8be2d501b214f50daa97fa8024"
[[package]] [[package]]
name = "libheif-rs" name = "libheif-rs"
@ -3178,9 +3178,9 @@ dependencies = [
[[package]] [[package]]
name = "time" name = "time"
version = "0.3.20" version = "0.3.21"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890" checksum = "8f3403384eaacbca9923fa06940178ac13e4edb725486d70e8e15881d0c836cc"
dependencies = [ dependencies = [
"serde", "serde",
"time-core", "time-core",
@ -3188,9 +3188,9 @@ dependencies = [
[[package]] [[package]]
name = "time-core" name = "time-core"
version = "0.1.0" version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd" checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
[[package]] [[package]]
name = "tinystr" name = "tinystr"
@ -3770,9 +3770,9 @@ dependencies = [
[[package]] [[package]]
name = "zip" name = "zip"
version = "0.6.4" version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0445d0fbc924bb93539b4316c11afb121ea39296f99a3c4c9edad09e3658cdef" checksum = "7e92305c174683d78035cbf1b70e18db6329cc0f1b9cae0a52ca90bf5bfe7125"
dependencies = [ dependencies = [
"aes 0.7.5", "aes 0.7.5",
"byteorder", "byteorder",
@ -3784,7 +3784,7 @@ dependencies = [
"hmac", "hmac",
"pbkdf2", "pbkdf2",
"sha1", "sha1",
"time 0.3.20", "time 0.3.21",
] ]
[[package]] [[package]]

3
czkawka_core/src/common.rs
View file

@ -373,7 +373,8 @@ where
entries_to_check entries_to_check
.into_iter() .into_iter()
.filter_map(|vec_file_entry| { .filter_map(|vec_file_entry| {
let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) = vec_file_entry.into_iter().partition(|e| directories.is_referenced_directory(e.get_path())); let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) =
vec_file_entry.into_iter().partition(|e| directories.is_in_referenced_directory(e.get_path()));
if files_from_referenced_folders.is_empty() || normal_files.is_empty() { if files_from_referenced_folders.is_empty() || normal_files.is_empty() {
None None

2
czkawka_core/src/common_dir_traversal.rs
View file

@ -34,6 +34,8 @@ pub enum CheckingMethod {
SizeName, SizeName,
Size, Size,
Hash, Hash,
AudioTags,
AudioContent,
} }
#[derive(Clone, Debug, Default, PartialEq, Eq)] #[derive(Clone, Debug, Default, PartialEq, Eq)]

2
czkawka_core/src/common_directory.rs
View file

@ -306,7 +306,7 @@ impl Directories {
} }
#[must_use] #[must_use]
pub fn is_referenced_directory(&self, path: &Path) -> bool { pub fn is_in_referenced_directory(&self, path: &Path) -> bool {
self.reference_directories.iter().any(|e| path.starts_with(e)) self.reference_directories.iter().any(|e| path.starts_with(e))
} }

25
czkawka_core/src/duplicate.rs
View file

@ -182,9 +182,7 @@ impl DuplicateFinder {
return; return;
} }
} }
CheckingMethod::None => { _ => panic!(),
panic!();
}
} }
self.delete_files(); self.delete_files();
self.debug_print(); self.debug_print();
@ -384,7 +382,7 @@ impl DuplicateFinder {
.into_iter() .into_iter()
.filter_map(|(_name, vec_file_entry)| { .filter_map(|(_name, vec_file_entry)| {
let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) = let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) =
vec_file_entry.into_iter().partition(|e| self.directories.is_referenced_directory(e.get_path())); vec_file_entry.into_iter().partition(|e| self.directories.is_in_referenced_directory(e.get_path()));
if files_from_referenced_folders.is_empty() || normal_files.is_empty() { if files_from_referenced_folders.is_empty() || normal_files.is_empty() {
None None
@ -464,7 +462,7 @@ impl DuplicateFinder {
.into_iter() .into_iter()
.filter_map(|(_size, vec_file_entry)| { .filter_map(|(_size, vec_file_entry)| {
let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) = let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) =
vec_file_entry.into_iter().partition(|e| self.directories.is_referenced_directory(e.get_path())); vec_file_entry.into_iter().partition(|e| self.directories.is_in_referenced_directory(e.get_path()));
if files_from_referenced_folders.is_empty() || normal_files.is_empty() { if files_from_referenced_folders.is_empty() || normal_files.is_empty() {
None None
@ -584,7 +582,7 @@ impl DuplicateFinder {
.into_iter() .into_iter()
.filter_map(|(_size, vec_file_entry)| { .filter_map(|(_size, vec_file_entry)| {
let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) = let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) =
vec_file_entry.into_iter().partition(|e| self.directories.is_referenced_directory(e.get_path())); vec_file_entry.into_iter().partition(|e| self.directories.is_in_referenced_directory(e.get_path()));
if files_from_referenced_folders.is_empty() || normal_files.is_empty() { if files_from_referenced_folders.is_empty() || normal_files.is_empty() {
None None
@ -921,7 +919,7 @@ impl DuplicateFinder {
let mut all_results_with_same_size = Vec::new(); let mut all_results_with_same_size = Vec::new();
for vec_file_entry in vec_vec_file_entry { for vec_file_entry in vec_vec_file_entry {
let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) = let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) =
vec_file_entry.into_iter().partition(|e| self.directories.is_referenced_directory(e.get_path())); vec_file_entry.into_iter().partition(|e| self.directories.is_in_referenced_directory(e.get_path()));
if files_from_referenced_folders.is_empty() || normal_files.is_empty() { if files_from_referenced_folders.is_empty() || normal_files.is_empty() {
continue; continue;
@ -1012,10 +1010,7 @@ impl DuplicateFinder {
let _tuple: (u64, usize, usize) = delete_files(vector, &self.delete_method, &mut self.text_messages, self.dryrun); let _tuple: (u64, usize, usize) = delete_files(vector, &self.delete_method, &mut self.text_messages, self.dryrun);
} }
} }
CheckingMethod::None => { _ => panic!(),
//Just do nothing
panic!("Checking method should never be none.");
}
} }
} }
} }
@ -1206,9 +1201,7 @@ impl SaveResults for DuplicateFinder {
write!(writer, "Not found any duplicates.").unwrap(); write!(writer, "Not found any duplicates.").unwrap();
} }
} }
CheckingMethod::None => { _ => panic!(),
panic!();
}
} }
true true
@ -1294,9 +1287,7 @@ impl PrintResults for DuplicateFinder {
println!(); println!();
} }
} }
CheckingMethod::None => { _ => panic!(),
panic!("Checking Method shouldn't be ever set to None");
}
} }
} }
} }

122
czkawka_core/src/same_music.rs
View file

@ -37,12 +37,6 @@ pub enum DeleteMethod {
Delete, Delete,
} }
#[derive(Eq, PartialEq, Clone, Debug, Copy)]
pub enum AudioCheckMethod {
Tags,
Content,
}
bitflags! { bitflags! {
#[derive(PartialEq, Copy, Clone, Debug)] #[derive(PartialEq, Copy, Clone, Debug)]
pub struct MusicSimilarity : u32 { pub struct MusicSimilarity : u32 {
@ -133,7 +127,7 @@ pub struct SameMusic {
delete_outdated_cache: bool, // TODO add this to GUI delete_outdated_cache: bool, // TODO add this to GUI
use_reference_folders: bool, use_reference_folders: bool,
save_also_as_json: bool, save_also_as_json: bool,
check_type: AudioCheckMethod, check_type: CheckingMethod,
hash_preset_config: Configuration, hash_preset_config: Configuration,
minimum_segment_duration: f32, minimum_segment_duration: f32,
maximum_difference: f64, maximum_difference: f64,
@ -163,7 +157,7 @@ impl SameMusic {
use_reference_folders: false, use_reference_folders: false,
duplicated_music_entries_referenced: vec![], duplicated_music_entries_referenced: vec![],
save_also_as_json: false, save_also_as_json: false,
check_type: AudioCheckMethod::Content, check_type: CheckingMethod::AudioContent,
hash_preset_config: Configuration::preset_test1(), // TODO allow to change this hash_preset_config: Configuration::preset_test1(), // TODO allow to change this
minimum_segment_duration: 10.0, minimum_segment_duration: 10.0,
maximum_difference: 2.0, maximum_difference: 2.0,
@ -178,7 +172,7 @@ impl SameMusic {
return; return;
} }
match self.check_type { match self.check_type {
AudioCheckMethod::Tags => { CheckingMethod::AudioTags => {
if !self.read_tags(stop_receiver, progress_sender) { if !self.read_tags(stop_receiver, progress_sender) {
self.stopped_search = true; self.stopped_search = true;
return; return;
@ -188,7 +182,7 @@ impl SameMusic {
return; return;
} }
} }
AudioCheckMethod::Content => { CheckingMethod::AudioContent => {
if !self.calculate_fingerprint(stop_receiver, progress_sender) { if !self.calculate_fingerprint(stop_receiver, progress_sender) {
self.stopped_search = true; self.stopped_search = true;
return; return;
@ -198,6 +192,7 @@ impl SameMusic {
return; return;
} }
} }
_ => panic!(),
} }
self.delete_files(); self.delete_files();
self.debug_print(); self.debug_print();
@ -703,51 +698,44 @@ impl SameMusic {
true true
} }
// fn split_fingerprints_to_check(&self) -> (Vec<MusicEntry>, Vec<MusicEntry>) { fn split_fingerprints_to_check(&mut self) -> (Vec<MusicEntry>, Vec<MusicEntry>) {
// let mut base_files: Vec<MusicEntry> = Vec::new(); let base_files: Vec<MusicEntry>;
// let mut files_to_compare: Vec<MusicEntry> = Vec::new(); let files_to_compare: Vec<MusicEntry>;
//
// if self.use_reference_folders {
// // base_files =
// } else {
// base_files = self.music_entries.clone();
// files_to_compare = self.music_entries.clone();
// }
//
// (base_files, files_to_compare)
// }
// fn compare_improved(&mut self, stop_receiver: Option<&Receiver<()>>, atomic_counter: &Arc<AtomicUsize>) -> Option<Vec<Vec<MusicEntry>>> {} if self.use_reference_folders {
(base_files, files_to_compare) = mem::take(&mut self.music_entries)
.into_iter()
.partition(|f| self.directories.is_in_referenced_directory(f.get_path()));
} else {
base_files = self.music_entries.clone();
files_to_compare = mem::take(&mut self.music_entries);
}
(base_files, files_to_compare)
}
fn compare_fingerprints(&mut self, stop_receiver: Option<&Receiver<()>>, atomic_counter: &Arc<AtomicUsize>) -> Option<Vec<Vec<MusicEntry>>> { fn compare_fingerprints(&mut self, stop_receiver: Option<&Receiver<()>>, atomic_counter: &Arc<AtomicUsize>) -> Option<Vec<Vec<MusicEntry>>> {
// TODO do optimization
// Multithreading
// Grouping same hashes(not sure how common, but probably with a lot of files can save some time)
// Better algorithm of finding similar fingerprints
let mut used_paths: HashSet<String> = Default::default(); let mut used_paths: HashSet<String> = Default::default();
let (base_files, files_to_compare) = self.split_fingerprints_to_check();
let configuration = &self.hash_preset_config; let configuration = &self.hash_preset_config;
let minimum_segment_duration = self.minimum_segment_duration; let minimum_segment_duration = self.minimum_segment_duration;
let maximum_difference = self.maximum_difference; let maximum_difference = self.maximum_difference;
let mut duplicated_music_entries = Vec::new(); let mut duplicated_music_entries = Vec::new();
for (f_idx, f_entry) in self.music_entries.iter().enumerate() { for f_entry in base_files {
if f_idx + 1 == self.music_entries.len() { atomic_counter.fetch_add(1, Ordering::Relaxed);
break;
}
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() { if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
return None; return None;
} }
atomic_counter.fetch_add(1, Ordering::Relaxed);
let f_string = f_entry.path.to_string_lossy().to_string(); let f_string = f_entry.path.to_string_lossy().to_string();
if used_paths.contains(&f_string) { if used_paths.contains(&f_string) {
continue; continue;
} }
let mut collected_similar_items = self.music_entries[f_idx + 1..] let mut collected_similar_items = files_to_compare
.par_iter() .par_iter()
.filter_map(|e_entry| { .filter_map(|e_entry| {
let e_string = e_entry.path.to_string_lossy().to_string(); let e_string = e_entry.path.to_string_lossy().to_string();
@ -779,6 +767,66 @@ impl SameMusic {
Some(duplicated_music_entries) Some(duplicated_music_entries)
} }
// fn compare_fingerprints(&mut self, stop_receiver: Option<&Receiver<()>>, atomic_counter: &Arc<AtomicUsize>) -> Option<Vec<Vec<MusicEntry>>> {
// // TODO do optimization
// // Multithreading
// // Grouping same hashes(not sure how common, but probably with a lot of files can save some time)
// // Better algorithm of finding similar fingerprints
//
// let mut used_paths: HashSet<String> = Default::default();
// let configuration = &self.hash_preset_config;
// let minimum_segment_duration = self.minimum_segment_duration;
// let maximum_difference = self.maximum_difference;
//
// let mut duplicated_music_entries = Vec::new();
//
// for (f_idx, f_entry) in self.music_entries.iter().enumerate() {
// if f_idx + 1 == self.music_entries.len() {
// break;
// }
//
// if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
// return None;
// }
// atomic_counter.fetch_add(1, Ordering::Relaxed);
//
// let f_string = f_entry.path.to_string_lossy().to_string();
// if used_paths.contains(&f_string) {
// continue;
// }
//
// let mut collected_similar_items = self.music_entries[f_idx + 1..]
// .par_iter()
// .filter_map(|e_entry| {
// let e_string = e_entry.path.to_string_lossy().to_string();
// if used_paths.contains(&e_string) {
// return None;
// }
// let mut segments = match_fingerprints(&f_entry.fingerprint, &e_entry.fingerprint, configuration).unwrap();
// segments.retain(|s| s.duration(configuration) > minimum_segment_duration && s.score < maximum_difference);
// if segments.is_empty() {
// None
// } else {
// Some((e_string, e_entry))
// }
// })
// .collect::<Vec<_>>();
//
// collected_similar_items.retain(|(path, _entry)| !used_paths.contains(path));
// if !collected_similar_items.is_empty() {
// let mut music_entries = Vec::new();
// for (path, entry) in collected_similar_items {
// used_paths.insert(path);
// music_entries.push(entry.clone());
// }
// used_paths.insert(f_string);
// music_entries.push(f_entry.clone());
// duplicated_music_entries.push(music_entries);
// }
// }
// Some(duplicated_music_entries)
// }
fn check_for_duplicate_fingerprints(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool { fn check_for_duplicate_fingerprints(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
assert_ne!(MusicSimilarity::NONE, self.music_similarity, "This can't be none"); assert_ne!(MusicSimilarity::NONE, self.music_similarity, "This can't be none");
@ -801,9 +849,7 @@ impl SameMusic {
send_info_and_wait_for_ending_all_threads(&progress_thread_run, progress_thread_handle); send_info_and_wait_for_ending_all_threads(&progress_thread_run, progress_thread_handle);
// TODO fill this with proper values
self.duplicated_music_entries = duplicated_music_entries; self.duplicated_music_entries = duplicated_music_entries;
// Use
if self.use_reference_folders { if self.use_reference_folders {
self.duplicated_music_entries_referenced = filter_reference_folders_generic(mem::take(&mut self.duplicated_music_entries), &self.directories); self.duplicated_music_entries_referenced = filter_reference_folders_generic(mem::take(&mut self.duplicated_music_entries), &self.directories);

2
czkawka_core/src/similar_images.rs
View file

@ -913,7 +913,7 @@ impl SimilarImages {
.into_iter() .into_iter()
.filter_map(|vec_file_entry| { .filter_map(|vec_file_entry| {
let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) = let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) =
vec_file_entry.into_iter().partition(|e| self.directories.is_referenced_directory(e.get_path())); vec_file_entry.into_iter().partition(|e| self.directories.is_in_referenced_directory(e.get_path()));
if files_from_referenced_folders.is_empty() || normal_files.is_empty() { if files_from_referenced_folders.is_empty() || normal_files.is_empty() {
None None

2
czkawka_core/src/similar_videos.rs
View file

@ -517,7 +517,7 @@ impl SimilarVideos {
.into_iter() .into_iter()
.filter_map(|vec_file_entry| { .filter_map(|vec_file_entry| {
let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) = let (mut files_from_referenced_folders, normal_files): (Vec<_>, Vec<_>) =
vec_file_entry.into_iter().partition(|e| self.directories.is_referenced_directory(e.get_path())); vec_file_entry.into_iter().partition(|e| self.directories.is_in_referenced_directory(e.get_path()));
if files_from_referenced_folders.is_empty() || normal_files.is_empty() { if files_from_referenced_folders.is_empty() || normal_files.is_empty() {
None None

6
czkawka_gui/src/compute_results.rs
View file

@ -1164,7 +1164,7 @@ fn computer_duplicate_finder(
duplicates_size = information.lost_space_by_size; duplicates_size = information.lost_space_by_size;
duplicates_group = information.number_of_groups_by_size_name; duplicates_group = information.number_of_groups_by_size_name;
} }
CheckingMethod::None => { _ => {
panic!(); panic!();
} }
} }
@ -1251,7 +1251,7 @@ fn computer_duplicate_finder(
} }
} }
} }
CheckingMethod::None => { _ => {
panic!(); panic!();
} }
} }
@ -1310,7 +1310,7 @@ fn computer_duplicate_finder(
} }
} }
} }
CheckingMethod::None => { _ => {
panic!(); panic!();
} }
} }

906
czkawka_gui/src/connect_things/connect_progress_window.rs
View file

@ -1,5 +1,7 @@
use common_dir_traversal::CheckingMethod;
use futures::channel::mpsc::UnboundedReceiver; use futures::channel::mpsc::UnboundedReceiver;
use futures::StreamExt; use futures::StreamExt;
use glib::MainContext;
use gtk4::prelude::*; use gtk4::prelude::*;
use czkawka_core::common_dir_traversal; use czkawka_core::common_dir_traversal;
@ -13,460 +15,458 @@ use crate::taskbar_progress::tbp_flags::TBPF_INDETERMINATE;
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn connect_progress_window( pub fn connect_progress_window(
gui_data: &GuiData, gui_data: &GuiData,
mut futures_receiver_duplicate_files: UnboundedReceiver<ProgressData>, futures_receiver_duplicate_files: UnboundedReceiver<ProgressData>,
mut futures_receiver_empty_files: UnboundedReceiver<ProgressData>, futures_receiver_empty_files: UnboundedReceiver<ProgressData>,
mut futures_receiver_empty_folder: UnboundedReceiver<ProgressData>, futures_receiver_empty_folder: UnboundedReceiver<ProgressData>,
mut futures_receiver_big_files: UnboundedReceiver<ProgressData>, futures_receiver_big_files: UnboundedReceiver<ProgressData>,
mut futures_receiver_same_music: UnboundedReceiver<ProgressData>, futures_receiver_same_music: UnboundedReceiver<ProgressData>,
mut futures_receiver_similar_images: UnboundedReceiver<ProgressData>, futures_receiver_similar_images: UnboundedReceiver<ProgressData>,
mut futures_receiver_similar_videos: UnboundedReceiver<ProgressData>, futures_receiver_similar_videos: UnboundedReceiver<ProgressData>,
mut futures_receiver_temporary: UnboundedReceiver<ProgressData>, futures_receiver_temporary: UnboundedReceiver<ProgressData>,
mut futures_receiver_invalid_symlinks: UnboundedReceiver<ProgressData>, futures_receiver_invalid_symlinks: UnboundedReceiver<ProgressData>,
mut futures_receiver_broken_files: UnboundedReceiver<ProgressData>, futures_receiver_broken_files: UnboundedReceiver<ProgressData>,
mut futures_receiver_bad_extensions: UnboundedReceiver<ProgressData>, futures_receiver_bad_extensions: UnboundedReceiver<ProgressData>,
) { ) {
let main_context = glib::MainContext::default(); let main_context = MainContext::default();
let _guard = main_context.acquire().unwrap(); let _guard = main_context.acquire().unwrap();
{ process_bar_duplicates(gui_data, &main_context, futures_receiver_duplicate_files);
// Duplicate Files process_bar_empty_files(gui_data, &main_context, futures_receiver_empty_files);
let label_stage = gui_data.progress_window.label_stage.clone(); process_bar_empty_folder(gui_data, &main_context, futures_receiver_empty_folder);
let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone(); process_bar_big_files(gui_data, &main_context, futures_receiver_big_files);
let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone(); process_bar_same_music(gui_data, &main_context, futures_receiver_same_music);
let grid_progress_stages = gui_data.progress_window.grid_progress_stages.clone(); process_bar_similar_images(gui_data, &main_context, futures_receiver_similar_images);
let taskbar_state = gui_data.taskbar_state.clone(); process_bar_similar_videos(gui_data, &main_context, futures_receiver_similar_videos);
let future = async move { process_bar_temporary(gui_data, &main_context, futures_receiver_temporary);
while let Some(item) = futures_receiver_duplicate_files.next().await { process_bar_invalid_symlinks(gui_data, &main_context, futures_receiver_invalid_symlinks);
match item.checking_method { process_bar_broken_files(gui_data, &main_context, futures_receiver_broken_files);
common_dir_traversal::CheckingMethod::Hash => { process_bar_bad_extensions(gui_data, &main_context, futures_receiver_bad_extensions);
label_stage.show(); }
match item.current_stage { fn process_bar_empty_files(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_empty_files: UnboundedReceiver<ProgressData>) {
// Checking Size let label_stage = gui_data.progress_window.label_stage.clone();
0 => { let taskbar_state = gui_data.taskbar_state.clone();
progress_bar_current_stage.hide(); let future = async move {
// progress_bar_all_stages.hide(); while let Some(item) = futures_receiver_empty_files.next().await {
progress_bar_all_stages.set_fraction(0 as f64); label_stage.set_text(&flg!(
label_stage.set_text(&flg!( "progress_scanning_general_file",
"progress_scanning_size", generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) ));
)); taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); }
} };
// Hash - first 1KB file main_context.spawn_local(future);
1 => { }
progress_bar_current_stage.show(); fn process_bar_empty_folder(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_empty_folder: UnboundedReceiver<ProgressData>) {
// progress_bar_all_stages.show(); let label_stage = gui_data.progress_window.label_stage.clone();
if item.entries_to_check != 0 { let taskbar_state = gui_data.taskbar_state.clone();
progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64); let future = async move {
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); while let Some(item) = futures_receiver_empty_folder.next().await {
taskbar_state.borrow().set_progress_value( label_stage.set_text(&flg!(
(item.entries_to_check + item.entries_checked) as u64, "progress_scanning_empty_folders",
item.entries_to_check as u64 * (item.max_stage + 1) as u64, generate_translation_hashmap(vec![("folder_number", item.entries_checked.to_string())])
); ));
} else { taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64); }
progress_bar_current_stage.set_fraction(0f64); };
taskbar_state.borrow().set_progress_value(1, 1 + item.max_stage as u64); main_context.spawn_local(future);
} }
fn process_bar_big_files(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_big_files: UnboundedReceiver<ProgressData>) {
label_stage.set_text(&flg!( let label_stage = gui_data.progress_window.label_stage.clone();
"progress_analyzed_partial_hash", let taskbar_state = gui_data.taskbar_state.clone();
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) let future = async move {
)); while let Some(item) = futures_receiver_big_files.next().await {
} label_stage.set_text(&flg!(
// Hash - normal hash "progress_scanning_general_file",
2 => { generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
if item.entries_to_check != 0 { ));
progress_bar_all_stages.set_fraction((2f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64); taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); }
taskbar_state.borrow().set_progress_value( };
(2 * item.entries_to_check + item.entries_checked) as u64, main_context.spawn_local(future);
item.entries_to_check as u64 * (item.max_stage + 1) as u64, }
); fn process_bar_same_music(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_same_music: UnboundedReceiver<ProgressData>) {
} else { let label_stage = gui_data.progress_window.label_stage.clone();
progress_bar_all_stages.set_fraction((2f64) / (item.max_stage + 1) as f64); let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
progress_bar_current_stage.set_fraction(0f64); let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
taskbar_state.borrow().set_progress_value(2, 1 + item.max_stage as u64); let taskbar_state = gui_data.taskbar_state.clone();
} let future = async move {
while let Some(item) = futures_receiver_same_music.next().await {
label_stage.set_text(&flg!( match item.current_stage {
"progress_analyzed_full_hash", 0 => {
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) progress_bar_current_stage.hide();
)); label_stage.set_text(&flg!(
} "progress_scanning_general_file",
_ => { generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
panic!("Not available current_stage"); ));
} taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
} }
} 1 => {
common_dir_traversal::CheckingMethod::Name => { progress_bar_current_stage.show();
label_stage.show(); if item.entries_to_check != 0 {
grid_progress_stages.hide(); progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
label_stage.set_text(&flg!( taskbar_state.borrow().set_progress_value(
"progress_scanning_name", (item.entries_to_check + item.entries_checked) as u64,
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) item.entries_to_check as u64 * (item.max_stage + 1) as u64,
)); );
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); } else {
} progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64);
common_dir_traversal::CheckingMethod::SizeName => { progress_bar_current_stage.set_fraction(0f64);
label_stage.show(); taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64);
grid_progress_stages.hide(); }
label_stage.set_text(&flg!(
label_stage.set_text(&flg!( "progress_scanning_music_tags",
"progress_scanning_size_name", generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) ));
)); }
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); 2 => {
} if item.entries_to_check != 0 {
common_dir_traversal::CheckingMethod::Size => { progress_bar_all_stages.set_fraction((2f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
label_stage.show(); progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
grid_progress_stages.hide(); taskbar_state.borrow().set_progress_value(
(2 * item.entries_to_check + item.entries_checked) as u64,
label_stage.set_text(&flg!( item.entries_to_check as u64 * (item.max_stage + 1) as u64,
"progress_scanning_size", );
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) } else {
)); progress_bar_all_stages.set_fraction((2f64) / (item.max_stage + 1) as f64);
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); progress_bar_current_stage.set_fraction(0f64);
} taskbar_state.borrow().set_progress_value(2, (item.max_stage + 1) as u64);
common_dir_traversal::CheckingMethod::None => { }
panic!(); label_stage.set_text(&flg!(
} "progress_scanning_music_tags_end",
}; generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
} ));
}; }
main_context.spawn_local(future); _ => {
} panic!();
{ }
// Empty Files }
let label_stage = gui_data.progress_window.label_stage.clone(); }
let taskbar_state = gui_data.taskbar_state.clone(); };
let future = async move { main_context.spawn_local(future);
while let Some(item) = futures_receiver_empty_files.next().await { }
label_stage.set_text(&flg!( fn process_bar_similar_images(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_similar_images: UnboundedReceiver<ProgressData>) {
"progress_scanning_general_file", let label_stage = gui_data.progress_window.label_stage.clone();
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
)); let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); let taskbar_state = gui_data.taskbar_state.clone();
} let future = async move {
}; while let Some(item) = futures_receiver_similar_images.next().await {
main_context.spawn_local(future); match item.current_stage {
} 0 => {
{ progress_bar_current_stage.hide();
// Empty Folder label_stage.set_text(&flg!(
let label_stage = gui_data.progress_window.label_stage.clone(); "progress_scanning_general_file",
let taskbar_state = gui_data.taskbar_state.clone(); generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
let future = async move { ));
while let Some(item) = futures_receiver_empty_folder.next().await { taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
label_stage.set_text(&flg!( }
"progress_scanning_empty_folders", 1 => {
generate_translation_hashmap(vec![("folder_number", item.entries_checked.to_string())]) progress_bar_current_stage.show();
)); if item.entries_to_check != 0 {
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
} progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
}; taskbar_state.borrow().set_progress_value(
main_context.spawn_local(future); (item.entries_to_check + item.entries_checked) as u64,
} item.entries_to_check as u64 * (item.max_stage + 1) as u64,
{ );
// Big Files } else {
let label_stage = gui_data.progress_window.label_stage.clone(); progress_bar_all_stages.set_fraction((item.current_stage as f64) / (item.max_stage + 1) as f64);
let taskbar_state = gui_data.taskbar_state.clone(); progress_bar_current_stage.set_fraction(0f64);
let future = async move { taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64);
while let Some(item) = futures_receiver_big_files.next().await { }
label_stage.set_text(&flg!( label_stage.set_text(&flg!(
"progress_scanning_general_file", "progress_scanning_image",
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
)); ));
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); }
} 2 => {
}; progress_bar_current_stage.show();
main_context.spawn_local(future); if item.entries_to_check != 0 {
} progress_bar_all_stages.set_fraction((2f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
{ progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
// Same Music taskbar_state.borrow().set_progress_value(
let label_stage = gui_data.progress_window.label_stage.clone(); (item.entries_to_check + item.entries_checked) as u64,
let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone(); item.entries_to_check as u64 * (item.max_stage + 1) as u64,
let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone(); );
let taskbar_state = gui_data.taskbar_state.clone(); } else {
let future = async move { progress_bar_all_stages.set_fraction((item.current_stage as f64) / (item.max_stage + 1) as f64);
while let Some(item) = futures_receiver_same_music.next().await { progress_bar_current_stage.set_fraction(0f64);
match item.current_stage { taskbar_state.borrow().set_progress_value(2, (item.max_stage + 1) as u64);
0 => { }
progress_bar_current_stage.hide(); label_stage.set_text(&flg!(
label_stage.set_text(&flg!( "progress_comparing_image_hashes",
"progress_scanning_general_file", generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) ));
)); }
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); _ => {
} panic!();
1 => { }
progress_bar_current_stage.show(); }
if item.entries_to_check != 0 { }
progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64); };
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); main_context.spawn_local(future);
taskbar_state.borrow().set_progress_value( }
(item.entries_to_check + item.entries_checked) as u64, fn process_bar_similar_videos(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_similar_videos: UnboundedReceiver<ProgressData>) {
item.entries_to_check as u64 * (item.max_stage + 1) as u64, let label_stage = gui_data.progress_window.label_stage.clone();
); let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
} else { let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64); let taskbar_state = gui_data.taskbar_state.clone();
progress_bar_current_stage.set_fraction(0f64); let future = async move {
taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64); while let Some(item) = futures_receiver_similar_videos.next().await {
} match item.current_stage {
label_stage.set_text(&flg!( 0 => {
"progress_scanning_music_tags", progress_bar_current_stage.hide();
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) label_stage.set_text(&flg!(
)); "progress_scanning_general_file",
} generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
2 => { ));
if item.entries_to_check != 0 { taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
progress_bar_all_stages.set_fraction((2f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64); }
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); 1 => {
taskbar_state.borrow().set_progress_value( progress_bar_current_stage.show();
(2 * item.entries_to_check + item.entries_checked) as u64, if item.entries_to_check != 0 {
item.entries_to_check as u64 * (item.max_stage + 1) as u64, progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
); progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
} else { taskbar_state.borrow().set_progress_value(
progress_bar_all_stages.set_fraction((2f64) / (item.max_stage + 1) as f64); (item.entries_to_check + item.entries_checked) as u64,
progress_bar_current_stage.set_fraction(0f64); item.entries_to_check as u64 * (item.max_stage + 1) as u64,
taskbar_state.borrow().set_progress_value(2, (item.max_stage + 1) as u64); );
} } else {
label_stage.set_text(&flg!( progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64);
"progress_scanning_music_tags_end", progress_bar_current_stage.set_fraction(0f64);
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64);
)); }
} label_stage.set_text(&flg!(
_ => { "progress_scanning_video",
panic!(); generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
} ));
} }
} _ => {
}; panic!();
main_context.spawn_local(future); }
} }
{ }
// Similar Images };
let label_stage = gui_data.progress_window.label_stage.clone(); main_context.spawn_local(future);
let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone(); }
let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone(); fn process_bar_temporary(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_temporary: UnboundedReceiver<ProgressData>) {
let taskbar_state = gui_data.taskbar_state.clone(); let label_stage = gui_data.progress_window.label_stage.clone();
let future = async move { let taskbar_state = gui_data.taskbar_state.clone();
while let Some(item) = futures_receiver_similar_images.next().await { let future = async move {
match item.current_stage { while let Some(item) = futures_receiver_temporary.next().await {
0 => { label_stage.set_text(&flg!(
progress_bar_current_stage.hide(); "progress_scanning_general_file",
label_stage.set_text(&flg!( generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
"progress_scanning_general_file", ));
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
)); }
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); };
} main_context.spawn_local(future);
1 => { }
progress_bar_current_stage.show(); fn process_bar_invalid_symlinks(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_invalid_symlinks: UnboundedReceiver<ProgressData>) {
if item.entries_to_check != 0 { let label_stage = gui_data.progress_window.label_stage.clone();
progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64); let taskbar_state = gui_data.taskbar_state.clone();
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); let future = async move {
taskbar_state.borrow().set_progress_value( while let Some(item) = futures_receiver_invalid_symlinks.next().await {
(item.entries_to_check + item.entries_checked) as u64, label_stage.set_text(&flg!(
item.entries_to_check as u64 * (item.max_stage + 1) as u64, "progress_scanning_general_file",
); generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
} else { ));
progress_bar_all_stages.set_fraction((item.current_stage as f64) / (item.max_stage + 1) as f64); taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
progress_bar_current_stage.set_fraction(0f64); }
taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64); };
} main_context.spawn_local(future);
label_stage.set_text(&flg!( }
"progress_scanning_image", fn process_bar_broken_files(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_broken_files: UnboundedReceiver<ProgressData>) {
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) let label_stage = gui_data.progress_window.label_stage.clone();
)); let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
} let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
2 => { let taskbar_state = gui_data.taskbar_state.clone();
progress_bar_current_stage.show(); let future = async move {
if item.entries_to_check != 0 { while let Some(item) = futures_receiver_broken_files.next().await {
progress_bar_all_stages.set_fraction((2f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64); match item.current_stage {
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); 0 => {
taskbar_state.borrow().set_progress_value( progress_bar_current_stage.hide();
(item.entries_to_check + item.entries_checked) as u64, label_stage.set_text(&flg!(
item.entries_to_check as u64 * (item.max_stage + 1) as u64, "progress_scanning_general_file",
); generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
} else { ));
progress_bar_all_stages.set_fraction((item.current_stage as f64) / (item.max_stage + 1) as f64); taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
progress_bar_current_stage.set_fraction(0f64); }
taskbar_state.borrow().set_progress_value(2, (item.max_stage + 1) as u64); 1 => {
} progress_bar_current_stage.show();
label_stage.set_text(&flg!( if item.entries_to_check != 0 {
"progress_comparing_image_hashes", progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
)); taskbar_state.borrow().set_progress_value(
} (item.entries_to_check + item.entries_checked) as u64,
_ => { item.entries_to_check as u64 * (item.max_stage + 1) as u64,
panic!(); );
} } else {
} progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64);
} progress_bar_current_stage.set_fraction(0f64);
}; taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64);
main_context.spawn_local(future); }
} label_stage.set_text(&flg!(
{ "progress_scanning_broken_files",
// Similar Videos generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
let label_stage = gui_data.progress_window.label_stage.clone(); ));
let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone(); }
let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone(); _ => {
let taskbar_state = gui_data.taskbar_state.clone(); panic!();
let future = async move { }
while let Some(item) = futures_receiver_similar_videos.next().await { }
match item.current_stage { }
0 => { };
progress_bar_current_stage.hide(); main_context.spawn_local(future);
label_stage.set_text(&flg!( }
"progress_scanning_general_file", fn process_bar_bad_extensions(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_bad_extensions: UnboundedReceiver<ProgressData>) {
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) let label_stage = gui_data.progress_window.label_stage.clone();
)); let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
} let taskbar_state = gui_data.taskbar_state.clone();
1 => { let future = async move {
progress_bar_current_stage.show(); while let Some(item) = futures_receiver_bad_extensions.next().await {
if item.entries_to_check != 0 { match item.current_stage {
progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64); 0 => {
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); progress_bar_current_stage.hide();
taskbar_state.borrow().set_progress_value( label_stage.set_text(&flg!(
(item.entries_to_check + item.entries_checked) as u64, "progress_scanning_general_file",
item.entries_to_check as u64 * (item.max_stage + 1) as u64, generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
); ));
} else { taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64); }
progress_bar_current_stage.set_fraction(0f64); 1 => {
taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64); progress_bar_current_stage.show();
} if item.entries_to_check != 0 {
label_stage.set_text(&flg!( progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
"progress_scanning_video", progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) taskbar_state.borrow().set_progress_value(
)); (item.entries_to_check + item.entries_checked) as u64,
} item.entries_to_check as u64 * (item.max_stage + 1) as u64,
_ => { );
panic!(); } else {
} progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64);
} progress_bar_current_stage.set_fraction(0f64);
} taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64);
}; }
main_context.spawn_local(future); label_stage.set_text(&flg!(
} "progress_scanning_extension_of_files",
{ generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
// Temporary ));
let label_stage = gui_data.progress_window.label_stage.clone(); }
let taskbar_state = gui_data.taskbar_state.clone(); _ => {
let future = async move { panic!();
while let Some(item) = futures_receiver_temporary.next().await { }
label_stage.set_text(&flg!( }
"progress_scanning_general_file", }
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) };
)); main_context.spawn_local(future);
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); }
} fn process_bar_duplicates(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_duplicate_files: UnboundedReceiver<ProgressData>) {
}; let label_stage = gui_data.progress_window.label_stage.clone();
main_context.spawn_local(future); let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
} let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
{ let grid_progress_stages = gui_data.progress_window.grid_progress_stages.clone();
// Invalid Symlinks let taskbar_state = gui_data.taskbar_state.clone();
let label_stage = gui_data.progress_window.label_stage.clone(); let future = async move {
let taskbar_state = gui_data.taskbar_state.clone(); while let Some(item) = futures_receiver_duplicate_files.next().await {
let future = async move { match item.checking_method {
while let Some(item) = futures_receiver_invalid_symlinks.next().await { CheckingMethod::Hash => {
label_stage.set_text(&flg!( label_stage.show();
"progress_scanning_general_file", match item.current_stage {
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) // Checking Size
)); 0 => {
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); progress_bar_current_stage.hide();
} // progress_bar_all_stages.hide();
}; progress_bar_all_stages.set_fraction(0 as f64);
main_context.spawn_local(future); label_stage.set_text(&flg!(
} "progress_scanning_size",
{ generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
// Broken Files ));
let label_stage = gui_data.progress_window.label_stage.clone(); taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone(); }
let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone(); // Hash - first 1KB file
let taskbar_state = gui_data.taskbar_state.clone(); 1 => {
let future = async move { progress_bar_current_stage.show();
while let Some(item) = futures_receiver_broken_files.next().await { // progress_bar_all_stages.show();
match item.current_stage { if item.entries_to_check != 0 {
0 => { progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
progress_bar_current_stage.hide(); progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
label_stage.set_text(&flg!( taskbar_state.borrow().set_progress_value(
"progress_scanning_general_file", (item.entries_to_check + item.entries_checked) as u64,
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) item.entries_to_check as u64 * (item.max_stage + 1) as u64,
)); );
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); } else {
} progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64);
1 => { progress_bar_current_stage.set_fraction(0f64);
progress_bar_current_stage.show(); taskbar_state.borrow().set_progress_value(1, 1 + item.max_stage as u64);
if item.entries_to_check != 0 { }
progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); label_stage.set_text(&flg!(
taskbar_state.borrow().set_progress_value( "progress_analyzed_partial_hash",
(item.entries_to_check + item.entries_checked) as u64, generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
item.entries_to_check as u64 * (item.max_stage + 1) as u64, ));
); }
} else { // Hash - normal hash
progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64); 2 => {
progress_bar_current_stage.set_fraction(0f64); if item.entries_to_check != 0 {
taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64); progress_bar_all_stages.set_fraction((2f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
} progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
label_stage.set_text(&flg!( taskbar_state.borrow().set_progress_value(
"progress_scanning_broken_files", (2 * item.entries_to_check + item.entries_checked) as u64,
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) item.entries_to_check as u64 * (item.max_stage + 1) as u64,
)); );
} } else {
_ => { progress_bar_all_stages.set_fraction((2f64) / (item.max_stage + 1) as f64);
panic!(); progress_bar_current_stage.set_fraction(0f64);
} taskbar_state.borrow().set_progress_value(2, 1 + item.max_stage as u64);
} }
}
}; label_stage.set_text(&flg!(
main_context.spawn_local(future); "progress_analyzed_full_hash",
} generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
{ ));
// Broken Files }
let label_stage = gui_data.progress_window.label_stage.clone(); _ => {
let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone(); panic!("Not available current_stage");
let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone(); }
let taskbar_state = gui_data.taskbar_state.clone(); }
let future = async move { }
while let Some(item) = futures_receiver_bad_extensions.next().await { CheckingMethod::Name => {
match item.current_stage { label_stage.show();
0 => { grid_progress_stages.hide();
progress_bar_current_stage.hide();
label_stage.set_text(&flg!( label_stage.set_text(&flg!(
"progress_scanning_general_file", "progress_scanning_name",
generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())]) generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
)); ));
taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE); taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
} }
1 => { CheckingMethod::SizeName => {
progress_bar_current_stage.show(); label_stage.show();
if item.entries_to_check != 0 { grid_progress_stages.hide();
progress_bar_all_stages.set_fraction((1f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64); label_stage.set_text(&flg!(
taskbar_state.borrow().set_progress_value( "progress_scanning_size_name",
(item.entries_to_check + item.entries_checked) as u64, generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
item.entries_to_check as u64 * (item.max_stage + 1) as u64, ));
); taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
} else { }
progress_bar_all_stages.set_fraction((1f64) / (item.max_stage + 1) as f64); CheckingMethod::Size => {
progress_bar_current_stage.set_fraction(0f64); label_stage.show();
taskbar_state.borrow().set_progress_value(1, (item.max_stage + 1) as u64); grid_progress_stages.hide();
}
label_stage.set_text(&flg!( label_stage.set_text(&flg!(
"progress_scanning_extension_of_files", "progress_scanning_size",
generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())]) generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
)); ));
} taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
_ => { }
panic!(); _ => panic!(),
} };
} }
} };
}; main_context.spawn_local(future);
main_context.spawn_local(future);
}
} }

2
czkawka_gui/src/gui_structs/gui_main_notebook.rs
View file

@ -550,7 +550,7 @@ impl GuiMainNotebook {
CheckingMethod::Size => flg!("duplicate_mode_size_combo_box"), CheckingMethod::Size => flg!("duplicate_mode_size_combo_box"),
CheckingMethod::Name => flg!("duplicate_mode_name_combo_box"), CheckingMethod::Name => flg!("duplicate_mode_name_combo_box"),
CheckingMethod::SizeName => flg!("duplicate_mode_size_name_combo_box"), CheckingMethod::SizeName => flg!("duplicate_mode_size_name_combo_box"),
CheckingMethod::None => panic!(), _ => panic!(),
}; };
self.combo_box_duplicate_check_method.append_text(&text); self.combo_box_duplicate_check_method.append_text(&text);
} }