Struct StackView 

pub struct StackView<'a, ViewId, TitleFor, const N: usize>
where
    TitleFor: Fn(ViewId) -> Localized<'a>,
{ /* private fields */ }

Stack navigation container built on StackNav.

Implementations

impl<'a, ViewId, TitleFor, const N: usize> StackView<'a, ViewId, TitleFor, N>

where ViewId: Copy, TitleFor: Fn(ViewId) -> Localized<'a>,

pub fn new(root: ViewId, title_for: TitleFor) -> Self

Creates a stack view with a root view and title callback.

Examples found in repository

examples/containers.rs (lines 30-33)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let split = SplitView::new(SplitAxis::Horizontal, 620, 12);
    let _layout = split.layout(bounds);

    let mut stack = StackView::<Screen, _, 4>::new(Screen::Devices, |screen| match screen {
        Screen::Devices => Localized::new("screen.devices", "Devices"),
        Screen::DeviceDetail => Localized::new("screen.detail", "Device"),
    });
    let _ = stack.push_view(Screen::DeviceDetail);
    let _ = stack.motion(bounds);
    let _ = stack.handle_touch(
        TouchEvent::new(Point::new(12, 12), TouchPhase::Start, 1),
        bounds,
    );

    let tabs = [
        TabSpec {
            key: TabId::Home,
            icon: "H",
            title: Localized::new("tab.home", "Home"),
        },
        TabSpec {
            key: TabId::Logs,
            icon: "L",
            title: Localized::new("tab.logs", "Logs"),
        },
        TabSpec {
            key: TabId::Settings,
            icon: "S",
            title: Localized::new("tab.settings", "Settings"),
        },
    ];
    let mut tab_view = TabView::new(tabs, 0);
    let _ = tab_view.content_frame(bounds, &support::theme());
    let _ = tab_view.handle_touch(
        TouchEvent::new(Point::new(200, 220), TouchPhase::End, 2),
        bounds,
        &support::theme(),
    );
}

pub fn set_root(&mut self, root: ViewId)

Replaces the whole stack with a new root.

pub fn push_view(&mut self, view: ViewId) -> Result<(), StackError>

Pushes a new view onto the stack.

Examples found in repository

examples/containers.rs (line 34)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let split = SplitView::new(SplitAxis::Horizontal, 620, 12);
    let _layout = split.layout(bounds);

    let mut stack = StackView::<Screen, _, 4>::new(Screen::Devices, |screen| match screen {
        Screen::Devices => Localized::new("screen.devices", "Devices"),
        Screen::DeviceDetail => Localized::new("screen.detail", "Device"),
    });
    let _ = stack.push_view(Screen::DeviceDetail);
    let _ = stack.motion(bounds);
    let _ = stack.handle_touch(
        TouchEvent::new(Point::new(12, 12), TouchPhase::Start, 1),
        bounds,
    );

    let tabs = [
        TabSpec {
            key: TabId::Home,
            icon: "H",
            title: Localized::new("tab.home", "Home"),
        },
        TabSpec {
            key: TabId::Logs,
            icon: "L",
            title: Localized::new("tab.logs", "Logs"),
        },
        TabSpec {
            key: TabId::Settings,
            icon: "S",
            title: Localized::new("tab.settings", "Settings"),
        },
    ];
    let mut tab_view = TabView::new(tabs, 0);
    let _ = tab_view.content_frame(bounds, &support::theme());
    let _ = tab_view.handle_touch(
        TouchEvent::new(Point::new(200, 220), TouchPhase::End, 2),
        bounds,
        &support::theme(),
    );
}

pub fn pop_view(&mut self) -> Result<ViewId, StackError>

Pops the current view off the stack.

pub fn top_view(&self) -> ViewId

Returns the top-most view identifier.

pub fn depth(&self) -> usize

Returns the current stack depth.

pub fn is_animating(&self) -> bool

Returns whether the stack is animating.

pub fn advance(&mut self, dt_ms: u32) -> bool

Advances stack animation state.

pub fn nav_view(&self, frame: Rectangle) -> NavView<'a, ViewId>

Builds a navigation view for the supplied frame.

Examples found in repository

