Struct TextInput 

pub struct TextInput { /* private fields */ }

A single line text field.

Key	Action
typing	inserts and speaks the character
Left / Right	moves the cursor and speaks the character
Control + Left / Right	moves by word
Home / End	start / end
Backspace / Delete	deletes and speaks the character
Up / Down	speaks the whole text
Enter	submits (UiEvent::TextSubmitted)
Escape	cancels (UiEvent::Closed)

Implementations

impl TextInput

pub fn new(id: impl Into<String>, prompt: impl Into<String>) -> Self

Creates an empty text field with a spoken prompt.

Examples found in repository

examples/menus.rs (line 62)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Activated { menu, item } => match (menu.as_str(), item.as_str()) {
                ("main", "play") => {
                    let s = ctx.get::<Settings>().expect("settings exist");
                    let text = format!("Good luck, {}! (this is where your game would start)", s.name);
                    ctx.ui.message("intro", text);
                }
                ("main", "options") => {
                    let menu = options_menu(ctx.get::<Settings>().expect("settings exist"));
                    ctx.ui.open(menu);
                }
                ("main", "name") => ctx.ui.open(TextInput::new("name", "Enter your name").max_length(20).required()),
                ("main", "quit") => ctx.ui.open(Confirm::new("quit", "Do you really want to quit?").default_no()),
                ("options", "back") => ctx.ui.close(),
                _ => {}
            },
            UiEvent::Changed { menu, item, value } if menu == "options" => {
                let s = ctx.get_mut::<Settings>().expect("settings exist");
                match item.as_str() {
                    "volume" => s.volume = value.as_f32() / 100.0,
                    "difficulty" => s.difficulty = value.as_index(),
                    "name" => s.name = value.as_str().to_string(),
                    _ => {}
                }
                let volume = s.volume;
                ctx.audio.set_master_volume(volume);
            }
            UiEvent::TextSubmitted { id, text } if id == "name" => {
                ctx.get_mut::<Settings>().expect("settings exist").name = text.clone();
                ctx.speech.speak_queued(format!("Hello, {text}"));
            }
            UiEvent::Confirmed { id, yes: true } if id == "quit" => ctx.quit(),
            _ => {}
        }
    }

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

Pre-fills the field; the cursor is placed at the end.

pub fn password(self) -> Self

Speaks “star” instead of the typed characters.

pub fn max_length(self, max: usize) -> Self

Limits the number of characters.

Examples found in repository

examples/menus.rs (line 62)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Activated { menu, item } => match (menu.as_str(), item.as_str()) {
                ("main", "play") => {
                    let s = ctx.get::<Settings>().expect("settings exist");
                    let text = format!("Good luck, {}! (this is where your game would start)", s.name);
                    ctx.ui.message("intro", text);
                }
                ("main", "options") => {
                    let menu = options_menu(ctx.get::<Settings>().expect("settings exist"));
                    ctx.ui.open(menu);
                }
                ("main", "name") => ctx.ui.open(TextInput::new("name", "Enter your name").max_length(20).required()),
                ("main", "quit") => ctx.ui.open(Confirm::new("quit", "Do you really want to quit?").default_no()),
                ("options", "back") => ctx.ui.close(),
                _ => {}
            },
            UiEvent::Changed { menu, item, value } if menu == "options" => {
                let s = ctx.get_mut::<Settings>().expect("settings exist");
                match item.as_str() {
                    "volume" => s.volume = value.as_f32() / 100.0,
                    "difficulty" => s.difficulty = value.as_index(),
                    "name" => s.name = value.as_str().to_string(),
                    _ => {}
                }
                let volume = s.volume;
                ctx.audio.set_master_volume(volume);
            }
            UiEvent::TextSubmitted { id, text } if id == "name" => {
                ctx.get_mut::<Settings>().expect("settings exist").name = text.clone();
                ctx.speech.speak_queued(format!("Hello, {text}"));
            }
            UiEvent::Confirmed { id, yes: true } if id == "quit" => ctx.quit(),
            _ => {}
        }
    }

pub fn numeric(self) -> Self

Accepts only digits, minus and decimal point.

pub fn required(self) -> Self

Refuses to submit an empty text (default: empty is allowed).

Examples found in repository

examples/menus.rs (line 62)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Activated { menu, item } => match (menu.as_str(), item.as_str()) {
                ("main", "play") => {
                    let s = ctx.get::<Settings>().expect("settings exist");
                    let text = format!("Good luck, {}! (this is where your game would start)", s.name);
                    ctx.ui.message("intro", text);
                }
                ("main", "options") => {
                    let menu = options_menu(ctx.get::<Settings>().expect("settings exist"));
                    ctx.ui.open(menu);
                }
                ("main", "name") => ctx.ui.open(TextInput::new("name", "Enter your name").max_length(20).required()),
                ("main", "quit") => ctx.ui.open(Confirm::new("quit", "Do you really want to quit?").default_no()),
                ("options", "back") => ctx.ui.close(),
                _ => {}
            },
            UiEvent::Changed { menu, item, value } if menu == "options" => {
                let s = ctx.get_mut::<Settings>().expect("settings exist");
                match item.as_str() {
                    "volume" => s.volume = value.as_f32() / 100.0,
                    "difficulty" => s.difficulty = value.as_index(),
                    "name" => s.name = value.as_str().to_string(),
                    _ => {}
                }
                let volume = s.volume;
                ctx.audio.set_master_volume(volume);
            }
            UiEvent::TextSubmitted { id, text } if id == "name" => {
                ctx.get_mut::<Settings>().expect("settings exist").name = text.clone();
                ctx.speech.speak_queued(format!("Hello, {text}"));
            }
            UiEvent::Confirmed { id, yes: true } if id == "quit" => ctx.quit(),
            _ => {}
        }
    }

Trait Implementations

impl Clone for TextInput

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TextInput

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Widget for TextInput

fn id(&self) -> &str

Identifier used in events.

fn open(&mut self, ui: &mut UiContext<'_>)

Called once when the widget becomes active. Announce yourself here.

fn update(&mut self, ui: &mut UiContext<'_>) -> Status

Called every frame while this widget is on top of the stack.

fn value(&self, _item: &str) -> Option<Value>

Current value of an item, used by Ui::value.

fn resume(&mut self, value: Option<Value>, ui: &mut UiContext<'_>)

Called when the widget becomes the top again after the one above closed. value is what the closed widget passed with Status::CloseWith.

fn music(&self) -> Option<&str>

Music that plays while this widget is open, see Menu::music. Widgets above it without music of their own keep it playing.