Struct seed::app::App

pub struct App<Ms, Mdl, ElC, GMs = UndefinedGMsg> where
    Ms: 'static,
    Mdl: 'static,
    ElC: View<Ms>,  {
    pub init_cfg: Option<AppInitCfg<Ms, Mdl, ElC, GMs, dyn IntoAfterMount<Ms, Mdl, ElC, GMs>>>,
    pub cfg: Rc<AppCfg<Ms, Mdl, ElC, GMs>>,
    pub data: Rc<AppData<Ms, Mdl>>,
}

Fields

init_cfg: Option<AppInitCfg<Ms, Mdl, ElC, GMs, dyn IntoAfterMount<Ms, Mdl, ElC, GMs>>>

Temporary app configuration that is removed after app begins running.

cfg: Rc<AppCfg<Ms, Mdl, ElC, GMs>>

App configuration available for the entire application lifetime.

data: Rc<AppData<Ms, Mdl>>

Mutable app state

Methods

impl<Ms, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GMs>

We use a struct instead of series of functions, in order to avoid passing repetitive sequences of parameters.

pub fn builder(
    update: UpdateFn<Ms, Mdl, ElC, GMs>,
    view: ViewFn<Mdl, ElC>
) -> AppBuilder<Ms, Mdl, ElC, GMs, UndefinedInitAPI>

Creates a new AppBuilder instance. It's the standard way to create a Seed app.

Then you can call optional builder methods like routes or sink. And you have to call method build_and_start to build and run a new App instance.

NOTE: If your Model doesn't implement Default, you have to call builder method after_mount.

Example

fn update(msg: Msg, model: &mut Model, _orders: &mut impl Orders<Msg, GMsg>) {
  match msg {
      Msg::Clicked => model.clicks += 1,
  }
}

fn view(model: &Model) -> impl View<Msg> {
  vec![
      button![
          format!("Clicked: {}", model.clicks),
          simple_ev(Ev::Click, Msg::Clicked),
      ],
  ]
}

App::builder(update, view)

pub fn update(&self, message: Ms)

This runs whenever the state is changed, ie the user-written update function is called. It updates the state, and any DOM elements affected by this change. todo this is where we need to compare against differences and only update nodes affected by the state change.

We re-create the whole virtual dom each time (Is there a way around this? Probably not without knowing what vars the model holds ahead of time), but only edit the rendered, web_sys dom for things that have been changed. We re-render the virtual DOM on every change, but (attempt to) only change the actual DOM, via web_sys, when we need. The model stored in inner is the old model; updated_model is a newly-calculated one.

pub fn sink(&self, g_msg: GMs)

pub fn process_cmd_and_msg_queue(&self, queue: VecDeque<Effect<Ms, GMs>>)

pub fn patch_window_event_handlers(&self)

pub fn add_message_listener<F>(&self, listener: F) where
    F: Fn(&Ms) + 'static, 

pub fn build(
    init: impl FnOnce(Url, &mut OrdersContainer<Ms, Mdl, ElC, GMs>) -> Init<Mdl> + 'static,
    update: UpdateFn<Ms, Mdl, ElC, GMs>,
    view: ViewFn<Mdl, ElC>
) -> AppBuilder<Ms, Mdl, ElC, GMs, MountPointInitInitAPI<UndefinedMountPoint, InitFn<Ms, Mdl, ElC, GMs>>>

Deprecated since 0.5.0:

Use builder with AppBuilder::{after_mount, before_mount} instead.

pub fn run(self) -> Self

Deprecated since 0.4.2:

Please use AppBuilder.build_and_start instead

App initialization: Collect its fundamental components, setup, and perform an initial render.

Trait Implementations

impl<Ms, Mdl, ElC: View<Ms>, GMs> Clone for App<Ms, Mdl, ElC, GMs>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Ms: 'static, Mdl: 'static, ElC: View<Ms>, GMs> Debug for App<Ms, Mdl, ElC, GMs>

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

Formats the value using the given formatter.