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 133 134 135 136 137
//! A module that contains all the actions related to the terminal. //! Like clearing and scrolling in the terminal or getting the window size from the terminal. use super::{AnsiTerminal, ClearType, ITerminal}; use crossterm_utils::Result; #[cfg(windows)] use super::WinApiTerminal; #[cfg(windows)] use crossterm_utils::supports_ansi; use std::fmt; use std::io::Write; /// Allows you to preform actions on the terminal. /// /// # Features: /// /// - Clearing (all lines, current line, from cursor down and up, until new line) /// - Scrolling (Up, down) /// - Get the size of the terminal /// - Set the size of the terminal /// - Alternate screen /// - Raw screen /// - Exit the current process /// /// Check `/examples/` in the library for more specific examples. pub struct Terminal { #[cfg(windows)] terminal: Box<(dyn ITerminal + Sync + Send)>, #[cfg(unix)] terminal: AnsiTerminal, } impl Terminal { /// Create new terminal instance whereon terminal related actions can be performed. pub fn new() -> Terminal { #[cfg(windows)] let terminal = if supports_ansi() { Box::from(AnsiTerminal::new()) as Box<(dyn ITerminal + Sync + Send)> } else { WinApiTerminal::new() as Box<(dyn ITerminal + Sync + Send)> }; #[cfg(unix)] let terminal = AnsiTerminal::new(); Terminal { terminal } } /// Clear the current cursor by specifying the `ClearType`. /// /// # Example /// ```rust /// let mut term = terminal(); /// /// // clear all cells in terminal. /// term.clear(terminal::ClearType::All); /// // clear all cells from the cursor position downwards in terminal. /// term.clear(terminal::ClearType::FromCursorDown); /// // clear all cells from the cursor position upwards in terminal. /// term.clear(terminal::ClearType::FromCursorUp); /// // clear current line cells in terminal. /// term.clear(terminal::ClearType::CurrentLine); /// // clear all cells from cursor position until new line in terminal. /// term.clear(terminal::ClearType::UntilNewLine); /// ``` pub fn clear(&self, clear_type: ClearType) -> Result<()> { self.terminal.clear(clear_type) } /// Get the terminal size (x,y). /// /// # Remark /// This will return a tuple of (x: u16, y: u16) pub fn terminal_size(&self) -> (u16, u16) { self.terminal.terminal_size() } /// Scroll `n` lines up in the current terminal. /// /// # Parameter /// - `count`: the number of rows should be shifted up. pub fn scroll_up(&self, count: i16) -> Result<()> { self.terminal.scroll_up(count) } /// Scroll `n` lines down in the current terminal. /// /// # Parameter /// - `count`: the number of rows should be shifted down. pub fn scroll_down(&self, count: i16) -> Result<()> { self.terminal.scroll_down(count) } /// Set the terminal size. Note that not all terminals can be set to a very small scale. /// /// ```rust /// let mut term = terminal(); /// /// // Set of the size to X: 10 and Y: 10 /// let size = term.set_size(10,10); /// ``` pub fn set_size(&self, width: i16, height: i16) -> Result<()> { self.terminal.set_size(width, height) } /// Exit the current process. /// /// ```rust /// let mut term = terminal(); /// /// let size = term.exit(); /// ``` pub fn exit(&self) { crate::sys::exit(); } /// Write any displayable content to the current terminal screen. /// /// ```rust /// let mut term = terminal(); /// /// let size = term.write("Some text \n Some text on new line"); /// ``` /// /// This will also flush the standard output. pub fn write<D: fmt::Display>(&self, value: D) -> Result<usize> { write_cout!(format!("{}", value))?; Ok(0) } } /// Get a `Terminal` instance whereon terminal related actions could performed. pub fn terminal() -> Terminal { Terminal::new() }