Struct raui_core::application::Application

pub struct Application { /* fields omitted */ }

Implementations

impl Application

pub fn new() -> Self

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

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

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

pub fn map_props<T>(&mut self, type_name: &str) where
    T: 'static + PropsData, 

pub fn unmap_props<T>(&mut self) where
    T: 'static + PropsData, 

pub fn props_to_serializable(
    &self,
    props: Props
) -> Result<PropsDef, ApplicationError>

pub fn node_to_serializable(
    &self,
    node: WidgetNode
) -> Result<WidgetNodeDef, ApplicationError>

pub fn component_to_serializable(
    &self,
    component: WidgetComponent
) -> Result<WidgetComponentDef, ApplicationError>

pub fn unit_to_serializable(
    &self,
    unit: WidgetUnitNode
) -> Result<WidgetUnitNodeDef, ApplicationError>

pub fn props_from_serializable(
    &self,
    props: PropsDef
) -> Result<Props, ApplicationError>

pub fn node_from_serializable(
    &self,
    node: WidgetNodeDef
) -> Result<WidgetNode, ApplicationError>

pub fn component_from_serializable(
    &self,
    component: WidgetComponentDef
) -> Result<WidgetComponent, ApplicationError>

pub fn unit_from_serializable(
    &self,
    unit: WidgetUnitNodeDef
) -> Result<WidgetUnitNode, 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 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>(&self, interactions_engine: &mut I) -> Result<R, E> where
    I: InteractionsEngine<R, E>, 

pub fn messenger(&self) -> &MessageSender

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

pub fn forced_process(&mut self) -> bool

pub fn process(&mut self) -> bool

Trait Implementations

impl Default for Application

pub fn default() -> Self

Returns the "default value" for a type.