Struct CoolInput

pub struct CoolInput<H: CustomInputHandler> {
    pub text_data: TextInputData,
    pub scroll_x: usize,
    pub scroll_y: usize,
    pub listening: bool,
    pub custom_input: H,
}

The main input type. Uses a custom input handler (a struct which implements CustomInputHandler)

Fields

text_data: TextInputData

scroll_x: usize

scroll_y: usize

listening: bool

custom_input: H

Implementations

impl<H: CustomInputHandler> CoolInput<H>

pub fn new(handler: H, tab_width: usize) -> Self

Examples found in repository

examples/simple-custom-input.rs (line 26)

fn main() -> Result<(), std::io::Error> {
    let mut my_input = CoolInput::new(MyHandler, 0);
    my_input.listen()?;
    Ok(())
}

examples/basic.rs (line 4)

fn main() -> Result<(), std::io::Error> {
    let mut my_input = CoolInput::new(DefaultInputHandler, 0);
    my_input.listen()?;
    Ok(())
}

examples/full-custom-input.rs (line 56)

fn main() -> Result<(), std::io::Error> {
    let mut cool_input = CoolInput::new(CoolCustomInput, 0);
    cool_input.listen()?;
    Ok(())
}

examples/single-line-input.rs (line 40)

fn main() -> Result<(), std::io::Error> {
    let mut my_input = CoolInput::new(MyHandler, 0);
    my_input.listen()?;
    println!("your input was: '{}'", my_input.text_data.text);
    Ok(())
}

examples/fileeditor.rs (line 126)

    pub fn prompt(prompt: &str) -> Result<bool, std::io::Error> {
        let handler = ConfirmationInputHandler {
            prompt: prompt.to_string(),
            value: false,
        };
        let mut input = CoolInput::new(handler, 0);
        input.listen()?;
        Ok(input.custom_input.value)
    }
}
impl CustomInputHandler for ConfirmationInputHandler {
    fn get_input_transform(&mut self, ctx: HandlerContext) -> InputTransform {
        let prompt_offset = self.prompt.chars().count() as u16;
        InputTransform {
            size: (ctx.terminal_size.0 - prompt_offset, ctx.terminal_size.1),
            offset: (prompt_offset, 0),
        }
    }
    fn after_update_cursor(&mut self, _: HandlerContext) {
        let _ = queue!(stdout(), cursor::Hide);
    }
    fn after_draw_text(&mut self, _: HandlerContext) {
        let _ = set_terminal_line(&self.prompt, 0, 0, false);
    }
    fn handle_key_press(&mut self, key: &Event, _: HandlerContext) -> KeyPressResult {
        if let Event::Key(key_event) = key {
            if key_event.kind == KeyEventKind::Press {
                // Make CTRL + C stop
                if let KeyCode::Char(c) = key_event.code {
                    if c == 'c' && key_event.modifiers.contains(KeyModifiers::CONTROL) {
                        return KeyPressResult::Stop;
                    } else if c == 'y' || c == 'n' {
                        self.value = c == 'y';
                        return KeyPressResult::Stop;
                    }
                }
            }
        }
        KeyPressResult::Handled
    }
}

fn main() -> Result<(), std::io::Error> {
    let args: Vec<_> = env::args().collect();
    if args.len() != 2 {
        println!("please specify a filename!");
        return Ok(());
    }
    let filename = &args[1];
    let mut text = String::new();
    let mut is_new = true;
    if path_exists(filename) {
        text = fs::read_to_string(filename).expect("Unable to read file contents.");
        is_new = false;
    }
    let mut cool_input = CoolInput::new(
        FileEditorInput::open_filename(filename.to_string(), text.to_owned(), is_new),
        0,
    );
    cool_input.text_data.text = text;
    cool_input.listen()?;
    if cool_input.custom_input.original_text != cool_input.text_data.text {
        let save = ConfirmationInputHandler::prompt("Save file? [y/n]").unwrap();
        if save {
            save_file(filename, &cool_input.text_data.text);
        }
    }
    Ok(())
}

pub fn get_terminal_size(&self) -> Result<(u16, u16), Error>

Get the size of the terminal running the program

