Struct Terminal

pub struct Terminal<In: AsFd, Out: AsFd> { /* private fields */ }

Implementations

impl Terminal<Stdin, Stdout>

pub fn new() -> Result<Self>

Examples found in repository

examples/raw_mode.rs (line 4)

fn main() -> async_tty::Result<()> {
    let terminal = Terminal::new()?;
    println!("cooked mode\n1234567890");
    terminal.set_raw_mode()?;
    println!("raw mode\n1234567890");
    terminal.set_cooked_mode()?;
    println!("cooked mode\n1234567890");
    Ok(())
}

examples/alternate_screen.rs (line 8)

async fn main() -> async_tty::Result<()> {
    let mut terminal = Terminal::new()?;
    terminal.switch_to_alternate_screen().await?;
    println!("alternate screen");
    sleep(Duration::from_secs(2)).await;
    terminal.switch_to_main_screen().await?;
    println!("main screen");
    Ok(())
}

examples/cursor.rs (line 10)

async fn main() -> color_eyre::Result<()> {
    color_eyre::install()?;
    let mut terminal = async_tty::Terminal::new()?;
    terminal.switch_to_alternate_screen().await?;
    let cursor_movements = format!(
        "{}at 20,10{}up 1{}down 2",
        CursorPosition {
            row: 10,
            column: 20,
        },
        CursorUp { count: 1 },
        CursorDown { count: 2 }
    );
    terminal.write_all(cursor_movements.as_bytes()).await?;
    sleep(Duration::from_secs(2)).await;
    terminal.switch_to_main_screen().await?;
    Ok(())
}

impl<In: AsFd, Out: AsFd> Terminal<In, Out>

pub fn set_raw_mode(&self) -> Result<()>

Set the terminal to raw mode

Examples found in repository

examples/raw_mode.rs (line 6)

fn main() -> async_tty::Result<()> {
    let terminal = Terminal::new()?;
    println!("cooked mode\n1234567890");
    terminal.set_raw_mode()?;
    println!("raw mode\n1234567890");
    terminal.set_cooked_mode()?;
    println!("cooked mode\n1234567890");
    Ok(())
}

pub fn set_cooked_mode(&self) -> Result<()>

Set the terminal to cooked mode

Examples found in repository

examples/raw_mode.rs (line 8)

fn main() -> async_tty::Result<()> {
    let terminal = Terminal::new()?;
    println!("cooked mode\n1234567890");
    terminal.set_raw_mode()?;
    println!("raw mode\n1234567890");
    terminal.set_cooked_mode()?;
    println!("cooked mode\n1234567890");
    Ok(())
}

pub async fn switch_to_alternate_screen(&mut self) -> Result<()>

Switch to alternate screen buffer

Examples found in repository

examples/alternate_screen.rs (line 9)

async fn main() -> async_tty::Result<()> {
    let mut terminal = Terminal::new()?;
    terminal.switch_to_alternate_screen().await?;
    println!("alternate screen");
    sleep(Duration::from_secs(2)).await;
    terminal.switch_to_main_screen().await?;
    println!("main screen");
    Ok(())
}

examples/cursor.rs (line 11)

async fn main() -> color_eyre::Result<()> {
    color_eyre::install()?;
    let mut terminal = async_tty::Terminal::new()?;
    terminal.switch_to_alternate_screen().await?;
    let cursor_movements = format!(
        "{}at 20,10{}up 1{}down 2",
        CursorPosition {
            row: 10,
            column: 20,
        },
        CursorUp { count: 1 },
        CursorDown { count: 2 }
    );
    terminal.write_all(cursor_movements.as_bytes()).await?;
    sleep(Duration::from_secs(2)).await;
    terminal.switch_to_main_screen().await?;
    Ok(())
}

pub async fn switch_to_main_screen(&mut self) -> Result<()>

Switch back to main screen buffer

Examples found in repository

examples/alternate_screen.rs (line 12)

async fn main() -> async_tty::Result<()> {
    let mut terminal = Terminal::new()?;
    terminal.switch_to_alternate_screen().await?;
    println!("alternate screen");
    sleep(Duration::from_secs(2)).await;
    terminal.switch_to_main_screen().await?;
    println!("main screen");
    Ok(())
}

examples/cursor.rs (line 23)

async fn main() -> color_eyre::Result<()> {
    color_eyre::install()?;
    let mut terminal = async_tty::Terminal::new()?;
    terminal.switch_to_alternate_screen().await?;
    let cursor_movements = format!(
        "{}at 20,10{}up 1{}down 2",
        CursorPosition {
            row: 10,
            column: 20,
        },
        CursorUp { count: 1 },
        CursorDown { count: 2 }
    );
    terminal.write_all(cursor_movements.as_bytes()).await?;
    sleep(Duration::from_secs(2)).await;
    terminal.switch_to_main_screen().await?;
    Ok(())
}

Trait Implementations

impl<In: AsFd, Out: AsFd> AsyncWrite for Terminal<In, Out>

fn poll_write( self: Pin<&mut Self>, _cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<()>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<()>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<In: AsFd, Out: AsFd> Drop for Terminal<In, Out>

fn drop(&mut self)

Executes the destructor for this type.

impl<In: AsFd, Out: AsFd> Unpin for Terminal<In, Out>