Struct Form

pub struct Form { /* private fields */ }

A widget to display data in a collection of fields

Example

let form = Form::new(&["A", "B", "C"], |field| !field.is_empty());

// all fields remain valid until form is submitted.
assert_eq!(form.status().iter().all(|field| field.is_valid()), true);

// fields will now be invalid after submitting.
form.submit();
assert_eq!(form.status().iter().all(|field| field.is_valid()), false);

form.select(FormSelection::Active(0));
form.append_selection('a');
assert!(form.status[0].is_valid());

Implementations

impl Form

pub fn new( fields: &[&str], validation_fn: impl Fn(&str) -> bool + 'static, ) -> Self

Create a new Form from a slice of field titles and a validator function. validation_fn is used to mark fields as either valid or invalid when .status() is called.

pub fn widget(&self) -> impl Widget + '_

Examples found in repository

examples/minimal.rs (line 58)

fn render_app(frame: &mut Frame<CrosstermBackend<Stdout>>, state: &State) {
    match &state.submissions {
        Some(fields) => frame.render_widget(Paragraph::new(fields.join("\n")), frame.size()),
        None => frame.render_widget(state.form.widget(), frame.size()),
    }
}

pub fn select(&mut self, s: FormSelection)

pub fn selected(&self) -> &FormSelection

Examples found in repository

examples/minimal.rs (line 65)

fn handle_input(state: &mut State) -> io::Result<()> {
    if event::poll(Duration::from_millis(250))? {
        if let Event::Key(key) = event::read()? {
            match state.form.selected() {
                FormSelection::NoSelection => match key.code {
                    KeyCode::Esc | KeyCode::Char('q') => state.should_quit = true,
                    KeyCode::Char('s') => {
                        let fields = state.form.submit();
                        if fields.iter().any(|f| !f.is_valid()) {
                        } else {
                            // Field impls Into<String>
                            state.submissions = Some(fields.into_iter().map(Into::into).collect());

                            state.form.deselect();
                        }
                    }
                    _ => {}
                },
                _ => {}
            }

            state.form.input(key.code);
        }
    }

    Ok(())
}

pub fn submit(&mut self) -> Vec<Field<'_>>

Submits form and returns status of fields.

Examples found in repository

examples/minimal.rs (line 69)

fn handle_input(state: &mut State) -> io::Result<()> {
    if event::poll(Duration::from_millis(250))? {
        if let Event::Key(key) = event::read()? {
            match state.form.selected() {
                FormSelection::NoSelection => match key.code {
                    KeyCode::Esc | KeyCode::Char('q') => state.should_quit = true,
                    KeyCode::Char('s') => {
                        let fields = state.form.submit();
                        if fields.iter().any(|f| !f.is_valid()) {
                        } else {
                            // Field impls Into<String>
                            state.submissions = Some(fields.into_iter().map(Into::into).collect());

                            state.form.deselect();
                        }
                    }
                    _ => {}
                },
                _ => {}
            }

            state.form.input(key.code);
        }
    }

    Ok(())
}

pub fn status(&self) -> Vec<Field<'_>>

Returns the state of all fields in the form. Uses a Field struct to indicate whether or not each field’s buffer is valid.

pub fn input(&mut self, key: KeyCode)

Examples found in repository

examples/minimal.rs (line 83)

fn handle_input(state: &mut State) -> io::Result<()> {
    if event::poll(Duration::from_millis(250))? {
        if let Event::Key(key) = event::read()? {
            match state.form.selected() {
                FormSelection::NoSelection => match key.code {
                    KeyCode::Esc | KeyCode::Char('q') => state.should_quit = true,
                    KeyCode::Char('s') => {
                        let fields = state.form.submit();
                        if fields.iter().any(|f| !f.is_valid()) {
                        } else {
                            // Field impls Into<String>
                            state.submissions = Some(fields.into_iter().map(Into::into).collect());

                            state.form.deselect();
                        }
                    }
                    _ => {}
                },
                _ => {}
            }

            state.form.input(key.code);
        }
    }

    Ok(())
}

pub fn append_selection(&mut self, ch: char)

pub fn pop_selection(&mut self)

pub fn deselect(&mut self)

Examples found in repository

examples/minimal.rs (line 75)

fn handle_input(state: &mut State) -> io::Result<()> {
    if event::poll(Duration::from_millis(250))? {
        if let Event::Key(key) = event::read()? {
            match state.form.selected() {
                FormSelection::NoSelection => match key.code {
                    KeyCode::Esc | KeyCode::Char('q') => state.should_quit = true,
                    KeyCode::Char('s') => {
                        let fields = state.form.submit();
                        if fields.iter().any(|f| !f.is_valid()) {
                        } else {
                            // Field impls Into<String>
                            state.submissions = Some(fields.into_iter().map(Into::into).collect());

                            state.form.deselect();
                        }
                    }
                    _ => {}
                },
                _ => {}
            }

            state.form.input(key.code);
        }
    }

    Ok(())
}

pub fn next_field(&mut self)

pub fn prev_field(&mut self)

pub fn submitted(&mut self, submitted: bool)

Set whether the Form has been submitted

pub fn active_field_style(&mut self, style: Style)

pub fn invalid_field_style(&mut self, style: Style)

pub fn hovered_field_style(&mut self, style: Style)

pub fn default_field_style(&mut self, style: Style)

Trait Implementations

impl Default for Form

fn default() -> Self

Returns the “default value” for a type.

impl From<Vec<&str>> for Form

fn from(value: Vec<&str>) -> Self

Converts to this type from the input type.

impl From<Vec<(&str, &str)>> for Form

fn from(value: Vec<(&str, &str)>) -> Self

Converts to this type from the input type.

impl From<Vec<FieldBuffer>> for Form

fn from(value: Vec<FieldBuffer>) -> Self

Converts to this type from the input type.