| //! Managing switching between main and alternate screen buffers. |
| //! |
| //! Note that this implementation uses xterm's new escape sequences for screen switching and thus |
| //! only works for xterm compatible terminals (which should be most terminals nowadays). |
| //! |
| //! # Example |
| //! |
| //! ```rust |
| //! use termion::screen::AlternateScreen; |
| //! use std::io::{Write, stdout}; |
| //! |
| //! fn main() { |
| //! { |
| //! let mut screen = AlternateScreen::from(stdout()); |
| //! write!(screen, "Writing to alternate screen!").unwrap(); |
| //! screen.flush().unwrap(); |
| //! } |
| //! println!("Writing to main screen."); |
| //! } |
| //! ``` |
| |
| use std::io::{self, Write}; |
| use std::ops; |
| use std::fmt; |
| |
| /// Switch to the main screen buffer of the terminal. |
| pub struct ToMainScreen; |
| |
| impl fmt::Display for ToMainScreen { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, csi!("?1049l")) |
| } |
| } |
| |
| /// Switch to the alternate screen buffer of the terminal. |
| pub struct ToAlternateScreen; |
| |
| impl fmt::Display for ToAlternateScreen { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, csi!("?1049h")) |
| } |
| } |
| |
| /// A terminal restorer, which wraps a type implementing Write, and causes all writes to be written |
| /// to an alternate screen. |
| /// |
| /// This is achieved by switching the terminal to the alternate screen on creation and |
| /// automatically switching it back to the original screen on drop. |
| pub struct AlternateScreen<W: Write> { |
| /// The output target. |
| output: W, |
| } |
| |
| impl<W: Write> AlternateScreen<W> { |
| /// Create an alternate screen wrapper struct for the provided output and switch the terminal |
| /// to the alternate screen. |
| pub fn from(mut output: W) -> Self { |
| write!(output, "{}", ToAlternateScreen).expect("switch to alternate screen"); |
| AlternateScreen { output: output } |
| } |
| } |
| |
| impl<W: Write> Drop for AlternateScreen<W> { |
| fn drop(&mut self) { |
| write!(self, "{}", ToMainScreen).expect("switch to main screen"); |
| } |
| } |
| |
| impl<W: Write> ops::Deref for AlternateScreen<W> { |
| type Target = W; |
| |
| fn deref(&self) -> &W { |
| &self.output |
| } |
| } |
| |
| impl<W: Write> ops::DerefMut for AlternateScreen<W> { |
| fn deref_mut(&mut self) -> &mut W { |
| &mut self.output |
| } |
| } |
| |
| impl<W: Write> Write for AlternateScreen<W> { |
| fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
| self.output.write(buf) |
| } |
| |
| fn flush(&mut self) -> io::Result<()> { |
| self.output.flush() |
| } |
| } |