ez_tui/components/concrete/forms/

form.rs

use crate::components::concrete::forms::inputs::core::{InputBuilder, InputCpt};
use crate::{
    AttrValue, Attribute, BorderTheme, Component, EzArgs, EzCptIds, EzEvent, EzMsg, EzState, Form,
    FormField, FormFieldValue, FormResult, Legend, Matcher, MockComponent, MockProps, Props, State,
    Theme,
};
use crossterm::event::KeyCode;
use eztui_derive::MockProps;
use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
use ratatui::prelude::Widget;
use ratatui::style::Style;
use ratatui::style::palette::tailwind::GRAY;
use ratatui::widgets::{BorderType, Borders};
use std::collections::HashMap;
use std::fmt::Debug;

/// A component responsible for rendering a form.
#[derive(Debug, MockProps)]
pub struct FormCpt<FID, CID, CA, CS, CM>
where
    FID: EzCptIds,
    CID: EzCptIds,
    CA: EzArgs,
    CS: EzState,
    CM: EzMsg,
{
    props: Props,
    form: Form<FID>,
    inputs: HashMap<FID, Box<dyn InputCpt<CID, CA, CS, CM>>>,
    focus: Option<FID>,
}

impl<FID, CID, CA, CS, CM> FormCpt<FID, CID, CA, CS, CM>
where
    FID: EzCptIds,
    CID: EzCptIds,
    CA: EzArgs,
    CS: EzState,
    CM: EzMsg,
{
    /// Create a new [`FormCpt`] component with a given form.
    #[must_use]
    pub fn new(form: Form<FID>) -> Self {
        let name = form.name().to_string();
        let mut cpt = FormCpt {
            props: Props::default(),
            inputs: form
                .flatten_fields()
                .into_iter()
                .map(|field| (field.id().clone(), InputBuilder::create(field)))
                .collect(),
            form,
            focus: None,
        };
        if let Some(props) = cpt.props_mut() {
            props.set(
                Attribute::Title,
                AttrValue::Title((name, ratatui::prelude::Alignment::Center)),
            );
        }
        cpt
    }

    fn update_focus(&mut self, previous: Option<FID>) {
        if let Some(fid) = previous
            && let Some(cpt) = self.inputs.get_mut(&fid)
            && let Some(props) = cpt.props_mut()
        {
            props.set(Attribute::Focus, AttrValue::Flag(false));
        }

        if let Some(fid) = &self.focus
            && let Some(cpt) = self.inputs.get_mut(fid)
            && let Some(props) = cpt.props_mut()
        {
            props.set(Attribute::Focus, AttrValue::Flag(true));
        }
    }

    /// Collect this form result as a [`FormResult`].
    #[allow(clippy::missing_panics_doc)] // this except should never happen
    pub fn collect(&self) -> FormResult<FID> {
        let result: Vec<(FormField<FID>, FormFieldValue)> = self
            .inputs
            .iter()
            .map(|(fid, v)| {
                (
                    self.form
                        .get(fid)
                        .expect("form and inputs should have matching fields")
                        .clone(),
                    v.get_value(),
                )
            })
            .collect();
        result.into()
    }

    /// Pass the validation event of this form to all its inputs so they can
    /// act on it and return wether or not validation has been handled internally.
    pub fn capture_validation(&mut self) -> bool {
        for ref mut input in self.inputs.values_mut() {
            if input.capture_validation() {
                return true;
            }
        }
        false
    }
}
impl<FID, CID, CA, CS, CM> MockComponent for FormCpt<FID, CID, CA, CS, CM>
where
    FID: EzCptIds,
    CID: EzCptIds,
    CA: EzArgs,
    CS: EzState,
    CM: EzMsg,
{
    fn draw(&mut self, area: Rect, buf: &mut Buffer, theme: &Theme) {
        let block = theme.block(self.props());
        let block_area = block.inner(area);
        block.render(area, buf);

        let mut field_theme = theme.clone();
        field_theme.default_border_theme =
            BorderTheme::new(Borders::ALL, BorderType::Thick, Style::new().fg(GRAY.c500));

        let mut callback = |(input_id, input_area, buf): (FID, Rect, &mut Buffer)| {
            if let Some(field) = self.form.get(&input_id)
                && let Some(input) = self.inputs.get_mut(field.id())
            {
                input.draw(input_area, buf, &field_theme);
            }
        };
        self.form
            .custom_layout()
            .draw(block_area, buf, &mut callback);
    }
}

impl<FID, CID, CA, CS, CM> Component<CID, CA, CS, CM> for FormCpt<FID, CID, CA, CS, CM>
where
    FID: EzCptIds,
    CID: EzCptIds,
    CA: EzArgs,
    CS: EzState,
    CM: EzMsg,
{
    fn on_event(
        &mut self,
        event: EzEvent<CID, CM>,
        state: &mut State<CS>,
    ) -> Vec<EzEvent<CID, CM>> {
        if let Some(fid) = &self.focus
            && let Some(cpt) = self.inputs.get_mut(fid)
        {
            cpt.on_event(event, state)
        } else {
            vec![]
        }
    }

    fn focusable(&self) -> bool {
        true
    }

    fn legend(&self) -> Option<Legend> {
        Legend::new(
            self.form.name.to_string(),
            vec![
                Matcher::new(vec![KeyCode::Enter.into()], "Validate form".into()),
                Matcher::new(
                    vec![KeyCode::Char(' ').into()],
                    "Toggle (range target, check)".into(),
                ),
                Matcher::new(vec![KeyCode::PrintScreen.into()], "Toggle date tz)".into()),
            ],
        )
        .into()
    }

    fn capture_focus(&mut self, forward: bool) -> bool {
        let mut previous = None;
        let new_focus = if let Some(focus) = &self.focus {
            previous = Some(focus.clone());
            if forward {
                focus.after()
            } else {
                focus.before()
            }
        } else if forward {
            FID::first()
        } else {
            FID::last()
        };
        self.focus = new_focus;
        self.update_focus(previous);
        self.focus.is_some()
    }
}
impl<FID, CID, CA, CS, CM> FormCpt<FID, CID, CA, CS, CM>
where
    FID: EzCptIds,
    CID: EzCptIds,
    CA: EzArgs,
    CS: EzState,
    CM: EzMsg,
{
}