[][src]Crate iced

Iced is a cross-platform GUI library focused on simplicity and type-safety. Inspired by Elm.

Features

Check out the repository and the examples for more details!

Overview

Inspired by The Elm Architecture, Iced expects you to split user interfaces into four different concepts:

  • State — the state of your application
  • Messages — user interactions or meaningful events that you care about
  • View logic — a way to display your state as widgets that may produce messages on user interaction
  • Update logic — a way to react to messages and update your state

We can build something to see how this works! Let's say we want a simple counter that can be incremented and decremented using two buttons.

We start by modelling the state of our application:

use iced::button;

struct Counter {
    // The counter value
    value: i32,

    // The local state of the two buttons
    increment_button: button::State,
    decrement_button: button::State,
}

Next, we need to define the possible user interactions of our counter: the button presses. These interactions are our messages:

#[derive(Debug, Clone, Copy)]
pub enum Message {
    IncrementPressed,
    DecrementPressed,
}

Now, let's show the actual counter by putting it all together in our view logic:

use iced::{Button, Column, Text};

impl Counter {
    pub fn view(&mut self) -> Column<Message> {
        // We use a column: a simple vertical layout
        Column::new()
            .push(
                // The increment button. We tell it to produce an
                // `IncrementPressed` message when pressed
                Button::new(&mut self.increment_button, Text::new("+"))
                    .on_press(Message::IncrementPressed),
            )
            .push(
                // We show the value of the counter here
                Text::new(self.value.to_string()).size(50),
            )
            .push(
                // The decrement button. We tell it to produce a
                // `DecrementPressed` message when pressed
                Button::new(&mut self.decrement_button, Text::new("-"))
                    .on_press(Message::DecrementPressed),
            )
    }
}

Finally, we need to be able to react to any produced messages and change our state accordingly in our update logic:

impl Counter {
    // ...

    pub fn update(&mut self, message: Message) {
        match message {
            Message::IncrementPressed => {
                self.value += 1;
            }
            Message::DecrementPressed => {
                self.value -= 1;
            }
        }
    }
}

And that's everything! We just wrote a whole user interface. Iced is now able to:

  1. Take the result of our view logic and layout its widgets.
  2. Process events from our system and produce messages for our update logic.
  3. Draw the resulting user interface.

Usage

The Application and Sandbox traits should get you started quickly, streamlining all the process described above!

Re-exports

pub use widget::*;
pub use settings::Settings;
pub use runtime::futures;

Modules

executor

Choose your preferred executor to power your application.

keyboard

Listen and react to keyboard events.

mouse

Listen and react to mouse events.

settings

Configure your application.

widget

Display information and interactive controls in your application.

window

Configure the window of your application in native platforms.

Structs

Color

A color in the sRGB color space.

Command

A collection of async operations.

Point

A 2D point.

Rectangle

A rectangle.

Size

An amount of space in 2 dimensions.

Vector

A 2D vector.

Enums

Align

Alignment on an axis of a container.

Background

The background of some element.

Error

An error that occurred while running an application.

Font

A font.

HorizontalAlignment

The horizontal alignment of some resource.

Length

The strategy used to fill space in a specific dimension.

VerticalAlignment

The vertical alignment of some resource.

Traits

Application

An interactive cross-platform application.

Executor

A type that can run futures.

Sandbox

A sandboxed Application.

Type Definitions

Element

A generic widget.

Result

The result of running an Application.

Subscription

A request to listen to external events.