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 delivery_mode: DeliveryMode,
    pub flags: u64,
}

Message is a 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 a very simple and reliable mechanism that effectively decouples widgets from each other. There is no direct way of modifying something during runtime, you have to use messages to change the 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 Send, it can be sent from another thread to a user interface.

Examples

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

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

fn using_messages(my_widget: Handle<UiNode>, ui: &UserInterface) {
    // Send MyWidgetMessage::DoSomething
    ui.send(my_widget, MyWidgetMessage::DoSomething);
    // Send MyWidgetMessage::Foo
    ui.send(my_widget, MyWidgetMessage::Foo(5));
    // Send MyWidgetMessage::Bar
    ui.send(my_widget, MyWidgetMessage::Bar {foo: 1, baz: 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).

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.

delivery_mode: DeliveryMode

Message delivery mode. See DeliveryMode docs for more info.

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 for_widget( handle: Handle<impl ObjectOrVariant<UiNode>>, data: impl MessageData, ) -> UiMessage

Creates a new UI message with the given data for the specified widget.

pub fn from_widget( handle: Handle<impl ObjectOrVariant<UiNode>>, data: impl MessageData, ) -> UiMessage

Creates a new UI message with the given data to be posted from the name of the specified widget.

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_routing_strategy( self, routing_strategy: RoutingStrategy, ) -> UiMessage

Sets the desired routing strategy.

pub fn with_delivery_mode(self, delivery_mode: DeliveryMode) -> UiMessage

Sets the desired delivery mode for the message.

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 a Value message. When the input field receives a Value message with MessageDirection::ToWidget it checks if value needs to be changed and if it does, it re-sends the 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 data_from<T>( &self, handle: Handle<impl ObjectOrVariant<UiNode>>, ) -> Option<&T>

where T: MessageData,

Checks if the message comes from the specified widget (via Self::is_from) and the data type matches the given type and returns a reference to the data.

Example

if let Some(data) = message.data_from::<MyMessage>(widget_handle) {
    // Do something
}

This method call is essentially a shortcut for:

if message.destination() == widget_handle && message.direction() == MessageDirection::FromWidget {
    if let Some(data) = message.data::<MyMessage>() {
        // Do something
    }
}

pub fn data_for<T>( &self, handle: Handle<impl ObjectOrVariant<UiNode>>, ) -> Option<&T>

where T: MessageData,

Checks if the message was sent to the specified widget (via Self::is_for) and the data type matches the given type and returns a reference to the data.

Example

if let Some(data) = message.data_for::<MyMessage>(widget_handle) {
    // Do something
}

This method call is essentially a shortcut for:

if message.destination() == widget_handle && message.direction() == MessageDirection::ToWidget {
    if let Some(data) = message.data::<MyMessage>() {
        // Do something
    }
}

pub fn is_from(&self, handle: Handle<impl ObjectOrVariant<UiNode>>) -> bool

Checks whether the message destination node handle matches the given one and the message direction is MessageDirection::FromWidget.

pub fn is_for(&self, handle: Handle<impl ObjectOrVariant<UiNode>>) -> bool

Checks whether the message destination node handle matches the given one and the message direction is MessageDirection::ToWidget.

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 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 duplicate 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.