Struct oxygengine_user_interface::raui::core::application::Application

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

Fields

animations_delta_time: f32

Implementations

impl Application

pub fn new() -> Application

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

pub fn register_component(
    &mut self,
    type_name: &str,
    processor: fn(WidgetContext<'_>) -> WidgetNode
)

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_props(&mut self, name: &str)

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

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

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

pub fn deserialize_node(
    &self,
    data: Value
) -> 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: Box<dyn MessageData + 'static, Global>
)

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

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

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

pub fn default() -> Application

Returns the “default value” for a type.