Struct iced::UserInterface

pub struct UserInterface<'a, Message, Renderer> { /* fields omitted */ }

A set of interactive graphical elements with a specific Layout.

It can be updated and drawn.

Iced tries to avoid dictating how to write your event loop. You are in charge of using this type in your system in any way you want.

Methods

impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer>

pub fn build<E: Into<Element<'a, Message, Renderer>>>(
    root: E,
    cache: Cache,
    renderer: &Renderer
) -> Self

Builds a user interface for an Element.

It is able to avoid expensive computations when using a Cache obtained from a previous instance of a UserInterface.

Example

Imagine we want to build a UserInterface for the counter example that we previously wrote. Here is naive way to set up our application loop:

use iced::{UserInterface, Cache};
use iced_wgpu::Renderer;

// Initialization
let mut counter = Counter::new();
let mut cache = Cache::new();
let mut renderer = Renderer::new();

// Application loop
loop {
    // Process system events here...

    // Build the user interface
    let user_interface = UserInterface::build(
        counter.view(),
        cache,
        &renderer,
    );

    // Update and draw the user interface here...
    // ...

    // Obtain the cache for the next iteration
    cache = user_interface.into_cache();
}

pub fn update(&mut self, events: impl Iterator<Item = Event>) -> Vec<Message>

Updates the UserInterface by processing each provided Event.

It returns messages that may have been produced as a result of user interactions. You should feed these to your update logic.

Example

Let's allow our counter to change state by completing the previous example:

use iced::{UserInterface, Cache};
use iced_wgpu::Renderer;

let mut counter = Counter::new();
let mut cache = Cache::new();
let mut renderer = Renderer::new();

// Initialize our event storage
let mut events = Vec::new();

loop {
    // Process system events...

    let mut user_interface = UserInterface::build(
        counter.view(),
        cache,
        &renderer,
    );

    // Update the user interface
    let messages = user_interface.update(events.drain(..));

    cache = user_interface.into_cache();

    // Process the produced messages
    for message in messages {
        counter.update(message);
    }
}

pub fn draw(&self, renderer: &mut Renderer) -> MouseCursor

Draws the UserInterface with the provided Renderer.

It returns the current state of the MouseCursor. You should update the icon of the mouse cursor accordingly in your system.

Example

We can finally draw our counter by completing the last example:

use iced::{UserInterface, Cache};
use iced_wgpu::Renderer;

let mut counter = Counter::new();
let mut cache = Cache::new();
let mut renderer = Renderer::new();
let mut events = Vec::new();

loop {
    // Process system events...

    let mut user_interface = UserInterface::build(
        counter.view(),
        cache,
        &renderer,
    );

    let messages = user_interface.update(events.drain(..));

    // Draw the user interface
    let mouse_cursor = user_interface.draw(&mut renderer);

    cache = user_interface.into_cache();

    for message in messages {
        counter.update(message);
    }

    // Update mouse cursor icon...
    // Flush rendering operations...
}

pub fn into_cache(self) -> Cache

Extract the Cache of the UserInterface, consuming it in the process.

Trait Implementations

impl<'a, Message: Debug, Renderer: Debug> Debug for UserInterface<'a, Message, Renderer>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.