Struct AlertView 

pub struct AlertView<'a, const N: usize> {
    pub spec: AlertSpec<'a, N>,
    /* private fields */
}

Drawable alert widget for one AlertSpec.

Fields

spec: AlertSpec<'a, N>

Immutable alert specification.

Implementations

impl<'a, const N: usize> AlertView<'a, N>

pub const fn new(spec: AlertSpec<'a, N>) -> Self

Creates an alert view for a specification.

Examples found in repository

examples/alerts.rs (line 21)

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;
}

pub fn clear_touch_state(&mut self)

Clears transient button state.

pub fn panel( &self, bounds: Rectangle, theme: &FsTheme, i18n: &I18n<'a>, ) -> Rectangle

Returns the preferred panel rectangle for the alert.

Examples found in repository

examples/alerts.rs (line 22)

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;
}

pub fn handle_touch( &mut self, touch: TouchEvent, panel: Rectangle, ) -> ButtonTouchResponse<u8>

Routes one touch event to the alert buttons.

Examples found in repository

examples/alerts.rs (line 24)

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;
}

pub fn draw<D>( &self, display: &mut D, panel: Rectangle, theme: &FsTheme, i18n: &I18n<'a>, )

where D: DrawTarget<Color = Rgb565>,

Draws the alert.

Examples found in repository

examples/alerts.rs (line 23)

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;
}

pub fn draw_state<D>( &self, display: &mut D, panel: Rectangle, theme: &FsTheme, i18n: &I18n<'a>, )

where D: DrawTarget<Color = Rgb565>,

Draws the alert using the current touch state.

Examples found in repository

src/alert/view.rs (line 58)

    pub fn draw<D>(&self, display: &mut D, panel: Rectangle, theme: &FsTheme, i18n: &I18n<'a>)
    where
        D: embedded_graphics::draw_target::DrawTarget<Color = Rgb565>,
    {
        self.draw_state(display, panel, theme, i18n);
    }

Trait Implementations

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

fn clone(&self) -> AlertView<'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 AlertView<'a, N>

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

Formats the value using the given formatter.

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

fn eq(&self, other: &AlertView<'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 AlertView<'a, N>

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

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