Struct raui::core::application::Application

pub struct Application {
    pub view_models: ViewModelCollection,
    pub animations_delta_time: f32,
    /* private fields */
}

Contains and orchestrates application layout, animations, interactions, etc.

See the application module for more information and examples.

Fields

view_models: ViewModelCollection

animations_delta_time: f32

The amount of time between the last update, used when calculating animation progress

Implementations

impl Application

pub fn setup<F>(&mut self, f: F)

where F: FnMut(&mut Application),

Setup the application with a given a setup function

We need to run the setup function for the application to register components and properties if we want to support serialization of the UI. We pass it a function that will do the actual registration.

Note: RAUI will work fine without running any setup if UI serialization is not required.

Example

application.setup(setup /* the core setup function from the RAUI prelude */);

If you use crates like the raui_material crate you will want to call it’s setup function as well.

application.setup(raui_material::setup);

pub fn notifier(&self) -> ChangeNotifier

pub fn register_component(&mut self, type_name: &str, processor: FnWidget)

Register’s a component under a string name used when serializing the UI

This function is often used in setup functions for registering batches of components.

Example

fn my_widget(ctx: WidgetContext) -> WidgetNode {
    todo!("make awesome widget");
}

fn setup_widgets(app: &mut Application) {
    app.register_component("my_widget", FnWidget::pointer(my_widget));
}

let mut application = Application::default();

application.setup(setup_widgets);

pub fn unregister_component(&mut self, type_name: &str)

Unregisters a component

See register_component

pub fn register_props<T>(&mut self, name: &str)

where T: 'static + Prefab + PropsData,

Register’s a property type under a string name used when serializing the UI

This function is often used in setup functions for registering batches of properties.

Example

#[derive(PropsData, Debug, Default, Copy, Clone, Serialize, Deserialize)]
struct MyProp {
    awesome: bool,
}

fn setup_properties(app: &mut Application) {
    app.register_props::<MyProp>("MyProp");
}

let mut application = Application::default();

application.setup(setup_properties);

pub fn unregister_props(&mut self, name: &str)

Unregisters a property type

See register_props

pub fn serialize_props(&self, props: &Props) -> Result<Value, PrefabError>

Serialize the given Props to a PrefabValue

pub fn deserialize_props(&self, data: Value) -> Result<Props, PrefabError>

Deserialize Props from a PrefabValue

pub fn serialize_node( &self, data: &WidgetNode ) -> Result<Value, ApplicationError>

Serialize a WidgetNode to a PrefabValue

pub fn deserialize_node( &self, data: Value ) -> Result<WidgetNode, ApplicationError>

Deserialize a WidgetNode from a PrefabValue

pub fn last_invalidation_cause(&self) -> &InvalidationCause

Get the reason that the application state was last invalidated and caused to re-process

pub fn dirty(&self) -> &WidgetIdCommon

Return’s common root widget ID of widgets that has to be to be re-processed

pub fn mark_dirty(&mut self)

Force mark the application as needing to re-process its root

pub fn does_render_changed(&self) -> bool

pub fn tree(&self) -> &WidgetNode

Get the WidgetNode for the application tree

pub fn rendered_tree(&self) -> &WidgetUnit

Get the application widget tree rendered to raw WidgetUnit’s

pub fn layout_data(&self) -> &Layout

Get the application Layout data

pub fn has_layout_widget(&self, id: &WidgetId) -> bool

pub fn apply(&mut self, tree: impl Into<WidgetNode>)

Update the application widget tree

pub fn render<R, T, E>( &self, mapping: &CoordsMapping, renderer: &mut R ) -> Result<T, E>

where R: Renderer<T, E>,

Render the application

pub fn render_change<R, T, E>( &mut self, mapping: &CoordsMapping, renderer: &mut R ) -> Result<Option<T>, E>

where R: Renderer<T, E>,

Render the application, but only if something effecting the rendering has changed and it needs to be re-rendered

pub fn layout<L, E>( &mut self, mapping: &CoordsMapping, layout_engine: &mut L ) -> Result<(), E>

where L: LayoutEngine<E>,

Calculate application layout

pub fn layout_change<L, E>( &mut self, mapping: &CoordsMapping, layout_engine: &mut L ) -> Result<bool, E>

where L: LayoutEngine<E>,

Calculate application layout, but only if something effecting application layout has changed and the layout needs to be re-done

pub fn interact<I, R, E>(&mut self, interactions_engine: &mut I) -> Result<R, E>

where I: InteractionsEngine<R, E>,

Perform interactions on the application using the given interaction engine

pub fn send_message<T>(&mut self, id: &WidgetId, data: T)

where T: 'static + MessageData,

Send a message to the given widget

pub fn send_message_raw(&mut self, id: &WidgetId, data: Box<dyn MessageData>)

Send raw message data to the given widget

pub fn signals(&self) -> &[(WidgetId, Box<dyn MessageData>)]

Get the list of signals that have been sent by widgets

pub fn consume_signals(&mut self) -> Vec<(WidgetId, Box<dyn MessageData>)>

Get the list of signals that have been sent by widgets, consuming the current list so that further calls will not include previously sent signals

pub fn forced_process(&mut self) -> bool

process() application, even if no changes have been detected

pub fn process(&mut self) -> bool

Process the application.

Example

const APP_DATA: &str = "app-data";
const COUNTER: &str = "counter";

/// Some sort of application data.
struct AppData {
    counter: ViewModelValue<i32>,
}

// Make view-model of that data.
let mut view_model = ViewModel::produce(|properties| {
    AppData {
        counter: ViewModelValue::new(0, properties.notifier(COUNTER)),
    }
});

// Get handle to view-model data for access on host side.
// This handle is valid as long as it's view-model is alive.
let mut app_data = view_model.lazy::<AppData>().unwrap();

let mut app = Application::default();
app.view_models.insert(APP_DATA.to_owned(), view_model);
// Do application stuff like interactions, layout, etc...

// Now we call `process` with our process context
app.process();

Now, in our components we can access the AppData from view-model through the widget’s WidgetContext.

fn my_component(mut ctx: WidgetContext) -> WidgetNode {
    let mut data = ctx
        .view_models
        .view_model_mut(APP_DATA)
        .unwrap()
        .write::<AppData>()
        .unwrap();
    *data.counter += 1;

    // widget stuff...
}

Trait Implementations

impl Default for Application

fn default() -> Application

Returns the “default value” for a type.