Struct finestra::App

pub struct App<Delegate, State = ()> { /* private fields */ }

This is the main entrypoint to the framework. You have to implement the AppDelegate to get notified of specific app lifecycle events.

Example

let app = App::new(());
app.run();

App Lifecycle

The app lifecycle is initiated by the App::run() function, and after that, the platform takes over. Finestra ensures the order of the delegate invocations are consistent:

1. Instantiate an App and call the run() method.
2. The platform will make preparations for your app, and after loading whats necessary, it will call AppDelegate::did_launch()
3. Finestra ensures the creation of a main window, and will call AppDelegate::configure_main_window(). You can override the default implementation to e.g. set a title by using WindowConfiguration::with_title().
4. After configuring the window, the content of the window must be determined. This is done by calling AppDelegate::make_content_view(). Use Labels, Stacks and other views to build your user interface.
5. Finestra will translate those views into the platform-dependent primitives. Before the window is shown, you get a chance to do some last-minute preparations by overriding AppDelegate::will_show_window(). You also get a reference to the Window.
6. After that, you’re done! Respond to events and such by using the State<T> type, or specific-events like Button::with_on_click().

Implementations

impl<Delegate, State: 'static> App<Delegate, State>

where Delegate: AppDelegate<State> + 'static,

pub fn new(delegate: Delegate) -> App<Delegate, ()>

This is the main entrypoint to the framework.

let app = App::new(());
app.run();

pub fn with_state<NewState>( delegate: Delegate, state: NewState ) -> App<Delegate, NewState>

With this function, you can specify a State parameter that gets passed to invocation by the platform to your delegate.

#[derive(Default)]
struct AppState {
    label: State<String>,
}

struct MyApp;
impl AppDelegate<AppState> for MyApp {}

let app = App::with_state(MyApp, AppState::default());
app.run();

pub fn with_backend(self, backend: UIBackend) -> Self

Override the UIBackend for this application. Note that the default is already the most appropriate for the platform, but you can still override that behavior if you’d like.

impl<Delegate, State> App<Delegate, State>

where Delegate: AppDelegate<State> + 'static, State: 'static,

pub fn delegate(&self) -> &Delegate

Get the delegate passed by Self::new() or Self::with_state().

pub fn run(self) -> !

Start the application. At this point, you can no longer make changes to the application configuration. The next thing that gets called is the AppDelegate::did_launch() to signify the application was made aware of to the platform.