pub fn get_input_transform(&mut self) -> Result<InputTransform, Error>

pub fn render(&mut self) -> Result<(), Error>

Render all text and update cursor

pub fn cursor_within_screen(&mut self) -> Result<bool, Error>

pub fn handle_event(&mut self, event: Event) -> Result<(), Error>

Handle an event

pub fn listen_quiet(&mut self) -> Result<(), Error>

Start listening for key presses without preparing the terminal

pub fn pre_listen(&mut self) -> Result<(), Error>

Prepare the terminal for input

pub fn post_listen(&mut self) -> Result<(), Error>

Restore the terminal after input is finished.

pub fn listen(&mut self) -> Result<(), Error>

Prepare terminal and start to listen for key presses until finished.

Examples found in repository

examples/simple-custom-input.rs (line 27)

fn main() -> Result<(), std::io::Error> {
    let mut my_input = CoolInput::new(MyHandler, 0);
    my_input.listen()?;
    Ok(())
}

examples/basic.rs (line 5)

fn main() -> Result<(), std::io::Error> {
    let mut my_input = CoolInput::new(DefaultInputHandler, 0);
    my_input.listen()?;
    Ok(())
}

examples/full-custom-input.rs (line 57)

fn main() -> Result<(), std::io::Error> {
    let mut cool_input = CoolInput::new(CoolCustomInput, 0);
    cool_input.listen()?;
    Ok(())
}

examples/single-line-input.rs (line 41)

fn main() -> Result<(), std::io::Error> {
    let mut my_input = CoolInput::new(MyHandler, 0);
    my_input.listen()?;
    println!("your input was: '{}'", my_input.text_data.text);
    Ok(())
}

examples/fileeditor.rs (line 127)

    pub fn prompt(prompt: &str) -> Result<bool, std::io::Error> {
        let handler = ConfirmationInputHandler {
            prompt: prompt.to_string(),
            value: false,
        };
        let mut input = CoolInput::new(handler, 0);
        input.listen()?;
        Ok(input.custom_input.value)
    }
}
impl CustomInputHandler for ConfirmationInputHandler {
    fn get_input_transform(&mut self, ctx: HandlerContext) -> InputTransform {
        let prompt_offset = self.prompt.chars().count() as u16;
        InputTransform {
            size: (ctx.terminal_size.0 - prompt_offset, ctx.terminal_size.1),
            offset: (prompt_offset, 0),
        }
    }
    fn after_update_cursor(&mut self, _: HandlerContext) {
        let _ = queue!(stdout(), cursor::Hide);
    }
    fn after_draw_text(&mut self, _: HandlerContext) {
        let _ = set_terminal_line(&self.prompt, 0, 0, false);
    }
    fn handle_key_press(&mut self, key: &Event, _: HandlerContext) -> KeyPressResult {
        if let Event::Key(key_event) = key {
            if key_event.kind == KeyEventKind::Press {
                // Make CTRL + C stop
                if let KeyCode::Char(c) = key_event.code {
                    if c == 'c' && key_event.modifiers.contains(KeyModifiers::CONTROL) {
                        return KeyPressResult::Stop;
                    } else if c == 'y' || c == 'n' {
                        self.value = c == 'y';
                        return KeyPressResult::Stop;
                    }
                }
            }
        }
        KeyPressResult::Handled
    }
}

fn main() -> Result<(), std::io::Error> {
    let args: Vec<_> = env::args().collect();
    if args.len() != 2 {
        println!("please specify a filename!");
        return Ok(());
    }
    let filename = &args[1];
    let mut text = String::new();
    let mut is_new = true;
    if path_exists(filename) {
        text = fs::read_to_string(filename).expect("Unable to read file contents.");
        is_new = false;
    }
    let mut cool_input = CoolInput::new(
        FileEditorInput::open_filename(filename.to_string(), text.to_owned(), is_new),
        0,
    );
    cool_input.text_data.text = text;
    cool_input.listen()?;
    if cool_input.custom_input.original_text != cool_input.text_data.text {
        let save = ConfirmationInputHandler::prompt("Save file? [y/n]").unwrap();
        if save {
            save_file(filename, &cool_input.text_data.text);
        }
    }
    Ok(())
}