Struct crossterm::Screen

pub struct Screen {
    pub stdout: Arc<TerminalOutput>,
    // some fields omitted
}

This type represents an screen. This screen has an stdout which is used by the program to write to or to execute commands with.

You have to make sure that you pass the correct Screen to the modules cursor, terminal, color, input, style. Most of the time you just have one screen so you could get an instance of that screen with: Screen::default().

The screen can be in two modes at first:

• Alternate modes:

  *Nix style applications often utilize an alternate screen buffer, so that they can modify the entire contents of the buffer, without affecting the application that started them. The alternate buffer is exactly the dimensions of the window, without any scrollback region. For an example of this behavior, consider when vim is launched from bash. Vim uses the entirety of the screen to edit the file, then returning to bash leaves the original buffer unchanged.

• RawModes

  • No line buffering. Normally the terminals uses line buffering. This means that the input will be send to the terminal line by line. With raw mode the input will be send one byte at a time.
  • Input All input has to be written manually by the programmer.
  • Characters The characters are not processed by the terminal driver, but are sent straight through. Special character have no meaning, like backspace will not be interpret as backspace but instead will be directly send to the terminal.
  • Escape characters Note that in raw modes \n \r will move to the new line but the cursor will be at the same position as before on the new line therefor use \n\r to start at the new line at the first cell.

Also this screen has an buffer where you can write to. When you want to write the buffer to the screen you could flush the screen.

// create default screen.
let screen = Screen::default();
// create raw screen.
let mut screen = Screen::new(true);

// write some text to the internal buffer of this type.
screen.write(b"Some text");
screen.write(b"Some more text");
screen.write(b"Some more text");

// write the above text by flushing the internal buffer of this type.
screen.flush();

let screen = Screen::new(false);

// create raw alternate screen from normal screen.
if let Ok(alternate_screen) = screen.enable_alternate_modes(true)
{
    let crossterm = Crossterm::new(&alternate_screen.screen);

    // make sure to pass in the screen of the AlternateScreen.
    crossterm.cursor();
}

Fields

stdout: Arc<TerminalOutput>

Methods

impl Screen

Important traits for Screen

impl Write for Screen

pub fn new(raw_mode: bool) -> Screen

Create new instance of the Screen also specify if the current screen should be in raw mode or normal mode. If you are not sure what raw mode is then pass false or use the Screen::default() to create an instance.

pub fn enable_alternate_modes(&self, raw_mode: bool) -> Result<AlternateScreen>

Switch to alternate screen. This function will return an AlternateScreen instance. If everything went well this type will give you control over the AlternateScreen.

The bool 'raw_mode' specifies whether the alternate screen should be raw mode or not.

What is Alternate screen?

*Nix style applications often utilize an alternate screen buffer, so that they can modify the entire contents of the buffer, without affecting the application that started them. The alternate buffer is exactly the dimensions of the window, without any scrollback region. For an example of this behavior, consider when vim is launched from bash. Vim uses the entirety of the screen to edit the file, then returning to bash leaves the original buffer unchanged.

pub fn write_buf(&mut self, buf: &[u8]) -> Result<usize>

Write buffer to an internal buffer. When you want to write the buffer to screen use flush().

This function is useful if you want to build up some output and when you are ready you could flush the output to the screen.

pub fn flush_buf(&mut self) -> Result<()>

Flush the internal buffer to the screen.

pub fn disable_drop(&mut self)

This will disable the drop which will cause raw modes not to be undone on drop of Screen.

Trait Implementations

impl From<TerminalOutput> for Screen

fn from(stdout: TerminalOutput) -> Self

Create an screen with the given Stdout

impl From<Arc<TerminalOutput>> for Screen

fn from(stdout: Arc<TerminalOutput>) -> Self

Create an screen with the given 'Arc'

impl Default for Screen

fn default() -> Self

Create an new screen which will not be in raw mode or alternate mode.

impl Drop for Screen

fn drop(&mut self)

If the current screen is in raw mode whe need to disable it when the instance goes out of scope.

impl Write for Screen

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this object, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this write.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.