Trait iced::application::Application

source ·

pub trait Application: Sized {
    type Executor: Executor;
    type Message: Debug + Send;
    type Theme: Default + StyleSheet;
    type Flags;

    // Required methods
    fn new(flags: Self::Flags) -> (Self, Command<Self::Message>);
    fn title(&self) -> String;
    fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
    fn view(&self) -> Element<'_, Self::Message, Self::Theme, Renderer>;

    // Provided methods
    fn theme(&self) -> Self::Theme { ... }
    fn style(&self) -> <Self::Theme as StyleSheet>::Style { ... }
    fn subscription(&self) -> Subscription<Self::Message> { ... }
    fn scale_factor(&self) -> f64 { ... }
    fn run(settings: Settings<Self::Flags>) -> Result
       where Self: 'static { ... }
}

Expand description

An interactive cross-platform application.

This trait is the main entrypoint of Iced. Once implemented, you can run your GUI application by simply calling run.

On native platforms, it will run in its own window.
On the web, it will take control of the <title> and the <body> of the document.

An Application can execute asynchronous actions by returning a Command in some of its methods. If you do not intend to perform any background work in your program, the Sandbox trait offers a simplified interface.

When using an Application with the debug feature enabled, a debug view can be toggled by pressing F12.

§Examples

The repository has a bunch of examples that use the Application trait:

clock, an application that uses the Canvas widget to draw a clock and its hands to display the current time.
download_progress, a basic application that asynchronously downloads a dummy file of 100 MB and tracks the download progress.
events, a log of native events displayed using a conditional Subscription.
game_of_life, an interactive version of the [Game of Life], invented by [John Horton Conway].
pokedex, an application that displays a random Pokédex entry (sprite included!) by using the PokéAPI.
solar_system, an animated solar system drawn using the Canvas widget and showcasing how to compose different transforms.
stopwatch, a watch with start/stop and reset buttons showcasing how to listen to time.
todos, a todos tracker inspired by TodoMVC.

§A simple “Hello, world!”

If you just want to get started, here is a simple Application that says “Hello, world!”:

use iced::executor;
use iced::{Application, Command, Element, Settings, Theme};

pub fn main() -> iced::Result {
    Hello::run(Settings::default())
}

struct Hello;

impl Application for Hello {
    type Executor = executor::Default;
    type Flags = ();
    type Message = ();
    type Theme = Theme;

    fn new(_flags: ()) -> (Hello, Command<Self::Message>) {
        (Hello, Command::none())
    }

    fn title(&self) -> String {
        String::from("A cool application")
    }

    fn update(&mut self, _message: Self::Message) -> Command<Self::Message> {
        Command::none()
    }

    fn view(&self) -> Element<Self::Message> {
        "Hello, world!".into()
    }
}

Required Associated Types§

source

type Executor: Executor

The Executor that will run commands and subscriptions.

The default executor can be a good starting point!

source

type Message: Debug + Send

The type of messages your Application will produce.

source

type Theme: Default + StyleSheet

The theme of your Application.

source

type Flags

The data needed to initialize your Application.

Required Methods§

source

fn new(flags: Self::Flags) -> (Self, Command<Self::Message>)

Initializes the Application with the flags provided to run as part of the Settings.

Here is where you should return the initial state of your app.

Additionally, you can return a Command if you need to perform some async action in the background on startup. This is useful if you want to load state from a file, perform an initial HTTP request, etc.

source

fn title(&self) -> String

Returns the current title of the Application.

This title can be dynamic! The runtime will automatically update the title of your application when necessary.

source

fn update(&mut self, message: Self::Message) -> Command<Self::Message>

Handles a message and updates the state of the Application.

This is where you define your update logic. All the messages, produced by either user interactions or commands, will be handled by this method.

Any Command returned will be executed immediately in the background.

source