exhibit 0.2.0

A small Rust library for controlling the display of any Displayable type
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::io::{self, Write};

use crossterm::{
    cursor,
    event::{self, Event, KeyCode, KeyEvent},
    execute, queue,
    style::Stylize,
    terminal,
};
use exhibit::ExhibitExt;

fn main() {
    let mut w = io::stdout();
    execute!(w, terminal::EnterAlternateScreen).unwrap();
    terminal::enable_raw_mode().unwrap();

    let (mut x1, mut y1) = (1, 1);
    let (mut x2, mut y2) = (1, 1);
    let mut is_first_selected = true;

    let text1 = format!(
        "+-- One -----------------------------+
|{}. Or 's' to switch.|
|{}.      |
+------------------------------------+",
        "Press 'q' to quit".dark_red(),
        "Or 'h', 'j', 'k', 'l' to move".red().italic()
    );

    let text2 = format!(
        "+-- One -----------------------------+
|{}. Or 's' to switch.|
|{}.      |
+------------------------------------+",
        "Press 'q' to quit".dark_blue(),
        "Or 'h', 'j', 'k', 'l' to move".blue().bold()
    );

    let (width1, height1) = (text1.lines().next().unwrap().len().try_into().unwrap(), 4);
    let (width2, height2) = (text2.lines().next().unwrap().len().try_into().unwrap(), 4);

    loop {
        let (term_width, term_height) = terminal::size().unwrap();

        x1 = x1.clamp(1, term_width - width1);
        y1 = y1.clamp(1, term_height - height1 - 1);

        x2 = x2.clamp(1, term_width - width2);
        y2 = y2.clamp(1, term_height - height2 - 1);

        queue!(
            w,
            terminal::Clear(terminal::ClearType::All),
            cursor::Hide,
            cursor::MoveTo(0, 0),
        )
        .unwrap();

        if is_first_selected {
            write!(
                w,
                "{}",
                text2
                    .exhibit()
                    .size(width2, height2)
                    .pos(x2, y2)
                    .redact(true)
            )
            .unwrap();
            queue!(w, cursor::MoveTo(0, 0),).unwrap();
            write!(w, "{}", text1.exhibit().size(width1, height1).pos(x1, y1)).unwrap();
        } else {
            write!(
                w,
                "{}",
                text1
                    .exhibit()
                    .size(width1, height1)
                    .pos(x1, y1)
                    .redact(true)
            )
            .unwrap();
            queue!(w, cursor::MoveTo(0, 0),).unwrap();
            write!(w, "{}", text2.exhibit().size(width2, height2).pos(x2, y2)).unwrap();
        }

        w.flush().unwrap();

        if let Ok(Event::Key(KeyEvent {
            code: KeyCode::Char(c),
            ..
        })) = event::read()
        {
            match c {
                'q' => break,
                'l' => {
                    if is_first_selected {
                        x1 += 1
                    } else {
                        x2 += 1
                    }
                }
                'j' => {
                    if is_first_selected {
                        y1 += 1
                    } else {
                        y2 += 1
                    }
                }
                'h' => {
                    if is_first_selected {
                        x1 = x1.saturating_sub(1)
                    } else {
                        x2 = x2.saturating_sub(1)
                    }
                }
                'k' => {
                    if is_first_selected {
                        y1 = y1.saturating_sub(1)
                    } else {
                        y2 = y2.saturating_sub(1)
                    }
                }
                's' => is_first_selected = !is_first_selected,
                _ => {}
            }
        }
    }

    execute!(w, cursor::Show, terminal::LeaveAlternateScreen).unwrap();
    terminal::disable_raw_mode().unwrap();
}