Struct UiMessage

pub struct UiMessage {
    pub handled: Cell<bool>,
    pub data: Box<dyn MessageData>,
    pub destination: Handle<UiNode>,
    pub direction: MessageDirection,
    pub routing_strategy: RoutingStrategy,
    pub perform_layout: Cell<bool>,
    pub flags: u64,
}

Message is basic communication element that is used to deliver information to widget or to user code.

Motivation

This UI library uses message passing mechanism to communicate with widgets. This is very simple and reliable mechanism that effectively decouples widgets from each other. There is no direct way of modify something during runtime, you have to use messages to change state of ui elements.

Direction

Each message marked with “Direction” field, which means supported routes for message. For example crate::button::ButtonMessage::Click has “Direction: To/From UI” which means that it can be sent either from internals of library or from user code. However crate::widget::WidgetMessage::Focus has “Direction: From UI” which means that only internal library code can send such messages without a risk of breaking anything.

Threading

UiMessage is nor Send or Sync. User interface is a single-thread thing, as well as its messages.

Examples

use fyrox_ui::{
    core::pool::Handle, define_constructor, message::MessageDirection, message::UiMessage, UiNode,
    UserInterface,
};

// Message must be debuggable and comparable.
#[derive(Debug, PartialEq, Clone)]
enum MyWidgetMessage {
    DoSomething,
    Foo(u32),
    Bar { foo: u32, baz: u8 },
}

impl MyWidgetMessage {
    define_constructor!(MyWidgetMessage:DoSomething => fn do_something(), layout: false);
    define_constructor!(MyWidgetMessage:Foo => fn foo(u32), layout: false);
    define_constructor!(MyWidgetMessage:Bar => fn bar(foo: u32, baz: u8), layout: false);
}

fn using_messages(my_widget: Handle<UiNode>, ui: &UserInterface) {
    // Send MyWidgetMessage::DoSomething
    ui.send_message(MyWidgetMessage::do_something(
        my_widget,
        MessageDirection::ToWidget,
    ));
    // Send MyWidgetMessage::Foo
    ui.send_message(MyWidgetMessage::foo(
        my_widget,
        MessageDirection::ToWidget,
        5,
    ));
    // Send MyWidgetMessage::Bar
    ui.send_message(MyWidgetMessage::bar(
        my_widget,
        MessageDirection::ToWidget,
        1,
        2,
    ));
}

Fields

handled: Cell<bool>

Useful flag to check if a message was already handled. It could be used to mark messages as “handled” to prevent any further responses to them. It is especially useful in bubble message routing, when a message is passed through the entire chain of parent nodes starting from current. In this, you can mark a message as “handled” and also check if it is handled or not. For example, this is used in crate::tree::Tree implementation, to prevent double-click to close all the parent trees from current.

data: Box<dyn MessageData>

Actual message data. Use UiMessage::data method to try to downcast the internal data to a specific type.

destination: Handle<UiNode>

Handle of node that will receive message. Please note that all nodes in hierarchy will also receive this message, order is “up-on-tree” (so called “bubble” message routing). T

direction: MessageDirection

Indicates the direction of the message. See MessageDirection docs for more info.

routing_strategy: RoutingStrategy

Defines a way of how the message will behave in the widget tree after it was delivered to the destination node. Default is bubble routing. See RoutingStrategy for more info.

perform_layout: Cell<bool>

Whether or not message requires layout to be calculated first.

Motivation

Some of message handling routines uses layout info, but message loop performed right after layout pass, but some of messages may change layout and this flag tells UI to perform layout before passing message further. In ideal case we’d perform layout after each message, but since layout pass is super heavy we should do it only when it is actually needed.

flags: u64

A custom user flags. Use it if handled flag is not enough.

Implementations

impl UiMessage

pub fn with_data<T>(data: T) -> UiMessage

where T: MessageData,

Creates new UI message with desired data.

pub fn with_destination(self, destination: Handle<UiNode>) -> UiMessage

Sets the desired destination of the message.

pub fn with_direction(self, direction: MessageDirection) -> UiMessage

Sets the desired direction of the message.

pub fn with_handled(self, handled: bool) -> UiMessage

Sets the desired handled flag of the message.

pub fn with_perform_layout(self, perform_layout: bool) -> UiMessage

Sets the desired perform layout flag of the message.

pub fn with_routing_strategy( self, routing_strategy: RoutingStrategy, ) -> UiMessage

Sets the desired routing strategy.

pub fn with_flags(self, flags: u64) -> UiMessage

Sets the desired flags of the message.

pub fn reverse(&self) -> UiMessage

Creates a new copy of the message with reversed direction. Typical use case is to re-send messages to create “response” in a widget. For example you have a float input field and it has Value message. When the input field receives Value message with MessageDirection::ToWidget it checks if value needs to be changed and if it does, it re-sends same message, but with reversed direction back to message queue so every “listener” can reach properly. The input field won’t react at MessageDirection::FromWidget message so there will be no infinite message loop.

pub fn destination(&self) -> Handle<UiNode>

Returns destination widget handle of the message.

pub fn data<T>(&self) -> Option<&T>

where T: MessageData,

Tries to downcast current data of the message to a particular type.

pub fn set_handled(&self, handled: bool)

Sets handled flag.

pub fn handled(&self) -> bool

Returns handled flag.

pub fn direction(&self) -> MessageDirection

Returns direction of the message.

pub fn set_perform_layout(&self, value: bool)

Sets perform layout flag.

pub fn need_perform_layout(&self) -> bool

Returns perform layout flag.

pub fn has_flags(&self, flags: u64) -> bool

Checks if the message has particular flags.

Trait Implementations

impl Clone for UiMessage

fn clone(&self) -> UiMessage

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UiMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for UiMessage

fn eq(&self, other: &UiMessage) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.