Struct TextArea 

pub struct TextArea { /* private fields */ }

Multi-line text. Returns the text, lines joined with \n.

Implementations

impl TextArea

pub fn new(prompt: impl Into<String>) -> TextArea

pub fn value(self, value: impl AsRef<str>) -> Self

Start with this text, the caret at its end.

pub fn placeholder(self, placeholder: impl Into<String>) -> Self

Dim text shown while the area is empty.

pub fn char_limit(self, chars: usize) -> Self

At most chars characters (grapheme clusters, so 👨‍👩‍👧 or e and a combining accent is one), line breaks included. Text already there beyond it is cut.

pub fn truncate(text: &str, chars: usize) -> &str

The first chars characters of text as the character limit counts them: grapheme clusters, a line break one. Never cuts a cluster.

pub fn rebind(self, action: &str, keys: impl IntoIterator<Item = Key>) -> Self

Make keys do action (in context textarea; see keymap) on this area only; no keys unbinds it.

pub fn emacs_keys(self) -> Self

Emacs’s keys on top of the defaults: Ctrl+F/B/N/P and Alt+F/B move, Ctrl+K, Ctrl+U, Ctrl+W, Alt+D and Alt+Backspace kill onto the buffer’s kill ring, Ctrl+Y yanks the last kill back and Alt+Y swaps it for an older one, Alt+{ and Alt+} move by paragraph. (Ctrl+D still submits unless submit_key moves it.)

use rich_interact::headless::{run, Script};
use rich_interact::TextArea;

let area = TextArea::new("Note").value("one two").emacs_keys();
let script = Script::new().keys("ctrl+a alt+d ctrl+e ctrl+y ctrl+d");
let (outcome, _) = run(area, script, 30, 6);
assert_eq!(outcome.unwrap().value().as_deref(), Some(" twoone"));

pub fn submit_key(self, key: Key) -> Self

The key that submits (default Ctrl+D).

pub fn height(self, rows: usize) -> Self

Rows of text shown (default 5).

pub fn line_numbers(self, on: bool) -> Self

Number the lines.

pub fn theme(self, theme: Theme) -> Self

pub fn text(&self) -> String

The text so far.

pub fn caret(&self) -> (usize, usize)

The caret: (line, character column).

Trait Implementations

impl Component for TextArea

fn prompt( &mut self, io: &mut dyn LineIo, ) -> Result<Option<String>, NotInteractive>

Without a terminal: every line up to the end of input is the text, cut to the character limit. No lines at all answer with the text the area started with.

type Output = String

fn handle(&mut self, event: &Event, context: &Context<'_>) -> Flow<String>

Handle one event. Ctrl+C never arrives here: the event loop ends the component with Outcome::Interrupted.

fn keymap(&self) -> Keymap

The bindings this component has right now, for a help overlay, a shortcut list or status-bar hints to read (see keymap). A container’s include its focused child’s, before its own. The default declares none.

fn render(&self, context: &Context<'_>) -> View

Render the current state.

fn default_value(&self) -> Option<String>

The value to return when the terminal is not interactive and the policy asks for defaults. None: there is none.

fn start(&mut self, context: &Context<'_>) -> Flow<Self::Output>

Called once, before the component is first painted, with the terminal’s size: for work that needs it, such as rendering content at the width. Returning Done or Cancel finishes the component without waiting for an event. The default does nothing.

fn tick(&self) -> Option<Duration>

How often the component wants Event::Tick, for a spinner or a countdown. None (the default): never.

fn mouse(&self) -> bool

Whether the component wants mouse events (#476): clicks, drags and the wheel. Off by default, since reporting the mouse takes text selection away from the terminal; a component turns it on when its caller opts in, and run then enables mouse reporting for the session.

fn focusable(&self) -> bool

Whether the component takes focus in a container: Tab stops on it and keys go to it. The default: yes. A label, or a component that has finished, says no.

fn focus_step(&mut self, forward: bool) -> bool

Move focus to the next (forward) or previous focus stop inside this component, for Tab and Shift+Tab. false when there is none after the current one, so the container moves on to its next child. The default, for a component that is one stop: false.

fn focus_enter(&mut self, forward: bool) -> bool

Take focus from outside: at the first stop inside when forward, at the last otherwise. false when nothing in it can take focus. The default: whether the component is focusable.