User Input
Demonstrates one approach to accepting user input. Source user_input.rs.
:::caution Consider using tui-textarea
or
tui-input
crates for more functional text entry UIs. :::
git clone https://github.com/ratatui-org/ratatui.git --branch latestcd ratatuicargo run --example=user_input --features=crossterm
//! # [Ratatui] User Input example//!//! The latest version of this example is available in the [examples] folder in the repository.//!//! Please note that the examples are designed to be run against the `main` branch of the Github//! repository. This means that you may not be able to compile with the latest release version on//! crates.io, or the one that you have installed locally.//!//! See the [examples readme] for more information on finding examples that match the version of the//! library you are using.//!//! [Ratatui]: https://github.com/ratatui-org/ratatui//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
// A simple example demonstrating how to handle user input. This is a bit out of the scope of// the library as it does not provide any input handling out of the box. However, it may helps// some to get started.//// This is a very simple example:// * An input box always focused. Every character you type is registered here.// * An entered character is inserted at the cursor position.// * Pressing Backspace erases the left character before the cursor position// * Pressing Enter pushes the current input in the history of previous messages. **Note: ** as// this is a relatively simple example unicode characters are unsupported and their use will// result in undefined behaviour.//// See also https://github.com/rhysd/tui-textarea and https://github.com/sayanarijit/tui-input/
use std::{error::Error, io};
use ratatui::{ crossterm::{ event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind}, execute, terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen}, }, prelude::*, widgets::{Block, List, ListItem, Paragraph},};
enum InputMode { Normal, Editing,}
/// App holds the state of the applicationstruct App { /// Current value of the input box input: String, /// Position of cursor in the editor area. character_index: usize, /// Current input mode input_mode: InputMode, /// History of recorded messages messages: Vec<String>,}
impl App { const fn new() -> Self { Self { input: String::new(), input_mode: InputMode::Normal, messages: Vec::new(), character_index: 0, } }
fn move_cursor_left(&mut self) { let cursor_moved_left = self.character_index.saturating_sub(1); self.character_index = self.clamp_cursor(cursor_moved_left); }
fn move_cursor_right(&mut self) { let cursor_moved_right = self.character_index.saturating_add(1); self.character_index = self.clamp_cursor(cursor_moved_right); }
fn enter_char(&mut self, new_char: char) { let index = self.byte_index(); self.input.insert(index, new_char); self.move_cursor_right(); }
/// Returns the byte index based on the character position. /// /// Since each character in a string can be contain multiple bytes, it's necessary to calculate /// the byte index based on the index of the character. fn byte_index(&mut self) -> usize { self.input .char_indices() .map(|(i, _)| i) .nth(self.character_index) .unwrap_or(self.input.len()) }
fn delete_char(&mut self) { let is_not_cursor_leftmost = self.character_index != 0; if is_not_cursor_leftmost { // Method "remove" is not used on the saved text for deleting the selected char. // Reason: Using remove on String works on bytes instead of the chars. // Using remove would require special care because of char boundaries.
let current_index = self.character_index; let from_left_to_current_index = current_index - 1;
// Getting all characters before the selected character. let before_char_to_delete = self.input.chars().take(from_left_to_current_index); // Getting all characters after selected character. let after_char_to_delete = self.input.chars().skip(current_index);
// Put all characters together except the selected one. // By leaving the selected one out, it is forgotten and therefore deleted. self.input = before_char_to_delete.chain(after_char_to_delete).collect(); self.move_cursor_left(); } }
fn clamp_cursor(&self, new_cursor_pos: usize) -> usize { new_cursor_pos.clamp(0, self.input.chars().count()) }
fn reset_cursor(&mut self) { self.character_index = 0; }
fn submit_message(&mut self) { self.messages.push(self.input.clone()); self.input.clear(); self.reset_cursor(); }}
fn main() -> Result<(), Box<dyn Error>> { // setup terminal enable_raw_mode()?; let mut stdout = io::stdout(); execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?; let backend = CrosstermBackend::new(stdout); let mut terminal = Terminal::new(backend)?;
// create app and run it let app = App::new(); let res = run_app(&mut terminal, app);
// restore terminal disable_raw_mode()?; execute!( terminal.backend_mut(), LeaveAlternateScreen, DisableMouseCapture )?; terminal.show_cursor()?;
if let Err(err) = res { println!("{err:?}"); }
Ok(())}
fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<()> { loop { terminal.draw(|f| ui(f, &app))?;
if let Event::Key(key) = event::read()? { match app.input_mode { InputMode::Normal => match key.code { KeyCode::Char('e') => { app.input_mode = InputMode::Editing; } KeyCode::Char('q') => { return Ok(()); } _ => {} }, InputMode::Editing if key.kind == KeyEventKind::Press => match key.code { KeyCode::Enter => app.submit_message(), KeyCode::Char(to_insert) => { app.enter_char(to_insert); } KeyCode::Backspace => { app.delete_char(); } KeyCode::Left => { app.move_cursor_left(); } KeyCode::Right => { app.move_cursor_right(); } KeyCode::Esc => { app.input_mode = InputMode::Normal; } _ => {} }, InputMode::Editing => {} } } }}
fn ui(f: &mut Frame, app: &App) { let vertical = Layout::vertical([ Constraint::Length(1), Constraint::Length(3), Constraint::Min(1), ]); let [help_area, input_area, messages_area] = vertical.areas(f.size());
let (msg, style) = match app.input_mode { InputMode::Normal => ( vec![ "Press ".into(), "q".bold(), " to exit, ".into(), "e".bold(), " to start editing.".bold(), ], Style::default().add_modifier(Modifier::RAPID_BLINK), ), InputMode::Editing => ( vec![ "Press ".into(), "Esc".bold(), " to stop editing, ".into(), "Enter".bold(), " to record the message".into(), ], Style::default(), ), }; let text = Text::from(Line::from(msg)).patch_style(style); let help_message = Paragraph::new(text); f.render_widget(help_message, help_area);
let input = Paragraph::new(app.input.as_str()) .style(match app.input_mode { InputMode::Normal => Style::default(), InputMode::Editing => Style::default().fg(Color::Yellow), }) .block(Block::bordered().title("Input")); f.render_widget(input, input_area); match app.input_mode { InputMode::Normal => // Hide the cursor. `Frame` does this by default, so we don't need to do anything here {}
InputMode::Editing => { // Make the cursor visible and ask ratatui to put it at the specified coordinates after // rendering #[allow(clippy::cast_possible_truncation)] f.set_cursor( // Draw the cursor at the current position in the input field. // This position is can be controlled via the left and right arrow key input_area.x + app.character_index as u16 + 1, // Move one line down, from the border to the input line input_area.y + 1, ); } }
let messages: Vec<ListItem> = app .messages .iter() .enumerate() .map(|(i, m)| { let content = Line::from(Span::raw(format!("{i}: {m}"))); ListItem::new(content) }) .collect(); let messages = List::new(messages).block(Block::bordered().title("Messages")); f.render_widget(messages, messages_area);}