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 crate::{ClrT, Point, Result, Yarr, Yogurt};
use crossterm::{
    cursor, execute, queue,
    style::Print,
    terminal::{
        disable_raw_mode, enable_raw_mode, size, Clear, EnterAlternateScreen, LeaveAlternateScreen,
        SetSize,
    },
};
use std::{fmt::Display, io::Write};

/// Output to the terminal.
impl Yogurt {
    /// Print a string to the cursor location.
    pub fn print(&mut self, displ: impl Display) -> Result<()> {
        queue! {
            self.stdout,
            Print(displ),
        }?;
        Ok(())
    }
    /// Move the cursor to the specified point.
    pub fn mv(&mut self, point: impl Into<Point>) -> Result<()> {
        let point = Into::<Point>::into(point);
        queue! {
            self.stdout,
            cursor::MoveTo(point.x, point.y),
        }?;
        Ok(())
    }
    /// Move the cursor to the specified point and print.
    pub fn mv_print(&mut self, point: impl Into<Point>, displ: impl Display) -> Result<()> {
        self.mv(point)?;
        self.print(displ)?;
        Ok(())
    }
    /// Flush the buffer.
    pub fn flush(&mut self) -> Result<()> {
        self.stdout.flush()?;
        Ok(())
    }
    /// Draw a box with the provided characters.
    ///
    /// You can use the constants
    /// [`BORDER`](crate::stylize::BORDER) or [`ROUND_BORDER`](crate::stylize::ROUND_BORDER) instead of defining
    /// your own.
    ///
    /// Example of defining custom border:
    /// ```
    /// let my_super_cool_border =
    /// ['┌', '─', '┐',
    ///  '│',      '│',
    ///  '└', '─', '┘'];
    /// ```
    ///
    /// An example can be found by running `$ cargo run --example=border`.
    pub fn draw_box(
        &mut self,
        up_corner: impl Into<Point>,
        down_corner: impl Into<Point>,
        chars: [char; 8],
    ) -> Result<()> {
        let up = Into::<Point>::into(up_corner);
        let down = Into::<Point>::into(down_corner);
        for tile in up.x..=down.x {
            self.mv_print((tile, up.y), chars[1])?;
            self.mv_print((tile, down.y), chars[6])?;
        }
        for tile in up.y..=down.y {
            self.mv_print((up.x, tile), chars[3])?;
            self.mv_print((down.x, tile), chars[4])?;
        }
        self.mv_print(up, chars[0])?;
        self.mv_print((down.x, up.y), chars[2])?;
        self.mv_print((up.x, down.y), chars[5])?;
        self.mv_print(down, chars[7])?;
        Ok(())
    }
    /// Enter "alternate mode." See also [`leave_alt`](Yogurt::leave_alt).
    ///
    /// In alternate mode, the following things are true:
    ///
    /// - input will be avaliable imideately to the program (not line buffered)
    /// - special keys will not be processed (`^C` won't do anything!)
    /// - newline will not be proccessed
    /// - an "alternate screen" will be entered, which has no scroll area and any changes made to the screen will not be preserved when switching back to the main screen.
    ///
    /// In effect, alternate mode just enters an alternate screen and enables terminal raw mode.
    ///
    /// This function also flushes the buffer.
    pub fn enter_alt(&mut self) -> Result<()> {
        self.size = Some(Point::from(size()?));
        execute! {
            self.stdout,
            EnterAlternateScreen
        }?;
        enable_raw_mode()?;
        Ok(())
    }
    /// Leave "alternate mode." See also [`enter_alt`](Yogurt::enter_alt).
    ///
    /// This function also flushes the buffer.
    pub fn leave_alt(&mut self) -> Result<()> {
        if let Some(size) = self.size.take() {
            execute! {
                self.stdout,
                LeaveAlternateScreen,
                SetSize(size.x, size.y),
            }?;
            disable_raw_mode()?;
            Ok(())
        } else {
            Err(Yarr::NotInAltMode)
        }
    }
    /// Clear the screen.
    pub fn clear(&mut self, cleartype: ClrT) -> Result<()> {
        queue! {
            self.stdout,
            Clear(cleartype),
        }?;
        Ok(())
    }
    /// Resize the terminal.
    pub fn resize(&mut self, rows: u16, cols: u16) -> Result<()> {
        queue! {
            self.stdout,
            SetSize(rows, cols),
        }?;
        Ok(())
    }
}