Struct patternfly_yew::ValidationFormContext

pub struct ValidationFormContext { /* private fields */ }

Implementations

impl ValidationFormContext

pub fn new(callback: Callback<GroupValidationResult>, state: InputState) -> Self

Examples found in repository

src/form/mod.rs (lines 205-208)

    fn view(&self, ctx: &Context<Self>) -> Html {
        let mut classes = Classes::from("pf-c-form");

        classes.extend(ctx.props().horizontal.clone());

        if ctx.props().limit_width {
            classes.push("pf-m-limit-width");
        }

        let alert = &ctx.props().alert;
        let validation_alert = Self::make_alert(
            self.validation.state,
            (
                ctx.props()
                    .validation_warning_title
                    .as_deref()
                    .unwrap_or("The form contains fields with warnings."),
                &html!(),
            ),
            (
                ctx.props()
                    .validation_error_title
                    .as_deref()
                    .unwrap_or("The form contains fields with errors."),
                &html!(),
            ),
        );

        // reduce by severity

        let alert = match (alert, &validation_alert) {
            (None, None) => None,
            (Some(alert), None) | (None, Some(alert)) => Some(alert),
            (Some(props), Some(validation)) if validation.r#type > props.r#type => Some(validation),
            (Some(props), Some(_)) => Some(props),
        };

        let validation_context = ValidationFormContext::new(
            ctx.link().callback(Msg::GroupValidationChanged),
            self.validation.state,
        );

        html! (
            <ContextProvider<ValidationFormContext> context={validation_context} >
                <form
                    novalidate=true
                    class={classes}
                    id={ctx.props().id.clone()}
                    action={ctx.props().action.clone()}
                    method={ctx.props().method.clone()}
                >

                    if let Some(alert) = alert {
                        <div class="pf-c-form__alert">
                            <Alert
                                inline=true
                                r#type={alert.r#type}
                                title={alert.title.clone()}
                                >
                                { alert.children.clone() }
                            </Alert>
                        </div>
                    } else {
                        <div style="display: none;"></div>
                    }

                    { for ctx.props().children.iter() }

                </form>
            </ContextProvider<ValidationFormContext>>
        )
    }

pub fn is_error(&self) -> bool

pub fn push_state(&self, state: GroupValidationResult)

Examples found in repository

src/form/group.rs (line 239)

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Self::Message::Validate(value) => {
                let state = ctx.props().validator.run(value);
                if self.state != state {
                    self.state = state;
                    ctx.props()
                        .onvalidated
                        .emit(self.state.clone().unwrap_or_default());
                    if let Some((validation_ctx, _)) = ctx
                        .link()
                        .context::<ValidationFormContext>(Callback::noop())
                    {
                        validation_ctx
                            .push_state(GroupValidationResult(self.id.clone(), self.state.clone()));
                    }
                }
            }
        }
        true
    }

pub fn clear_state(&self, id: String)

Examples found in repository

src/form/group.rs (line 252)

    fn destroy(&mut self, ctx: &Context<Self>) {
        if let Some((ctx, _)) = ctx
            .link()
            .context::<ValidationFormContext>(Callback::noop())
        {
            ctx.clear_state(self.id.clone());
        }
    }

Trait Implementations

impl Clone for ValidationFormContext

fn clone(&self) -> ValidationFormContext

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for ValidationFormContext

fn default() -> ValidationFormContext

Returns the “default value” for a type.

impl PartialEq<ValidationFormContext> for ValidationFormContext

fn eq(&self, other: &ValidationFormContext) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ValidationFormContext