Struct NavStack

pub struct NavStack<R> { /* private fields */ }

The screens the user went through to get where they are, root first.

A plain value the app keeps in its model — the runtime never sees it. It exists so the two things that must agree are one object: what App::on_back walks and what App::save_state persists. It serialises whenever the route type does, and it is never empty: there is always a root to fall back to, including after deserialising.

use ltk::{ App, BackResponse, Element, NavStack, text };
use serde::{ Deserialize, Serialize };

#[ derive( Clone, PartialEq, Serialize, Deserialize ) ]
enum Route { Inbox, Thread( u64 ), Settings }

#[ derive( Clone ) ]
enum Msg { Open( Route ), Back }

struct Mail { nav: NavStack<Route> }

impl App for Mail
{
    type Message = Msg;

    fn app_id( &self ) -> &str { "net.example.Mail" }

    fn view( &self ) -> Element<Msg>
    {
        let screen = match self.nav.current()
        {
            Route::Inbox        => text( "inbox" ),
            Route::Thread( id ) => text( format!( "thread {id}" ) ),
            Route::Settings     => text( "settings" ),
        };
        screen.into()
    }

    fn update( &mut self, msg: Msg )
    {
        match msg
        {
            Msg::Open( route ) => self.nav.push( route ),
            Msg::Back          => { self.nav.pop(); }
        }
    }

    fn on_back( &mut self ) -> BackResponse<Msg> { self.nav.back( Msg::Back ) }

    fn save_state( &self ) -> Option<Vec<u8>> { serde_json::to_vec( &self.nav ).ok() }

    fn restore_state( &mut self, state: Vec<u8> )
    {
        if let Ok( nav ) = serde_json::from_slice( &state ) { self.nav = nav; }
    }
}

Implementations

impl<R> NavStack<R>

pub fn new(root: R) -> Self

pub fn current(&self) -> &R

The route on screen.

pub fn current_mut(&mut self) -> &mut R

pub fn push(&mut self, route: R)

Go to route, keeping the current one underneath.

pub fn pop(&mut self) -> Option<R>

Go back one route. None at the root, which stays.

pub fn replace(&mut self, route: R) -> R

Swap the current route for route without growing the stack — a sideways move (tab to tab, step to step) back should not retrace. Returns the route it replaced.

pub fn pop_to_root(&mut self)

pub fn reset(&mut self, root: R)

Start over from a new root.

pub fn can_pop(&self) -> bool

pub fn depth(&self) -> usize

Number of routes, the root included.

pub fn iter(&self) -> impl Iterator<Item = &R>

Routes from the root up to the current one.

pub fn back<M>(&self, pop: M) -> BackResponse<M>

The answer for App::on_back: pop when there is a route to go back to, BackResponse::Unhandled at the root. pop is the app’s message that ends up calling Self::pop.

Trait Implementations

impl<R: Clone> Clone for NavStack<R>

fn clone(&self) -> NavStack<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for NavStack<R>

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

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for NavStack<R>

where R: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: PartialEq> PartialEq for NavStack<R>

fn eq(&self, other: &NavStack<R>) -> 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<R> Serialize for NavStack<R>

where R: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: Eq> Eq for NavStack<R>

impl<R> StructuralPartialEq for NavStack<R>