Struct AlertSpec 

pub struct AlertSpec<'a, const N: usize> {
    pub kind: AlertKind,
    pub title: Localized<'a>,
    pub message: Localized<'a>,
    pub actions: [AlertAction<'a>; N],
}

Complete alert specification for a fixed number of actions.

Fields

kind: AlertKind

Semantic alert kind.

title: Localized<'a>

Localized title.

message: Localized<'a>

Localized message body.

actions: [AlertAction<'a>; N]

Action definitions displayed in the alert.

Implementations

impl<'a> AlertSpec<'a, 1>

pub const fn error(message: Localized<'a>) -> Self

Creates a one-button error alert.

pub const fn warning(message: Localized<'a>) -> Self

Creates a one-button warning alert.

impl<'a> AlertSpec<'a, 2>

pub const fn confirm(title: Localized<'a>, message: Localized<'a>) -> Self

Creates a two-button confirmation alert.

Examples found in repository

examples/alerts.rs (lines 17-20)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let theme = support::theme();
    let i18n = support::i18n();
    let mut canvas = support::NullCanvas::new(bounds.size);

    let spec = AlertSpec::confirm(
        Localized::new("alert.title", "Delete item?"),
        Localized::new("alert.message", "This action cannot be undone."),
    );
    let mut alert = AlertView::new(spec);
    let panel = alert.panel(bounds, &theme, &i18n);
    alert.draw(&mut canvas, panel, &theme, &i18n);
    let _ = alert.handle_touch(TouchEvent::new(panel.center(), TouchPhase::Start, 1), panel);

    let mut host = AlertHost::<u8, 2>::new();
    let _ = host.present(7, spec);
    let _ = host.layer(bounds, &theme, &i18n);
    host.draw(&mut canvas, bounds, &theme, &i18n);
    let _ = host.handle_touch(
        TouchEvent::new(Point::new(160, 160), TouchPhase::End, 2),
        bounds,
        &theme,
        &i18n,
    );

    let mut modal = ModalHost::new();
    modal.show(3_u8);
    let _ = modal.current(bounds, &theme);
    let _ = Rgb565::BLACK;
}

Trait Implementations

impl<'a, const N: usize> Clone for AlertSpec<'a, N>

fn clone(&self) -> AlertSpec<'a, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, const N: usize> Debug for AlertSpec<'a, N>

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

Formats the value using the given formatter.

impl<'a, const N: usize> PartialEq for AlertSpec<'a, N>

fn eq(&self, other: &AlertSpec<'a, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, const N: usize> Copy for AlertSpec<'a, N>

impl<'a, const N: usize> Eq for AlertSpec<'a, N>

impl<'a, const N: usize> StructuralPartialEq for AlertSpec<'a, N>