broot 1.51.0

File browser and launcher
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use {
    super::*,
    crate::{
        skin::StyleMap,
        tree::TreeOptions,
    },
    chrono::{
        Local,
        LocalResult,
        TimeZone,
    },
    termimad::CompoundStyle,
    trash::TrashItem,
    unicode_width::UnicodeWidthStr,
};

/// A displayable column, related to properties of the TrashItem
#[derive(Debug, Clone, Copy)]
pub enum TrashItemProperty {
    OriginalParent,
    Name,
    DeletionDate,
    Size,
}

impl TrashItemProperty {
    pub fn title(self) -> &'static str {
        // only single byte characters allowed here
        match self {
            Self::OriginalParent => "Original parent",
            Self::Name => "Deleted file name",
            Self::DeletionDate => "Deletion",
            Self::Size => "Size",
        }
    }
    pub fn style(
        self,
        is_dir: bool,
        styles: &StyleMap,
    ) -> &CompoundStyle {
        match self {
            Self::DeletionDate => &styles.dates,
            _ => {
                if is_dir {
                    &styles.directory
                } else {
                    &styles.file
                }
            }
        }
    }
    pub fn value_of(
        self,
        item: &TrashItem,
        options: &TreeOptions,
    ) -> String {
        match self {
            Self::OriginalParent => item.original_parent.to_string_lossy().to_string(),
            Self::Name => item.name.to_string_lossy().to_string(),
            Self::DeletionDate => {
                let seconds = item.time_deleted;
                if let LocalResult::Single(date_time) = Local.timestamp_opt(seconds, 0) {
                    date_time.format(options.date_time_format).to_string()
                } else {
                    "???".to_string()
                }
            }
            Self::Size => match item_unified_size(item) {
                Some(size) => format!("{:>4}", file_size::fit_4(size)),
                None => "????".to_string(),
            },
        }
    }
    pub fn const_width(self) -> bool {
        match self {
            Self::OriginalParent => false,
            Self::Name => false,
            Self::DeletionDate => true,
            Self::Size => true,
        }
    }
    pub fn optimal_width(
        self,
        items: &[TrashItem],
        options: &TreeOptions,
    ) -> usize {
        match self {
            Self::Size => 4,
            _ => items
                .iter()
                .map(|m| self.value_of(m, options).width())
                .max()
                .unwrap_or(0),
        }
    }
    pub fn column_constraints(
        self,
        items: &[TrashItem],
        options: &TreeOptions,
    ) -> flex_grow::Child<Self> {
        let optimal_width = self.optimal_width(items, options);
        let child = flex_grow::Child::new(self);
        if self.const_width() {
            child.with_size(optimal_width)
        } else {
            child.with_max(optimal_width)
        }
    }
}

pub fn get_cols(
    items: &[TrashItem],
    available_width: usize,
    tree_options: &TreeOptions,
) -> Vec<flex_grow::Child<TrashItemProperty>> {
    let mut cols_builder = flex_grow::Container::builder_in(available_width).with_margin_between(1);
    if tree_options.show_sizes {
        cols_builder.add(
            TrashItemProperty::Size
                .column_constraints(items, tree_options)
                .optional(),
        );
    }
    if tree_options.show_dates {
        cols_builder.add(
            TrashItemProperty::DeletionDate
                .column_constraints(items, tree_options)
                .optional(),
        );
    }
    cols_builder.add(
        TrashItemProperty::OriginalParent
            .column_constraints(items, tree_options)
            .with_min(10)
            .optional(),
    );
    cols_builder.add(
        TrashItemProperty::Name
            .column_constraints(items, tree_options)
            .with_min(10)
            .with_grow(2.0),
    );
    let Ok(cols) = cols_builder.build() else {
        return Vec::new(); // should not happen
    };
    debug!("trash_state cols: {:?}", cols.sizes());
    cols.to_children()
}