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
|
use std::{path::PathBuf, sync::Arc};
use anyhow::Result;
use crossbeam::channel::Receiver;
use crosstermion::input::Event;
use dua::{
traverse::{EntryData, Traversal, Tree},
ByteFormat, WalkOptions, WalkResult,
};
use tui::prelude::Backend;
use tui_react::Terminal;
use crate::{crossdev, interactive::widgets::MainWindow};
use super::{
app_state::{AppState, ProcessingResult},
sorted_entries, DisplayOptions,
};
/// State and methods representing the interactive disk usage analyser for the terminal
pub struct TerminalApp {
pub traversal: Traversal,
pub display: DisplayOptions,
pub state: AppState,
pub window: MainWindow,
pub walk_options: WalkOptions,
}
impl TerminalApp {
pub fn initialize<B>(
terminal: &mut Terminal<B>,
walk_options: WalkOptions,
byte_format: ByteFormat,
) -> Result<TerminalApp>
where
B: Backend,
{
terminal.hide_cursor()?;
terminal.clear()?;
let display = DisplayOptions::new(byte_format);
let window = MainWindow::default();
let mut state = AppState {
is_scanning: false,
..Default::default()
};
let traversal = {
let mut tree = Tree::new();
let root_index = tree.add_node(EntryData::default());
Traversal {
tree,
root_index,
entries_traversed: 0,
start: std::time::Instant::now(),
elapsed: None,
io_errors: 0,
total_bytes: None,
}
};
state.navigation_mut().view_root = traversal.root_index;
state.entries = sorted_entries(
&traversal.tree,
state.navigation().view_root,
state.sorting,
state.glob_root(),
);
state.navigation_mut().selected = state.entries.first().map(|b| b.index);
let app = TerminalApp {
state,
display,
traversal,
window,
walk_options,
};
Ok(app)
}
pub fn traverse(&mut self, input: Vec<PathBuf>) -> Result<()> {
self.state
.traverse(&self.traversal, &self.walk_options, input)?;
Ok(())
}
pub fn process_events<B>(
&mut self,
terminal: &mut Terminal<B>,
events: Receiver<Event>,
) -> Result<WalkResult>
where
B: Backend,
{
match self.state.process_events(
&mut self.window,
&mut self.traversal,
&mut self.display,
terminal,
events,
)? {
ProcessingResult::ExitRequested(res) => Ok(res),
}
}
}
|