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
|
use std::path::PathBuf;
use anyhow::Result;
use std::fmt;
use std::ffi::OsStr;
use cursive::{View, Printer, XY, direction::Direction, view::Selector, Rect, event::Event, event::EventResult};
use cursive::view::Nameable;
use cursive::Cursive;
use cursive::views::NamedView;
use cursive_tree_view::TreeView;
use crate::main_view::MainView;
use crate::loader::PostProcessor;
use crate::loader::Loader;
#[derive(Debug)]
pub struct TreeEntry {
name: String,
path: PathBuf,
}
impl fmt::Display for TreeEntry {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.name)
}
}
pub const SIDEBAR_VIEW_NAME: &'static str = "sidebar_tree_view";
pub struct Sidebar {
inner_view: NamedView<TreeView<TreeEntry>>,
}
impl Sidebar {
pub fn new(pathes: Vec<PathBuf>) -> Self {
let mut tv = cursive_tree_view::TreeView::default();
pathes
.into_iter()
.map(|path| {
path.file_name()
.and_then(OsStr::to_str)
.map(String::from)
.ok_or_else(|| anyhow!("UTF8 error"))
.map(|name| TreeEntry { name, path })
})
.enumerate()
.for_each(|(i, item)| {
let item = item.expect("UNEX");
tv.insert_item(item, cursive_tree_view::Placement::After, i);
});
tv.set_on_submit(|mut siv: &mut Cursive, row: usize| {
let borrow = siv.call_on_name(SIDEBAR_VIEW_NAME, move |tree: &mut TreeView<TreeEntry>| {
tree.borrow_item(row).map(|b| b.path.clone())
})
.flatten();
if let Some(path) = borrow {
let loader = { // Fetch the loader for the view to be created
let p = path.clone();
siv.call_on_name(crate::main_view::MAIN_VIEW_NAME, move |main_view: &mut MainView| {
Some(main_view.maildir_loader(p))
})
.unwrap()
.unwrap()
};
let name = path.file_name()
.and_then(OsStr::to_str)
.map(String::from)
.ok_or_else(|| anyhow!("UTF8 error"))
.unwrap();
let postprocessor = loader.postprocessor(name.clone());
// Construct the AsyncView with the loader job
let list_view = cursive_async_view::AsyncView::new_with_bg_creator(&mut siv,
|| { loader.load() },
move |list| { postprocessor.postprocess(list) });
// Add the AsyncView to the screen
siv.call_on_name(crate::main_view::MAIN_VIEW_NAME, move |main_view: &mut MainView| {
Some(main_view.add_tab(name, list_view))
});
}
});
Sidebar {
inner_view: tv.with_name(SIDEBAR_VIEW_NAME),
}
}
}
impl View for Sidebar {
fn draw(&self, printer: &Printer) {
self.inner_view.draw(printer)
}
fn layout(&mut self, xy: XY<usize>) {
self.inner_view.layout(xy)
}
fn needs_relayout(&self) -> bool {
self.inner_view.needs_relayout()
}
fn required_size(&mut self, constraint: XY<usize>) -> XY<usize> {
self.inner_view.required_size(constraint)
}
fn on_event(&mut self, e: Event) -> EventResult {
self.inner_view.on_event(e)
}
fn call_on_any<'a>(&mut self, s: &Selector, tpl: &'a mut (dyn FnMut(&mut (dyn View + 'static)) + 'a)) {
self.inner_view.call_on_any(s, tpl);
}
fn focus_view(&mut self, s: &Selector) -> Result<(), ()> {
self.inner_view.focus_view(s)
}
fn take_focus(&mut self, source: Direction) -> bool {
self.inner_view.take_focus(source)
}
fn important_area(&self, view_size: XY<usize>) -> Rect {
self.inner_view.important_area(view_size)
}
fn type_name(&self) -> &'static str {
self.inner_view.type_name()
}
}
|
