cursive 0.3.4

A TUI (Text User Interface) library focused on ease-of-use.
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

extern crate termion;

use ::backend;
use ::event::{Event, Key};
use std::io::Write;
use self::termion::input::TermRead;
use self::termion::raw::IntoRawMode;
use ::theme::{BaseColor, Color, ColorStyle, Effect};

pub struct Concrete {
    terminal: termion::raw::RawTerminal<::std::io::Stdout>,
}

impl backend::Backend for Concrete {
    fn init() -> Self {
        print!("{}", termion::cursor::Hide);

        let backend = Concrete {
            terminal: ::std::io::stdout().into_raw_mode().unwrap(),
        };

        backend.clear();
        backend
    }

    fn finish(&mut self) {
        // Maybe we should clear everything?
        print!("{}{}", termion::cursor::Show, termion::cursor::Goto(1, 1));
        self.clear();
    }

    fn init_color_style(&mut self, style: ColorStyle, foreground: &Color,
                        background: &Color) {
        // Do we _need_ to save the color?
    }

    fn with_color<F: FnOnce()>(&self, color: ColorStyle, f: F) {
        // TODO: actually use colors
        // TODO: careful! need to remember the previous state
        //                and apply it back
        f();
    }

    fn with_effect<F: FnOnce()>(&self, effect: Effect, f: F) {
        // TODO: actually use effects
        // TODO: careful! need to remember the previous state
        //                and apply it back
        f();
    }

    fn has_colors(&self) -> bool {
        // TODO: color support detection?
        true
    }

    fn screen_size(&self) -> (usize, usize) {
        let (x, y) = termion::terminal_size().unwrap_or((1, 1));
        (x as usize, y as usize)
    }

    fn clear(&self) {
        print!("{}", termion::clear::All);
    }

    fn refresh(&mut self) {
        // Not sure termion needs a refresh phase
        self.terminal.flush().unwrap();
    }

    fn print_at(&self, (x, y): (usize, usize), text: &str) {
        // TODO: terminals are 1-based. Should we add 1 here?
        print!("{}{}", termion::cursor::Goto(x as u16, y as u16), text);
    }

    fn set_refresh_rate(&mut self, fps: u32) {
        // TODO: handle async refresh, when no input is entered.
        // Could be done with a timeout on the event polling,
        // if it was supportedd.
    }

    fn poll_event(&self) -> Event {
        ::std::io::stdin().keys().next();
        Event::Key(Key::Enter)
    }
}