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 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
//! # Terminal //! //! The `terminal` module provides functionality to work with the terminal. //! //! This documentation does not contain a lot of examples. The reason is that it's fairly //! obvious how to use this crate. Although, we do provide //! [examples](https://github.com/crossterm-rs/crossterm/tree/master/examples) repository //! to demonstrate the capabilities. //! //! Most terminal actions can be performed with commands. //! Please have a look at [command documention](../index.html#command-api) for a more detailed documentation. //! //! ## Screen Buffer //! //! A screen buffer is a two-dimensional array of character //! and color data which is displayed in a terminal screen. //! //! The terminal has several of those buffers and is able to switch between them. //! The default screen in which you work is called the 'main screen'. //! The other screens are called the 'alternative screen'. //! //! It is important to understand that crossterm does not yet support creating screens, //! or switch between more than two buffers, and only offers the ability to change //! between the 'alternate' and 'main screen'. //! //! ### Alternate Screen //! //! By default, you will be working on the main screen. //! There is also another screen called the 'alternative' screen. //! This screen is slightly different from the main screen. //! For example, it has the exact dimensions of the terminal window, //! without any scroll-back area. //! //! Crossterm offers the possibility to switch to the 'alternative' screen, //! make some modifications, and move back to the 'main' screen again. //! The main screen will stay intact and will have the original data as we performed all //! operations on the alternative screen. //! //! An good example of this is Vim. //! When it is launched from bash, a whole new buffer is used to modify a file. //! Then, when the modification is finished, it closes again and continues on the main screen. //! //! ### Raw Mode //! //! By default, the terminal functions in a certain way. //! For example, it will move the cursor to the beginning of the next line when the input hits the end of a line. //! Or that the backspace is interpreted for character removal. //! //! Sometimes these default modes are irrelevant, //! and in this case, we can turn them off. //! This is what happens when you enable raw modes. //! //! Those modes will be set when enabling raw modes: //! //! - Input will not be forwarded to screen //! - Input will not be processed on enter press //! - Input will not be line buffered (input sent byte-by-byte to input buffer) //! - Special keys like backspace and CTL+C will not be processed by terminal driver //! - New line character will not be processed therefore `println!` can't be used, use `write!` instead //! //! ## Examples //! //! ```no_run //! use std::io::{stdout, Write}; //! use crossterm::{execute, Result, terminal::{ScrollUp, SetSize, size}}; //! //! fn main() -> Result<()> { //! let (cols, rows) = size()?; //! // Resize terminal and scroll up. //! execute!( //! stdout(), //! SetSize(10, 10), //! ScrollUp(5) //! )?; //! //! // Be a good citizen, cleanup //! execute!(stdout(), SetSize(cols, rows))?; //! Ok(()) //! } //! ``` //! //! For manual execution control check out [crossterm::queue](../macro.queue.html). #[cfg(windows)] use crossterm_winapi::{Handle, ScreenBuffer}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[doc(no_inline)] use crate::Command; use crate::{impl_display, Result}; mod ansi; pub(crate) mod sys; /// Enables raw mode. /// /// Please have a look at the [raw mode](./#raw-mode) section. pub fn enable_raw_mode() -> Result<()> { sys::enable_raw_mode() } /// Disables raw mode. /// /// Please have a look at the [raw mode](./#raw-mode) section. pub fn disable_raw_mode() -> Result<()> { sys::disable_raw_mode() } /// Returns the terminal size `(columns, rows)`. /// /// The top left cell is represented `(1, 1)`. pub fn size() -> Result<(u16, u16)> { sys::size() } /// A command that switches to alternate screen. /// /// # Notes /// /// * Commands must be executed/queued for execution otherwise they do nothing. /// * Use [LeaveAlternateScreen](./struct.LeaveAlternateScreen.html) command to leave the entered alternate screen. /// /// # Examples /// /// ```no_run /// use std::io::{stdout, Write}; /// use crossterm::{execute, Result, terminal::{EnterAlternateScreen, LeaveAlternateScreen}}; /// /// fn main() -> Result<()> { /// execute!(stdout(), EnterAlternateScreen)?; /// /// // Do anything on the alternate screen /// /// execute!(stdout(), LeaveAlternateScreen) /// } /// ``` /// #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct EnterAlternateScreen; impl Command for EnterAlternateScreen { type AnsiType = &'static str; fn ansi_code(&self) -> Self::AnsiType { ansi::ENTER_ALTERNATE_SCREEN_CSI_SEQUENCE } #[cfg(windows)] fn execute_winapi(&self) -> Result<()> { let alternate_screen = ScreenBuffer::create(); alternate_screen.show()?; Ok(()) } } /// A command that switches back to the main screen. /// /// # Notes /// /// * Commands must be executed/queued for execution otherwise they do nothing. /// * Use [EnterAlternateScreen](./struct.EnterAlternateScreen.html) to enter the alternate screen. /// /// # Examples /// /// ```no_run /// use std::io::{stdout, Write}; /// use crossterm::{execute, Result, terminal::{EnterAlternateScreen, LeaveAlternateScreen}}; /// /// fn main() -> Result<()> { /// execute!(stdout(), EnterAlternateScreen)?; /// /// // Do anything on the alternate screen /// /// execute!(stdout(), LeaveAlternateScreen) /// } /// ``` /// #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct LeaveAlternateScreen; impl Command for LeaveAlternateScreen { type AnsiType = &'static str; fn ansi_code(&self) -> Self::AnsiType { ansi::LEAVE_ALTERNATE_SCREEN_CSI_SEQUENCE } #[cfg(windows)] fn execute_winapi(&self) -> Result<()> { let screen_buffer = ScreenBuffer::from(Handle::current_out_handle()?); screen_buffer.show()?; Ok(()) } } /// Different ways to clear the terminal buffer. #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[derive(Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)] pub enum ClearType { /// All cells. All, /// All cells from the cursor position downwards. FromCursorDown, /// All cells from the cursor position upwards. FromCursorUp, /// All cells at the cursor row. CurrentLine, /// All cells from the cursor position until the new line. UntilNewLine, } /// A command that scrolls the terminal screen a given number of rows up. /// /// # Notes /// /// Commands must be executed/queued for execution otherwise they do nothing. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct ScrollUp(pub u16); impl Command for ScrollUp { type AnsiType = String; fn ansi_code(&self) -> Self::AnsiType { ansi::scroll_up_csi_sequence(self.0) } #[cfg(windows)] fn execute_winapi(&self) -> Result<()> { sys::scroll_up(self.0) } } /// A command that scrolls the terminal screen a given number of rows down. /// /// # Notes /// /// Commands must be executed/queued for execution otherwise they do nothing. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct ScrollDown(pub u16); impl Command for ScrollDown { type AnsiType = String; fn ansi_code(&self) -> Self::AnsiType { ansi::scroll_down_csi_sequence(self.0) } #[cfg(windows)] fn execute_winapi(&self) -> Result<()> { sys::scroll_down(self.0) } } /// A command that clears the terminal screen buffer. /// /// See the [`ClearType`](enum.ClearType.html) enum. /// /// # Notes /// /// Commands must be executed/queued for execution otherwise they do nothing. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct Clear(pub ClearType); impl Command for Clear { type AnsiType = &'static str; fn ansi_code(&self) -> Self::AnsiType { match self.0 { ClearType::All => ansi::CLEAR_ALL_CSI_SEQUENCE, ClearType::FromCursorDown => ansi::CLEAR_FROM_CURSOR_DOWN_CSI_SEQUENCE, ClearType::FromCursorUp => ansi::CLEAR_FROM_CURSOR_UP_CSI_SEQUENCE, ClearType::CurrentLine => ansi::CLEAR_FROM_CURRENT_LINE_CSI_SEQUENCE, ClearType::UntilNewLine => ansi::CLEAR_UNTIL_NEW_LINE_CSI_SEQUENCE, } } #[cfg(windows)] fn execute_winapi(&self) -> Result<()> { sys::clear(self.0) } } /// A command that sets the terminal size `(columns, rows)`. /// /// # Notes /// /// Commands must be executed/queued for execution otherwise they do nothing. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SetSize(pub u16, pub u16); impl Command for SetSize { type AnsiType = String; fn ansi_code(&self) -> Self::AnsiType { ansi::set_size_csi_sequence(self.0, self.1) } #[cfg(windows)] fn execute_winapi(&self) -> Result<()> { sys::set_size(self.0, self.1) } } impl_display!(for ScrollUp); impl_display!(for ScrollDown); impl_display!(for SetSize); impl_display!(for Clear); #[cfg(test)] mod tests { use std::{ io::{stdout, Write}, thread, time, }; use crate::execute; use super::{size, SetSize}; // Test is disabled, because it's failing on Travis CI #[test] #[ignore] fn test_resize_ansi() { try_enable_ansi(); let (width, height) = size().unwrap(); execute!(stdout(), SetSize(35, 35)).unwrap(); // see issue: https://github.com/eminence/terminal-size/issues/11 thread::sleep(time::Duration::from_millis(30)); assert_eq!((35, 35), size().unwrap()); // reset to previous size execute!(stdout(), SetSize(width, height)).unwrap(); // see issue: https://github.com/eminence/terminal-size/issues/11 thread::sleep(time::Duration::from_millis(30)); assert_eq!((width, height), size().unwrap()); } fn try_enable_ansi() -> bool { #[cfg(windows)] { if cfg!(target_os = "windows") { use crate::ansi_support::set_virtual_terminal_processing; // if it is not listed we should try with WinApi to check if we do support ANSI-codes. match set_virtual_terminal_processing(true) { Ok(_) => return true, Err(_) => return false, } } } true } }