algostru 0.4.0

Algorithms (algo) and Data Structures (stru)
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

#[allow(dead_code)]
mod util;
mod gui;
mod logger;

use std::{
    error::Error,
    io::{
        Stdout,
        Write,
        stdout,
    },
    rc::Rc,
    cell::RefCell,
};

use log::{LevelFilter};
use crossterm::{
    event::{
        EnableMouseCapture,
        DisableMouseCapture,
        KeyCode,
    },
    execute,
    terminal::{
        enable_raw_mode,
        disable_raw_mode,
        EnterAlternateScreen,
        LeaveAlternateScreen,
    },
};
use tui::{
    backend::CrosstermBackend,
    Terminal,
};

use crate::logger::Log;
use crate::gui::application::Application;
use crate::gui::store::Store;
use crate::gui::router::{
    Route,
    Router,
};
use crate::gui::screen::{
    title::Title,
    dashboard::Dashboard,
};
use crate::util::event::{
    Events,
    Event,
};

static LOGGER: Log = Log;

fn main() -> Result<(), Box<dyn Error>> {
    // todo - dynamic level filter (debug mode)
    log::set_logger(&LOGGER).map(|()| log::set_max_level(LevelFilter::Debug)).unwrap();

    // starting tui-rs + crossterm ---

    enable_raw_mode()?;

    let mut stdout = stdout();
    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
    let backend = CrosstermBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;
    let events = Events::new();
    let store = Rc::new(RefCell::new(Store::new()));
    let router = Router::new(
        Rc::clone(&store),
        vec![
            (Route::Title, Box::new(Title::new(Rc::clone(&store)))),
            (Route::Dashboard, Box::new(Dashboard::new(Rc::clone(&store)))),
        ]
    );
    let mut app = Application::new(Rc::clone(&store), router);

    terminal.clear()?;

    let shutdown = |mut terminal: Terminal<CrosstermBackend<Stdout>>| {
        disable_raw_mode().unwrap();
        execute!(
                terminal.backend_mut(),
                LeaveAlternateScreen,
                DisableMouseCapture
        ).unwrap();
        terminal.show_cursor().unwrap();
    };

    loop {
        terminal.draw(|f| app.draw(f))?;
        match events.next()? {
            Event::Input(event) => match event.code {
                KeyCode::Char('q') => {
                    shutdown(terminal);
                    break;
                }
                e => {
                    app.on_key(e);
                }
            },
            Event::Tick => {
                app.on_tick();
            }
        }
        if app.should_quit {
            shutdown(terminal);
            break;
        }
    }

    Ok(())
}