Struct coffee::ui::core::Element

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

A generic Widget.

If you have a widget, you should be able to use widget.into() to turn it into an Element.

Implementations

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

pub fn new(
    widget: impl Widget<Message, Renderer> + 'a
) -> Element<'a, Message, Renderer>

Create a new Element containing the given Widget.

pub fn map<F, B>(self, f: F) -> Element<'a, B, Renderer> where
    Message: 'static + Copy,
    Renderer: 'a,
    B: 'static,
    F: 'static + Fn(Message) -> B, 

Applies a transformation to the produced message of the Element.

This method is useful when you want to decouple different parts of your UI.

Example

Let's say that we want to have a main menu and a gameplay overlay in our game. We can decouple the interfaces nicely using modules and nested messages:

mod main_menu {
    use coffee::ui::core::Element;
    use coffee::ui::Renderer;

    pub struct MainMenu {
        // Our main menu state here...
        // Probably a bunch of `button::State` and other stuff.
    }

    #[derive(Debug, Clone, Copy)]
    pub enum Message {
        // The different interactions of the main menu here...
    }

    impl MainMenu {
        // We probably would have our `update` function here too...

        pub fn layout(&mut self) -> Element<Message, Renderer> {
            // We show the main menu here...
            // The returned `Element` produces `main_menu::Message`
        }
    }
}

mod gameplay_overlay {
    // Analogous to the `main_menu` module
}

use coffee::ui::core::Element;
use coffee::ui::Renderer;
use main_menu::MainMenu;
use gameplay_overlay::GameplayOverlay;

// The state of our UI
enum State {
    MainMenu(MainMenu),
    GameplayOverlay(GameplayOverlay),
    // ...
}

// The messages of our UI
// We nest the messages here
#[derive(Debug, Clone, Copy)]
enum Message {
    MainMenu(main_menu::Message),
    GameplayOverlay(gameplay_overlay::Message),
    // ...
}

// We show the UI here, transforming the local messages of each branch
// into the global `Message` type as needed.
pub fn layout(state: &mut State) -> Element<Message, Renderer> {
    match state {
        State::MainMenu(main_menu) => {
            main_menu.layout().map(Message::MainMenu)
        }
        State::GameplayOverlay(gameplay_overlay) => {
            gameplay_overlay.layout().map(Message::GameplayOverlay)
        }
        // ...
    }
}

This way, neither main_menu nor gameplay_overlay know anything about the global Message type. They become reusable, allowing the user of these modules to compose them together freely.

pub fn explain(self, color: Color) -> Element<'a, Message, Renderer> where
    Message: 'static,
    Renderer: 'a + Renderer, 

Marks the Element as to-be-explained.

The Renderer will explain the layout of the Element graphically. This can be very useful for debugging your layout!

Trait Implementations

impl<'a, Message, Renderer> Debug for Element<'a, Message, Renderer>

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

Formats the value using the given formatter.

impl<'a, Message, Renderer> From<Button<'a, Message>> for Element<'a, Message, Renderer> where
    Renderer: Renderer,
    Message: 'static + Copy + Debug, 

fn from(button: Button<'a, Message>) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<Checkbox<Message>> for Element<'a, Message, Renderer> where
    Renderer: Renderer + Renderer,
    Message: 'static, 

fn from(checkbox: Checkbox<Message>) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<Column<'a, Message, Renderer>> for Element<'a, Message, Renderer> where
    Renderer: 'a,
    Message: 'static, 

fn from(column: Column<'a, Message, Renderer>) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<Image> for Element<'a, Message, Renderer> where
    Renderer: Renderer, 

fn from(image: Image) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<Panel<'a, Message, Renderer>> for Element<'a, Message, Renderer> where
    Renderer: 'static + Renderer,
    Message: 'static, 

fn from(panel: Panel<'a, Message, Renderer>) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<ProgressBar> for Element<'a, Message, Renderer> where
    Renderer: Renderer, 

fn from(progress_bar: ProgressBar) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<Radio<Message>> for Element<'a, Message, Renderer> where
    Renderer: Renderer + Renderer,
    Message: 'static + Copy + Debug, 

fn from(checkbox: Radio<Message>) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>> for Element<'a, Message, Renderer> where
    Renderer: 'a,
    Message: 'static, 

fn from(row: Row<'a, Message, Renderer>) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<Slider<'a, Message>> for Element<'a, Message, Renderer> where
    Renderer: Renderer,
    Message: 'static, 

fn from(slider: Slider<'a, Message>) -> Element<'a, Message, Renderer>

Performs the conversion.

impl<'a, Message, Renderer> From<Text> for Element<'a, Message, Renderer> where
    Renderer: Renderer, 

fn from(text: Text) -> Element<'a, Message, Renderer>

Performs the conversion.