broot 1.56.2

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

use {
    crate::{
        app::{
            AppContext,
            DisplayContext,
        },
        command::ScrollCommand,
        display::{
            DisplayableTree,
            Screen,
            W,
        },
        errors::ProgramError,
        pattern::InputPattern,
        skin::PanelSkin,
        task_sync::Dam,
        tree::{
            Tree,
            TreeOptions,
        },
        tree_build::TreeBuilder,
    },
    crokey::crossterm::{
        QueueableCommand,
        cursor,
    },
    std::{
        io,
        path::PathBuf,
    },
    termimad::Area,
};

pub struct DirView {
    pub tree: Tree,
    page_height: Option<usize>,
}
impl DirView {
    pub fn new(
        dir: PathBuf,
        pattern: InputPattern,
        dam: &Dam,
        con: &AppContext,
    ) -> Result<Self, io::Error> {
        let options = TreeOptions {
            show_hidden: true,
            respect_git_ignore: false,
            pattern,
            ..Default::default()
        };
        let mut builder = TreeBuilder::from(dir, options, 100, con).map_err(io::Error::other)?;
        builder.deep = false;
        let tree = builder
            .build_tree(
                false, // on refresh we always do a non total search
                dam,
            )
            .map_err(io::Error::other)?;
        Ok(Self {
            tree,
            page_height: None,
        })
    }
    pub fn display(
        &mut self,
        w: &mut W,
        disc: &DisplayContext,
        area: &Area,
    ) -> Result<(), ProgramError> {
        let page_height = area.height as usize;
        if Some(page_height) != self.page_height {
            self.page_height = Some(page_height);
        }
        let dp = DisplayableTree {
            app_state: None,
            tree: &self.tree,
            skin: &disc.panel_skin.styles,
            ext_colors: &disc.con.ext_colors,
            area: area.clone(),
            in_app: true,
        };
        dp.write_on(w)?;
        Ok(())
    }
    pub fn display_info(
        &mut self,
        w: &mut W,
        _screen: Screen,
        panel_skin: &PanelSkin,
        area: &Area,
    ) -> Result<(), ProgramError> {
        let width = area.width as usize;
        let mut s = format!("{}", self.tree.lines.len());
        if s.len() > width {
            return Ok(());
        }
        if s.len() + "lines: ".len() < width {
            s = format!("entries: {s}");
        }
        w.queue(cursor::MoveTo(
            area.left + area.width - s.len() as u16,
            area.top,
        ))?;
        panel_skin.styles.default.queue(w, s)?;
        Ok(())
    }
    pub fn try_scroll(
        &mut self,
        cmd: ScrollCommand,
    ) -> bool {
        let Some(page_height) = self.page_height else {
            return false;
        };
        let dy = cmd.to_lines(page_height);
        self.tree.try_scroll(dy, page_height)
    }
    pub fn try_select_y(
        &mut self,
        y: u16,
    ) -> bool {
        self.tree.try_select_y(y as usize)
    }
    pub fn move_selection(
        &mut self,
        dy: i32,
        cycle: bool,
    ) {
        if let Some(page_height) = self.page_height {
            self.tree.move_selection(dy, page_height, cycle);
        }
    }
    pub fn select_first(&mut self) {
        self.tree.try_select_first();
    }
    pub fn select_last(&mut self) {
        if let Some(page_height) = self.page_height {
            self.tree.try_select_last(page_height);
        }
    }
}