Rewrite sidebar into wrapper struct

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

1 files changed, 95 insertions, 36 deletions

diff --git a/src/sidebar.rs b/src/sidebar.rs
index 922e446..deaaa15 100644
--- a/src/sidebar.rs
+++ b/src/sidebar.rs
@@ -2,12 +2,14 @@ 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::views::NamedView;
 use cursive::Cursive;
+use cursive::views::NamedView;
+use cursive_tree_view::TreeView;
 
 use crate::main_view::MainView;
-use cursive_tree_view::TreeView;
+use crate::mailcache::MailCache;
 
 #[derive(Debug)]
 pub struct TreeEntry {
@@ -23,39 +25,96 @@ impl fmt::Display for TreeEntry {
 
 pub const SIDEBAR_VIEW_NAME: &'static str = "sidebar_tree_view";
 
-pub fn sidebar<I>(iter: I) -> Result<NamedView<cursive_tree_view::TreeView<TreeEntry>>>
-    where I: Iterator<Item = PathBuf>
-{
-    let mut tv = cursive_tree_view::TreeView::default();
-
-    tv.set_on_submit(|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 {
-            siv.call_on_name(crate::main_view::MAIN_VIEW_NAME, move |main_view: &mut MainView| {
-                main_view.load_maildir(path);
-                None as Option<()>
-            });
+pub struct Sidebar {
+    inner_view: NamedView<TreeView<TreeEntry>>,
+    cache: MailCache,
+}
+
+impl Sidebar {
+    pub fn new(mailcache: MailCache) -> Self {
+        let mut tv = cursive_tree_view::TreeView::default();
+
+        tv.set_on_submit(|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 {
+                siv.call_on_name(crate::main_view::MAIN_VIEW_NAME, move |main_view: &mut MainView| {
+                    main_view.load_maildir(path);
+                    None as Option<()>
+                });
+            }
+        });
+
+        Sidebar {
+            inner_view: tv.with_name(SIDEBAR_VIEW_NAME),
+            cache: mailcache
         }
-    });
-
-    // Fill the tree from the iterator
-    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()
-    .fold(Ok(tv), |accu, (i, item)| {
-        accu.and_then(|mut tv| {
-            item.map(|itm| tv.insert_item(itm, cursive_tree_view::Placement::After, i))
-                .map(|_| tv)
-        })
-    })
-    .map(|tv| 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>) {
+        let _ = self.cache.update_cache().expect("Failed to update cache");
+
+        // Fill the tree from the iterator
+        self.cache
+            .cached_pathes()
+            .expect("UNEXPECTED ERROR FIXME")
+            .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");
+                self.inner_view.get_mut().insert_item(item, cursive_tree_view::Placement::After, i);
+            });
+
+        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()
+    }
+
+}
+