owen 0.0.1

Terminal User Interface library
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

use crate::{
    arrangement::{Position, Size},
    style::Style,
    window::Window,
};
use crossterm::{
    cursor::{position, Hide, MoveTo, Show},
    execute, queue,
    style::{Print, SetBackgroundColor, SetForegroundColor},
    terminal::{size, EnterAlternateScreen, LeaveAlternateScreen},
};
use std::io::{Error, Write};

pub struct Terminal<W>
where
    W: Write,
{
    // Output stream
    buffer: W,
    // The difference between the two is updated in the terminal
    frames: [Window; 2],
    // The frame that is drawn
    index: usize,
}

impl<W> Terminal<W>
where
    W: Write,
{
    pub fn new(buffer: W) -> Result<Terminal<W>, Error> {
        let size = match size() {
            Ok((columns, rows)) => Ok(Size { rows, columns }),
            Err(err) => Err(err),
        }
        .unwrap();
        Ok(Terminal {
            buffer,
            frames: [Window::new(size), Window::new(size)],
            index: 0,
        })
    }

    // Gets the size of the terminal
    pub fn size(&self) -> Result<Size, Error> {
        match size() {
            Ok((columns, rows)) => Ok(Size { rows, columns }),
            Err(err) => Err(err),
        }
    }

    // Switches the current frame index
    fn switch(&mut self) {
        if self.index == 1 {
            self.index = 0;
        } else {
            self.index = 1;
        };
    }

    // Makes the terminal switch to an alternate screen
    pub fn alternate_screen_enter(&mut self) -> Result<(), Error> {
        execute!(self.buffer, EnterAlternateScreen)
    }

    // Makes the terminal leave the alternate screen
    pub fn alternate_screen_leave(&mut self) -> Result<(), Error> {
        execute!(self.buffer, LeaveAlternateScreen)
    }

    // Draws the current frame onto the terminal
    pub fn draw(&mut self, renderer: impl FnOnce(&mut Window)) -> Result<(), Error> {
        renderer(&mut self.frames[1 - self.index]);
        let mut cursor_position: Position = match position() {
            Ok((column, row)) => Position::from(row, column),
            Err(err) => return Err(err),
        };
        let mut style = Style::default();
        // The difference between the current frame and the previous frame
        let diff = self.frames[self.index].diff(&self.frames[1 - self.index]);
        // Update the cells on the screen from the difference
        for (cell, position) in diff {
            if position.row != cursor_position.row
                || position.column as i32 != cursor_position.column as i32 - 1
            {
                queue!(self.buffer, MoveTo(position.column, position.row))?;
                cursor_position.row = position.row;
                cursor_position.column = position.column;
            } else {
                cursor_position.column += 1;
            }
            if cell.style.foreground != style.foreground {
                queue!(self.buffer, SetForegroundColor(cell.style.foreground))?;
                style.foreground = cell.style.foreground;
            }
            if cell.style.background != style.background {
                queue!(self.buffer, SetBackgroundColor(cell.style.background))?;
                style.background = cell.style.background;
            }
            queue!(self.buffer, Print(cell.symbol))?;
            self.buffer.flush()?;
        }
        // Send all commands to the terminal
        self.buffer.flush()?;
        self.switch();
        Ok(())
    }

    // Hides the cursor in the terminal
    pub fn cursor_hide(&mut self) -> Result<(), Error> {
        execute!(self.buffer, Hide)
    }

    // Shows the cursor in the terminal
    pub fn cursor_show(&mut self) -> Result<(), Error> {
        execute!(self.buffer, Show)
    }

    // Gets the position of the cursor in the terminal
    pub fn cursor_get() -> Result<Position, Error> {
        let cursor_position = position()?;
        Ok(Position {
            row: cursor_position.1,
            column: cursor_position.0,
        })
    }

    // Changes the position of the cursor in the terminal
    pub fn cursor_move(&mut self, position: Position) -> Result<(), Error> {
        execute!(self.buffer, MoveTo(position.column, position.row))
    }
}