Struct App 

pub struct App<AppData, O: for<'a> FnPersist2<&'a AppData, ScopeID<'static>, HashMap<Arc<SourceID>, Option<Window>>>, T> {
    pub instance: Instance,
    pub driver: Weak<Driver>,
    pub state: StateManager,
    /* private fields */
}

Represents a feather application with a given AppData and persistent outline function O. The outline function must always be a persistent function that takes two parameters, a copy of the AppData, and a ScopeID. It must always return [OutlineReturn].

An App creates all the top level structures needed for Feather to function. It stores all wgpu, winit, and any other global state needed. See App::new for examples.

Fields

instance: Instance

driver: Weak<Driver>

state: StateManager

Implementations

impl<AppData: 'static, O: for<'a> FnPersist2<&'a AppData, ScopeID<'static>, HashMap<Arc<SourceID>, Option<Window>>>, T> App<AppData, O, T>

pub fn new( appstate: AppData, inputs: Vec<AppEvent<AppData>>, outline: O, user_event: Option<Box<dyn FnMut(&mut Self, &ActiveEventLoop, T)>>, driver_init: Option<Box<dyn FnOnce(Weak<Driver>)>>, ) -> Result<(Self, EventLoop<T>, Sender<EventPair<AppData>>, AtomicU64)>

Creates a new feather application. app_state represents the initial state of the application, and will override any value returned by <O as FnPersist2>::init(). inputs must be an array of AppEvent, which can be acquired by boxing and wrapping lambdas using WrapEventEx. The outline must by a persistent function that takes two arguments (and implements FnPersist2): a copy of the AppData, and a ScopeID. It must always return [OutlineReturn].

driver_init is an optional hook used to enable hotloading of resources. user_event is also an optional handler for any user events you generate via an event_loop proxy, which can be created with EventLoop::create_proxy. This is often used to inject appdata changes outside of the input handler.

This function returns 4 values - the App object itself, the EventLoop that you must call EventLoop::run_app on to actually start the application, a channel for sending dynamic AppEvent handlers, and an atomic integer representing the current dynamic slot for any additional events. If your handlers are not going to change after the app has been created, you can ignore the last 2 returns.

Examples

use feather_ui::component::window::Window;
use feather_ui::persist::{ FnPersist2, FnPersistStore };
use feather_ui::{ SourceID, ScopeID, App };
use std::sync::Arc;

struct MyState {
  count: i32
}

struct MyApp {}

impl FnPersistStore for MyApp { type Store = (); }

impl FnPersist2<&MyState, ScopeID<'_>, im::HashMap<Arc<SourceID>, Option<Window>>> for MyApp {
    fn init(&self) -> Self::Store { () }

    fn call(&mut self,  _: Self::Store,  _: &MyState, _: ScopeID<'_>) -> (Self::Store, im::HashMap<Arc<SourceID>, Option<Window>>) {
        ((), im::HashMap::new())
    }
}

let (mut app, event_loop, _, _) = App::<MyState, MyApp, ()>::new(MyState { count: 0 }, Vec::new(), MyApp {}, None, None).unwrap();

// You would then run the app like so (commented out because docs can't test UIs)
// event_loop.run_app(&mut app).unwrap();

pub fn new_any_thread( appstate: AppData, inputs: Vec<AppEvent<AppData>>, outline: O, any_thread: bool, user_event: Option<Box<dyn FnMut(&mut Self, &ActiveEventLoop, T)>>, driver_init: Option<Box<dyn FnOnce(Weak<Driver>)>>, ) -> Result<(Self, EventLoop<T>, Sender<EventPair<AppData>>, AtomicU64)>

This is the same as App::new, but it allows overriding the main thread detection that winit uses. This is necessary for running tests, which don’t run on the main thread.

pub fn with_appstate<R>( &mut self, f: impl FnOnce(AccessCell<'_, '_, AppData>) -> R, ) -> R

This allows modifying the appstate outside of feather’s handling routines. It will be correctly marked as changed if it is modified, and a new frame will be queued.

Trait Implementations

impl<AppData: 'static, T: 'static, O: for<'a> FnPersist2<&'a AppData, ScopeID<'static>, HashMap<Arc<SourceID>, Option<Window>>>> ApplicationHandler<T> for App<AppData, O, T>

fn resumed(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has been resumed.

fn window_event( &mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent, )

Emitted when the OS sends an event to a winit window.

fn device_event( &mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent, )

Emitted when the OS sends an event to a device.

fn user_event(&mut self, event_loop: &ActiveEventLoop, evt: T)

Emitted when an event is sent from EventLoopProxy::send_event.

fn suspended(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has been suspended.

fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause)

Emitted when new events arrive from the OS to be processed.

fn about_to_wait(&mut self, event_loop: &ActiveEventLoop)

Emitted when the event loop is about to block and wait for new events.

fn exiting(&mut self, event_loop: &ActiveEventLoop)

Emitted when the event loop is being shut down.

fn memory_warning(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has received a memory warning.