Struct UiApp 

pub struct UiApp<'a, ViewId, Delegate, const STACK_DEPTH: usize> { /* private fields */ }

Compatibility app wrapper retained for pre-UiSystem consumers.

Implementations

impl<'a, ViewId, Delegate, const STACK_DEPTH: usize> UiApp<'a, ViewId, Delegate, STACK_DEPTH>

where ViewId: Copy, Delegate: ViewDelegate<'a, ViewId>,

pub fn draw<D>(&self, display: &mut D, bounds: Rectangle)

where D: DrawTarget<Color = Rgb565>,

Draws the full compatibility UI.

pub fn draw_interactive<D>(&self, display: &mut D, bounds: Rectangle)

where D: DrawTarget<Color = Rgb565>,

Draws only interactive chrome and the active view.

pub fn draw_active_view<D>(&self, display: &mut D, bounds: Rectangle)

where D: DrawTarget<Color = Rgb565>,

Draws only the active view body.

pub fn stack_motion(&self, bounds: Rectangle) -> Option<StackMotion>

Returns geometry for a stack transition, if one is active.

pub fn draw_stack_motion_header<D>(&self, display: &mut D, bounds: Rectangle)

where D: DrawTarget<Color = Rgb565>,

Draws only the stack-motion header region.

pub fn draw_stack_motion_base<D>(&self, display: &mut D, bounds: Rectangle)

where D: DrawTarget<Color = Rgb565>,

Draws the base layer for a stack transition.

pub fn draw_stack_motion_overlay<D>(&self, display: &mut D, bounds: Rectangle)

where D: DrawTarget<Color = Rgb565>,

Draws the overlay layer for a stack transition.

impl<'a, ViewId, Delegate, const STACK_DEPTH: usize> UiApp<'a, ViewId, Delegate, STACK_DEPTH>

where ViewId: Copy, Delegate: ViewDelegate<'a, ViewId>,

