Struct Application 

pub struct Application<CID, SID, CA, CS, CM>
where
    CID: EzCptIds,
    SID: EzShipIds,
    CA: EzArgs,
    CS: EzState,
    CM: EzMsg,
{ /* private fields */ }

Application is the struct that will hold all the parts of your TUI application.

It will hold

• the [Args] given on the command line
• the [TUI] - to manage the lifecycle and handle user inputs
• the View - to draw your [Component]s
• the Port - to handle external messages sent from [Ship]s
• the [Subscriptions] - to register what Event your [Component]s and [Ship]s may accept
• a copy of the Sender channel so we can send messages

Example

//! A basic example of a TUI application using ez-tui.

mod actions_list;

use crate::actions_list::ActionsListCpt;
use ez_tui::{Application, EzCptIds, FocusChain, LayoutItem, NoClientShipId};
use ez_tui::{CustomLayout, View};
use ez_tui::{Error, NoClientArgs, NoClientMsg, NoClientState};
use ratatui::layout::Layout;
use ratatui_macros::constraints;
use std::collections::VecDeque;
use std::process::ExitCode;
use strum_macros::EnumIter;

/// Examples components ids
#[derive(Ord, PartialOrd, PartialEq, Eq, Clone, Debug, Hash, Default, EnumIter)]
pub enum MyCptIds {
    /// A dummy
    #[default]
    Dummy,
}
impl EzCptIds for MyCptIds {}
impl FocusChain for MyCptIds {}

type TuiApp = Application<MyCptIds, NoClientShipId, NoClientArgs, NoClientState, NoClientMsg>;
#[tokio::main]
async fn main() -> Result<ExitCode, Error> {
    let (args, logger) = TuiApp::parse();
    let mut app: TuiApp = TuiApp::init(args, logger);

    let mut view = View::new();
    view = view
        .mount(MyCptIds::Dummy, Box::new(ActionsListCpt::default()))
        .layout(CustomLayout::named(
            "Main's layout",
            Layout::horizontal(&constraints![*=1]),
            VecDeque::from([LayoutItem::Component(MyCptIds::Dummy.into())]),
        )?);

    app = app.with_view(view);

    app.start().await;

    Ok(ExitCode::SUCCESS)
}

Implementations

impl<CID, SID, CA, CM> Application<CID, SID, CA, NoClientState, CM>

where CID: EzCptIds, SID: EzShipIds, CA: EzArgs, CM: EzMsg,

Implementation for Applications that explicitly don’t use a state (uses NoClientState instead)

pub fn init(args: AppArguments<CA>, logger: LogSwitcher) -> Self

Create a new Application instance by parsing the command line arguments and creating a [Tui] instance. That application will not support any custom [ClientState] and will use the default NoClientState. If you need some global state for your business logic, you should use with_state instead.

impl<CID, SID, CA, CS, CM> Application<CID, SID, CA, CS, CM>

where CID: EzCptIds, SID: EzShipIds, CA: EzArgs, CS: EzState, CM: EzMsg,

pub fn parse() -> (AppArguments<CA>, LogSwitcher)

Wrap the clap::Parser trait to parse the command line arguments nd initialize logging from them

pub fn with_view(self, view: View<CID, CA, CS, CM>) -> Self

Set a View for this application. The view is the UI part of the application and holds all components rendered to the user.

pub fn with_port(self, port: Port<CID, SID, CA, CS, CM>) -> Self

Set a Port for this application. The port is the interface to the outside world; any data you expect to receive from an external source should be emited in a [Ship]. The port will holds all those ships.

pub fn with_global_key_codes(self, hk: GlobalHotKeys) -> Self

Set the global key codes for this application.

pub fn init_with_state( args: AppArguments<CA>, logger: LogSwitcher, client_state: CS, ) -> Self

Same as init but with a custom [ClientState]

pub fn get_args(&self) -> AppArguments<CA>

Get the original command line arguments

pub fn clone_tx(&mut self) -> Sender<EzEvent<CID, CM>>

Get a clone of the Sender to send Event

pub async fn start(&mut self)

Start the application lifecycle

Panics

If any of those things fails to initialize:

• The TUI cannot be entered
• The channel to send events is already closed

pub fn subscribe_cpt( self, id: &EzCptId<CID>, subs: Vec<(EventClause<CID, CM>, SubClause<CID, SID>)>, ) -> Self

Subscribe a [Component] to a list of Event via a [Sub] struct. A Sub describes what kind of event and in under what circumstances the component should be notified.

pub fn subscribe_ship( self, id: EzShipId<SID>, subs: Vec<(EventClause<CID, CM>, SubClause<CID, SID>)>, ) -> Self

Subscribe a [Ship] to a list of Event via a [Sub] struct. A Sub describes what kind of event and in under what circumstances the ship should be notified.

impl<CID, SID, CA, CS, CM> Application<CID, SID, CA, CS, CM>

where CID: EzCptIds, SID: EzShipIds, CA: EzArgs, CS: EzState, CM: EzMsg,

pub fn set_state(&mut self, state: CS)

Set the state

pub fn unsubscribe_component(&mut self, id: &EzCptId<CID>)

Remoove all subscriptions for a given [Component]

pub fn unsubscribe_ship(&mut self, id: &EzShipId<SID>)

Remove all subscriptions for a given [Ship]

pub fn cpt_subscribed( &self, id: &EzCptId<CID>, clause: &EventClause<CID, CM>, ) -> bool

Check whether a [Component] is subscribed to a given EventClause

pub fn port_subscribed( &self, id: &EzShipId<SID>, clause: &EventClause<CID, CM>, ) -> bool

Check whether a [Ship] is subscribed to a given EventClause