Initial commit

examples/example.rs

@@ -0,0 +1,98 @@
+mod util;
+
+use crate::util::{
+    event::{Event, Events},
+    StatefulTree,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders},
+    Terminal,
+};
+
+use tui_tree_widget::{Tree, TreeItem};
+
+struct App<'a> {
+    tree: StatefulTree<'a>,
+}
+
+impl<'a> App<'a> {
+    fn new() -> App<'a> {
+        App {
+            tree: StatefulTree::with_items(vec![
+                TreeItem::new_leaf("a"),
+                TreeItem::new(
+                    "b",
+                    vec![
+                        TreeItem::new_leaf("c"),
+                        TreeItem::new("d", vec![TreeItem::new_leaf("e"), TreeItem::new_leaf("f")]),
+                        TreeItem::new_leaf("g"),
+                    ],
+                ),
+                TreeItem::new_leaf("h"),
+            ]),
+        }
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let events = Events::new();
+
+    // App
+    let mut app = App::new();
+
+    loop {
+        terminal.draw(|f| {
+            let area = f.size();
+
+            let items = Tree::new(app.tree.items.to_vec())
+                .block(
+                    Block::default()
+                        .borders(Borders::ALL)
+                        .title(format!("Tree Widget {:?}", app.tree.state)),
+                )
+                .highlight_style(
+                    Style::default()
+                        .fg(Color::Black)
+                        .bg(Color::LightGreen)
+                        .add_modifier(Modifier::BOLD),
+                )
+                .highlight_symbol(">> ");
+            f.render_stateful_widget(items, area, &mut app.tree.state);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => match input {
+                Key::Char('q') => {
+                    break;
+                }
+                Key::Left => {
+                    app.tree.close();
+                }
+                Key::Right => {
+                    app.tree.open();
+                }
+                Key::Down => {
+                    app.tree.next();
+                }
+                Key::Up => {
+                    app.tree.previous();
+                }
+                _ => {}
+            },
+            Event::Tick => {}
+        }
+    }
+
+    Ok(())
+}

examples/util/event.rs

@@ -0,0 +1,72 @@
+use std::io;
+use std::sync::mpsc;
+use std::thread;
+use std::time::Duration;
+
+use termion::event::Key;
+use termion::input::TermRead;
+
+pub enum Event<I> {
+    Input(I),
+    Tick,
+}
+
+/// A small event handler that wrap termion input and tick events. Each event
+/// type is handled in its own thread and returned to a common `Receiver`
+#[allow(dead_code)]
+pub struct Events {
+    rx: mpsc::Receiver<Event<Key>>,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Config {
+    pub exit_key: Key,
+    pub tick_rate: Duration,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            exit_key: Key::Char('q'),
+            tick_rate: Duration::from_millis(250),
+        }
+    }
+}
+
+impl Events {
+    pub fn new() -> Events {
+        Events::with_config(Config::default())
+    }
+
+    pub fn with_config(config: Config) -> Events {
+        let (tx, rx) = mpsc::channel();
+        {
+            let tx = tx.clone();
+            thread::spawn(move || {
+                let stdin = io::stdin();
+                for evt in stdin.keys() {
+                    if let Ok(key) = evt {
+                        if let Err(err) = tx.send(Event::Input(key)) {
+                            eprintln!("{}", err);
+                            return;
+                        }
+                        if key == config.exit_key {
+                            return;
+                        }
+                    }
+                }
+            })
+        };
+        thread::spawn(move || loop {
+            if tx.send(Event::Tick).is_err() {
+                break;
+            }
+            thread::sleep(config.tick_rate);
+        });
+        Events { rx }
+    }
+
+    pub fn next(&self) -> Result<Event<Key>, mpsc::RecvError> {
+        self.rx.recv()
+    }
+}

examples/util/mod.rs

@@ -0,0 +1,63 @@
+pub mod event;
+
+use tui_tree_widget::{flatten, identifier, TreeItem, TreeState};
+
+pub struct StatefulTree<'a> {
+    pub state: TreeState,
+    pub items: Vec<TreeItem<'a>>,
+}
+
+impl<'a> StatefulTree<'a> {
+    #[allow(dead_code)]
+    pub fn new() -> StatefulTree<'a> {
+        StatefulTree {
+            state: TreeState::default(),
+            items: Vec::new(),
+        }
+    }
+
+    pub fn with_items(items: Vec<TreeItem<'a>>) -> StatefulTree<'a> {
+        StatefulTree {
+            state: TreeState::default(),
+            items,
+        }
+    }
+
+    fn move_up_down(&mut self, down: bool) {
+        let visible = flatten(&self.state.opened, &self.items);
+        let current_identifier = self.state.selected();
+        let current_index = visible
+            .iter()
+            .position(|o| o.identifier == current_identifier);
+        let new_index = current_index.map_or(0, |current_index| {
+            if down {
+                current_index.saturating_add(1)
+            } else {
+                current_index.saturating_sub(1)
+            }
+            .min(visible.len() - 1)
+        });
+        let new_identifier = visible.get(new_index).unwrap().identifier.to_owned();
+        self.state.select(new_identifier);
+    }
+
+    pub fn next(&mut self) {
+        self.move_up_down(true);
+    }
+
+    pub fn previous(&mut self) {
+        self.move_up_down(false);
+    }
+
+    pub fn close(&mut self) {
+        let selected = self.state.selected();
+        if !self.state.close(&selected) {
+            let (head, _) = identifier::get_without_leaf(&selected);
+            self.state.select(head);
+        }
+    }
+
+    pub fn open(&mut self) {
+        self.state.open(self.state.selected());
+    }
+}