Struct crossterm::TerminalInput[][src]

pub struct TerminalInput<'stdout> { /* fields omitted */ }

Struct that stores an specific platform implementation for input related actions.

Check /examples/input the examples folder on github for more info.

extern crate crossterm;
use self::crossterm::Screen;
use self::crossterm::input;

let screen = Screen::default();
let input = input(&screen);
let result = input.read_line();
let pressed_char = input.read_char();

Methods

impl<'stdout> TerminalInput<'stdout>
[src]

Create new instance of TerminalInput whereon input related actions could be preformed.

Read one line from the user input.

let screen = Screen::default();
let input = input(&screen);
 match input.read_line() {
    Ok(s) => println!("string typed: {}", s),
    Err(e) => println!("error: {}", e),
 }

Read one character from the user input

let screen = Screen::default();
let input = input(&screen);

 match input.read_char() {
    Ok(c) => println!("character pressed: {}", c),
    Err(e) => println!("error: {}", e),
  }

Important traits for AsyncReader

Read the input asynchronously from the user.

This call will not block the current thread.

// we need to enable raw mode otherwise the characters will be outputted by default before we are able to read them.
let screen = Screen::new(true);
let input = input(&screen);

let mut stdin = input.read_async().bytes();

for i in 0..100 {

    // Get the next character typed. This is None if nothing is pressed. And Some(Ok(u8 value of character))
    let a = stdin.next();

    println!("pressed key: {:?}", a);

    if let Some(Ok(b'x')) = a {
        println!("The key: `x` was pressed and program is terminated.");
        break;
    }
    // simulate some timeout so that we can see the character on the screen.
    thread::sleep(time::Duration::from_millis(50));
}

Important traits for AsyncReader

Read the input asynchronously until a certain character is hit.

This is the same as read_async() but stops reading when a certain character is hit.

// we need to enable raw mode otherwise the characters will be outputted by default before we are able to read them.
let screen = Screen::new(true);

let crossterm = Crossterm::new(&screen);
let input = crossterm.input();
let terminal = crossterm.terminal();
let mut cursor = crossterm.cursor();


let mut stdin = input.read_until_async(b'\r').bytes();

for i in 0..100 {
    terminal.clear(ClearType::All);
    cursor.goto(1, 1);
    let a = stdin.next();

    println!("pressed key: {:?}", a);

    if let Some(Ok(b'\r')) = a {
        println!("The enter key is hit and program is not listening to input anymore.");
        break;
    }

    if let Some(Ok(b'x')) = a {
         println!("The key: x was pressed and program is terminated.");
        break;
    }

    thread::sleep(time::Duration::from_millis(100));
}

Auto Trait Implementations

impl<'stdout> Send for TerminalInput<'stdout>

impl<'stdout> Sync for TerminalInput<'stdout>