Struct Application

pub struct Application<F>
where
    F: Fn(&mut Context) + Send + 'static,
{ /* private fields */ }

Creating a new application creates a root Window and a Context. Views declared within the closure passed to Application::new() are added to the context and rendered into the root window.

Example

Application::new(|cx|{
   // Content goes here
})
.run();

Calling run() on the Application causes the program to enter the event loop and for the main window to display.

Implementations

impl<F> Application<F>

where F: Fn(&mut Context) + 'static + Send,

pub fn new(app: F) -> Self

pub fn ignore_default_theme(self) -> Self

Sets the default built-in theming to be ignored.

pub fn with_scale_policy(self, scale_policy: WindowScalePolicy) -> Self

Change the window’s scale policy. Not part of new() to keep the same signature as the winit backend. This should only be used for HiDPI scaling, use [WindowDescription::scale_factor] to set a separate arbitrary scale factor.

pub fn title(self, title: &str) -> Self

pub fn inner_size(self, size: impl Into<WindowSize>) -> Self

pub fn user_scale_factor(self, factor: f64) -> Self

A scale factor applied on top of any DPI scaling, defaults to 1.0.

pub fn run(self) -> Result<(), ApplicationError>

Open a new window that blocks the current thread until the window is destroyed.

Do not use this in the context of audio plugins, unless it is compiled as a standalone application.

• app - The Vizia application builder.

pub fn open_parented<P: HasRawWindowHandle>(self, parent: &P) -> WindowHandle

Open a new child window.

This function does not block the current thread. This is only to be used in the context of audio plugins.

• parent - The parent window.
• app - The Vizia application builder.

pub fn on_idle<I: 'static + Fn(&mut Context) + Send>(self, callback: I) -> Self

Takes a closure which will be called at the end of every loop of the application.

The callback provides a place to run ‘idle’ processing and happens at the end of each loop but before drawing. If the callback pushes events into the queue in context then the event loop will re-run. Care must be taken not to push events into the queue every time the callback runs unless this is intended.

Example

Application::new(|cx|{
    // Build application here
})
.on_idle(|cx|{
    // Code here runs at the end of every event loop after OS and vizia events have been handled
})
.run();