Struct fyrox_ui::UiNode

pub struct UiNode(pub Box<dyn Control>);

UI node is a type-agnostic wrapper for any widget type. Internally, it is just a trait object that provides common widget interface. Its main use is to reduce code bloat (no need to type Box<dyn Control> everywhere, just UiNode) and to provide some useful methods such as type casting, component querying, etc. You could also be interested in Control docs, since it contains all the interesting stuff and detailed description for each method.

Tuple Fields

0: Box<dyn Control>

Implementations

impl UiNode

pub fn new<T>(widget: T) -> Selfwhere T: Control,

Creates a new UI node from any object that implements Control trait. Its main use is to finish widget creation like so:

#[derive(Clone)]
struct MyWidget {
    widget: Widget,
}

struct MyWidgetBuilder {
    widget_builder: WidgetBuilder,
}

impl MyWidgetBuilder {
    pub fn build(self, ctx: &mut BuildContext) -> Handle<UiNode> {
        let my_widget = MyWidget {
            widget: self.widget_builder.build(),
        };

        // Wrap your widget in the type-agnostic wrapper so it can be placed in the UI.
        let node = UiNode::new(my_widget);

        ctx.add_node(node)
    }
}

pub fn cast<T>(&self) -> Option<&T>where T: Control,

Tries to perform direct downcasting to a particular widget type. It is just a simple wrapper for Any::downcast_ref.

pub fn cast_mut<T>(&mut self) -> Option<&mut T>where T: Control,

Tries to perform direct downcasting to a particular widget type. It is just a simple wrapper for Any::downcast_mut.

pub fn query_component<T>(&self) -> Option<&T>where T: 'static,

Tries to fetch a component of the given type T. At very basis it mimics Self::cast behaviour, but also allows you to fetch components of other types as well. For example, your widget may be built on top of existing one (via composition) and you have it as a field inside your widget. In this case, you can fetch it by using this method with the appropriate type. See docs for Control::query_component for more info.

pub fn has_component<T>(&self) -> boolwhere T: 'static,

This method checks if the widget has a component of the given type T. Internally, it queries the component of the given type and checks if it exists.

Trait Implementations

impl Deref for UiNode

type Target = dyn Control<Target = Widget>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for UiNode

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.