pub fn new( root: ViewId, delegate: Delegate, theme: FsTheme, i18n: I18n<'a>, ) -> Self

Creates a compatibility app rooted at root.

Examples found in repository

examples/root_delegate.rs (lines 54-59)

fn main() {
    let _ui = UiApp::<AppView, DemoDelegate, 8>::new(
        AppView::Home,
        DemoDelegate::new(),
        FsTheme::default(),
        I18n::new("en", "en", &[]),
    );
}

pub const fn delegate(&self) -> &Delegate

Returns the delegate.

pub fn delegate_mut(&mut self) -> &mut Delegate

Returns the delegate mutably.

pub const fn theme(&self) -> &FsTheme

Returns the active theme.

pub fn theme_mut(&mut self) -> &mut FsTheme

Returns the active theme mutably.

pub const fn i18n(&self) -> &I18n<'a>

Returns the active localization tables.

pub fn i18n_mut(&mut self) -> &mut I18n<'a>

Returns the active localization tables mutably.

pub fn active_view(&self) -> ViewId

Returns the currently visible view identifier.

pub fn is_animating(&self) -> bool

Returns whether a stack animation is active.

Examples found in repository

src/app/ui_app.rs (line 101)

    pub fn handle_touch_result(&mut self, touch: TouchEvent, bounds: Rectangle) -> AppTouchResult {
        if self.is_animating() {
            return AppTouchResult {
                redraw: AppRedraw::None,
                captured: false,
            };
        }

        let nav = self.nav_view(bounds);
        let chrome = nav.handle_touch(&mut self.nav_touch, touch);
        if chrome.action == Some(NavHeaderAction::Back) {
            self.clear_touch_state();
            return AppTouchResult {
                redraw: self
                    .stack
                    .pop()
                    .map(|_| AppRedraw::StackMotion)
                    .unwrap_or(AppRedraw::None),
                captured: true,
            };
        }
        if chrome.captured {
            return AppTouchResult {
                redraw: if chrome.redraw {
                    AppRedraw::Interactive
                } else {
                    AppRedraw::None
                },
                captured: true,
            };
        }

        let response = self.delegate.handle_view_touch(
            self.stack.top(),
            touch,
            nav.body,
            &self.theme,
            &self.i18n,
        );
        AppTouchResult {
            redraw: self.apply_response(response),
            captured: response.captured || response.navigation.is_some(),
        }
    }

pub fn content_frame(&self, bounds: Rectangle) -> Rectangle

Returns the body frame for the active view.

Examples found in repository

src/app/ui_app.rs (line 79)

    pub fn active_view_dirty(&self, bounds: Rectangle) -> Rectangle {
        self.content_frame(bounds)
    }

    /// Advances the compatibility app by one tick.
    pub fn tick(&mut self, dt_ms: u32, bounds: Rectangle) -> AppRedraw {
        if self.stack.advance(dt_ms) {
            return AppRedraw::StackMotion;
        }
        let body = self.content_frame(bounds);
        let response = self
            .delegate
            .tick(self.stack.top(), dt_ms, body, &self.theme, &self.i18n);
        self.apply_response(response)
    }

pub fn active_view_dirty(&self, bounds: Rectangle) -> Rectangle

Returns the dirty region for the active view.

pub fn tick(&mut self, dt_ms: u32, bounds: Rectangle) -> AppRedraw

Advances the compatibility app by one tick.

pub fn handle_touch( &mut self, touch: TouchEvent, bounds: Rectangle, ) -> AppRedraw

Handles one touch event.

pub fn handle_touch_result( &mut self, touch: TouchEvent, bounds: Rectangle, ) -> AppTouchResult

Handles one touch event and returns capture status.

Examples found in repository

src/app/ui_app.rs (line 96)

    pub fn handle_touch(&mut self, touch: TouchEvent, bounds: Rectangle) -> AppRedraw {
        self.handle_touch_result(touch, bounds).redraw
    }

pub fn clear_touch_state(&mut self)

Clears all compatibility touch state.

Examples found in repository

src/app/ui_app.rs (line 111)

    pub fn handle_touch_result(&mut self, touch: TouchEvent, bounds: Rectangle) -> AppTouchResult {
        if self.is_animating() {
            return AppTouchResult {
                redraw: AppRedraw::None,
                captured: false,
            };
        }

        let nav = self.nav_view(bounds);
        let chrome = nav.handle_touch(&mut self.nav_touch, touch);
        if chrome.action == Some(NavHeaderAction::Back) {
            self.clear_touch_state();
            return AppTouchResult {
                redraw: self
                    .stack
                    .pop()
                    .map(|_| AppRedraw::StackMotion)
                    .unwrap_or(AppRedraw::None),
                captured: true,
            };
        }
        if chrome.captured {
            return AppTouchResult {
                redraw: if chrome.redraw {
                    AppRedraw::Interactive
                } else {
                    AppRedraw::None
                },
                captured: true,
            };
        }

        let response = self.delegate.handle_view_touch(
            self.stack.top(),
            touch,
            nav.body,
            &self.theme,
            &self.i18n,
        );
        AppTouchResult {
            redraw: self.apply_response(response),
            captured: response.captured || response.navigation.is_some(),
        }
    }

    /// Clears all compatibility touch state.
    pub fn clear_touch_state(&mut self) {
        self.nav_touch.clear();
        self.delegate.clear_touch_state();
    }

    fn apply_response(&mut self, response: ViewResponse<ViewId>) -> AppRedraw {
        let mut redraw = response.redraw;
        match response.navigation {
            Some(AppNavigation::Push(view)) => {
                self.clear_touch_state();
                if self.stack.push(view).is_ok() {
                    redraw = redraw.merge(AppRedraw::StackMotion);
                }
            }
            Some(AppNavigation::Pop) => {
                self.clear_touch_state();
                if self.stack.pop().is_ok() {
                    redraw = redraw.merge(AppRedraw::StackMotion);
                }
            }
            None => {}
        }
        redraw
    }