Struct App 

pub struct App<AppData, O: FnPersist2<AppData, ScopeID<'static>, HashMap<Arc<SourceID>, Option<Window>>>> {
    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: Clone + PartialEq + 'static, O: FnPersist2<AppData, ScopeID<'static>, HashMap<Arc<SourceID>, Option<Window>>>> App<AppData, O>

pub fn new<T: 'static>( app_state: AppData, inputs: Vec<AppEvent<AppData>>, outline: O, driver_init: impl FnOnce(Weak<Driver>) + 'static, ) -> 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. For most basic applications, it can be set to the empty lambda: |_| ().

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;

#[derive(Clone, PartialEq)]
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 {}, |_| ()).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<T: 'static>( app_state: AppData, inputs: Vec<AppEvent<AppData>>, outline: O, any_thread: bool, driver_init: impl FnOnce(Weak<Driver>) + 'static, ) -> 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.

Trait Implementations

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

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, _: 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.