src/containers.rs (line 154)

    pub fn handle_touch(
        &mut self,
        touch: TouchEvent,
        frame: Rectangle,
    ) -> ButtonTouchResponse<NavHeaderAction> {
        self.nav_view(frame)
            .handle_touch(&mut self.header_touch, touch)
    }

    /// Draws stack navigation chrome.
    pub fn draw_chrome<D>(
        &self,
        display: &mut D,
        frame: Rectangle,
        theme: &FsTheme,
        i18n: &I18n<'a>,
    ) where
        D: embedded_graphics::draw_target::DrawTarget<
                Color = embedded_graphics::pixelcolor::Rgb565,
            >,
    {
        self.nav_view(frame)
            .draw_chrome(display, theme, i18n, &self.header_touch);
    }

    /// Returns stack-motion geometry for animated presentation.
    pub fn motion(&self, frame: Rectangle) -> Option<StackMotion> {
        let nav = self.nav_view(frame);
        nav.layers.overlay.map(|overlay| StackMotion {
            header: nav.header,
            body: nav.body,
            overlay: overlay.translated_frame(),
        })
    }

pub fn clear_touch_state(&mut self)

Clears transient header touch state.

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

Routes one touch event to the navigation chrome.

Examples found in repository

examples/containers.rs (lines 36-39)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let split = SplitView::new(SplitAxis::Horizontal, 620, 12);
    let _layout = split.layout(bounds);

    let mut stack = StackView::<Screen, _, 4>::new(Screen::Devices, |screen| match screen {
        Screen::Devices => Localized::new("screen.devices", "Devices"),
        Screen::DeviceDetail => Localized::new("screen.detail", "Device"),
    });
    let _ = stack.push_view(Screen::DeviceDetail);
    let _ = stack.motion(bounds);
    let _ = stack.handle_touch(
        TouchEvent::new(Point::new(12, 12), TouchPhase::Start, 1),
        bounds,
    );

    let tabs = [
        TabSpec {
            key: TabId::Home,
            icon: "H",
            title: Localized::new("tab.home", "Home"),
        },
        TabSpec {
            key: TabId::Logs,
            icon: "L",
            title: Localized::new("tab.logs", "Logs"),
        },
        TabSpec {
            key: TabId::Settings,
            icon: "S",
            title: Localized::new("tab.settings", "Settings"),
        },
    ];
    let mut tab_view = TabView::new(tabs, 0);
    let _ = tab_view.content_frame(bounds, &support::theme());
    let _ = tab_view.handle_touch(
        TouchEvent::new(Point::new(200, 220), TouchPhase::End, 2),
        bounds,
        &support::theme(),
    );
}

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

where D: DrawTarget<Color = Rgb565>,

Draws stack navigation chrome.

pub fn motion(&self, frame: Rectangle) -> Option<StackMotion>

Returns stack-motion geometry for animated presentation.

Examples found in repository

examples/containers.rs (line 35)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let split = SplitView::new(SplitAxis::Horizontal, 620, 12);
    let _layout = split.layout(bounds);

    let mut stack = StackView::<Screen, _, 4>::new(Screen::Devices, |screen| match screen {
        Screen::Devices => Localized::new("screen.devices", "Devices"),
        Screen::DeviceDetail => Localized::new("screen.detail", "Device"),
    });
    let _ = stack.push_view(Screen::DeviceDetail);
    let _ = stack.motion(bounds);
    let _ = stack.handle_touch(
        TouchEvent::new(Point::new(12, 12), TouchPhase::Start, 1),
        bounds,
    );

    let tabs = [
        TabSpec {
            key: TabId::Home,
            icon: "H",
            title: Localized::new("tab.home", "Home"),
        },
        TabSpec {
            key: TabId::Logs,
            icon: "L",
            title: Localized::new("tab.logs", "Logs"),
        },
        TabSpec {
            key: TabId::Settings,
            icon: "S",
            title: Localized::new("tab.settings", "Settings"),
        },
    ];
    let mut tab_view = TabView::new(tabs, 0);
    let _ = tab_view.content_frame(bounds, &support::theme());
    let _ = tab_view.handle_touch(
        TouchEvent::new(Point::new(200, 220), TouchPhase::End, 2),
        bounds,
        &support::theme(),
    );
}