Struct raui_core::application::Application

pub struct Application {
    pub animations_delta_time: Scalar,
    // some fields omitted
}

Fields

animations_delta_time: Scalar

Implementations

impl Application

pub fn new() -> Self

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

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

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

pub fn register_props<T>(&mut self, name: &str) where
    T: 'static + Prefab + PropsData, 

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

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

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

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

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

pub fn last_invalidation_cause(&self) -> &InvalidationCause

pub fn is_dirty(&self) -> bool

pub fn mark_dirty(&mut self)

pub fn does_render_changed(&self) -> bool

pub fn tree(&self) -> &WidgetNode

pub fn rendered_tree(&self) -> &WidgetUnit

pub fn layout_data(&self) -> &Layout

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

pub fn apply(&mut self, tree: WidgetNode)

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

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

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

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

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

pub fn send_message<T>(&mut self, id: &WidgetId, data: T) where
    T: 'static + MessageData, 

pub fn send_message_raw(&mut self, id: &WidgetId, data: Message)

pub fn signals(&self) -> &[Signal]

pub fn consume_signals(&mut self) -> Vec<Signal>

pub fn state_read(&self, id: &WidgetId) -> Option<&Props>

pub fn state_write(&mut self, id: &WidgetId, data: Props)

pub fn state_mutate<F>(&mut self, id: &WidgetId, f: F) where
    F: FnMut(&Props) -> Props, 

pub fn state_mutate_cloned<F>(&mut self, id: &WidgetId, f: F) where
    F: FnMut(&mut Props), 

pub fn forced_process(&mut self) -> bool

pub fn process(&mut self) -> bool

Trait Implementations

impl Default for Application

fn default() -> Self

Returns the “default value” for a type.