wallswitch 0.55.0

randomly selects wallpapers for multiple monitors
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use crate::{Colors, FileInfo, SliceDisplay, WallSwitchResult};
use serde::{Deserialize, Serialize};
use std::str::FromStr;

#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum SortCriteria {
    Path,
    Size,
    Name,
    Extension,
}

impl FromStr for SortCriteria {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "path" => Ok(Self::Path),
            "size" => Ok(Self::Size),
            "name" => Ok(Self::Name),
            "extension" => Ok(Self::Extension),
            _ => Err("Invalid sort criteria. Use: path, size, name, extension".to_string()),
        }
    }
}

/// Sorts and displays all found images based on the chosen criteria, then exits.
pub fn list_all_images(mut images: Vec<FileInfo>, criteria: SortCriteria) -> WallSwitchResult<()> {
    match criteria {
        SortCriteria::Size => {
            images.sort_by_key(|f| f.size);
            println!("Listing images sorted by {}:", "SIZE".yellow().bold());
        }
        SortCriteria::Path => {
            images.sort_by(|a, b| a.path.cmp(&b.path));
            println!("Listing images sorted by {}:", "PATH".yellow().bold());
        }
        SortCriteria::Name => {
            images.sort_by(|a, b| {
                let name_a = a.path.file_name().unwrap_or_default();
                let name_b = b.path.file_name().unwrap_or_default();
                name_a.cmp(name_b)
            });
            println!("Listing images sorted by {}:", "FILE NAME".yellow().bold());
        }
        SortCriteria::Extension => {
            images.sort_by(|a, b| {
                let ext_a = a.path.extension().unwrap_or_default();
                let ext_b = b.path.extension().unwrap_or_default();
                // Sort by extension, and then by name if extensions are equal
                ext_a.cmp(ext_b).then_with(|| {
                    a.path
                        .file_name()
                        .unwrap_or_default()
                        .cmp(b.path.file_name().unwrap_or_default())
                })
            });
            println!("Listing images sorted by {}:", "EXTENSION".yellow().bold());
        }
    }

    // Reuse your existing SliceDisplay for consistent formatting
    // We need to update the numbers (index) based on the new sort order
    let total = images.len();
    for (i, img) in images.iter_mut().enumerate() {
        img.number = i + 1;
        img.total = total;
    }

    print!("{}", SliceDisplay(&images));

    println!("\nTotal images found: {}", total.to_string().green().bold());
    Ok(())
}