Struct Builder

pub struct Builder<G> { /* private fields */ }

Implementations

impl<G: GlobalEventHandler> Builder<G>

pub fn disable_hot_reload(&mut self)

Disable hot reloading

pub fn register_widget<T: Widget + Default + 'static>( &mut self, ident: &'static str, )

Register a new widget

pub fn fps(&mut self, fps: u32)

Set the expected frame rate

pub fn emitter(&self) -> Emitter

Returns an Emitter to send messages to components

pub fn template( &mut self, ident: impl Into<String>, template: impl ToSourceKind, ) -> Result<()>

Registers a component as a template-only component.

This component has no state or reacts to any events

pub fn component<C: Component>( &mut self, ident: impl Into<String>, template: impl ToSourceKind, component: C, state: C::State, ) -> Result<ComponentId<C::Message>>

Registers a Component with the runtime. This returns a unique ComponentId that is used to send messages to the component.

A component can only be used once in a template. If you want multiple instances, register the component as a prototype instead, see [RuntimeBuilder::prototype].

pub fn default<C>( &mut self, ident: impl Into<String>, template: impl ToSourceKind, ) -> Result<ComponentId<C::Message>>

where C: Component + Default, C::State: Default,

Registers a Component with the runtime as long as the component and the associated state implements the Default trait. This returns a unique ComponentId that is used to send messages to the component.

pub fn prototype<FC, FS, C>( &mut self, ident: impl Into<String>, template: impl ToSourceKind, proto: FC, state: FS, ) -> Result<()>

where FC: 'static + Fn() -> C, FS: 'static + FnMut() -> C::State, C: Component + 'static,

Registers a Component as a prototype with the Runtime, which allows for multiple instances of the component to exist the templates.

pub fn with_global_event_handler<Eh>( self, global_event_handler: Eh, ) -> Builder<Eh>

where Eh: Fn(Event, &mut TabIndex<'_, '_>, &mut DeferredComponents) -> Option<Event>,

Assign a new event handler (make sure not to forget to add some mechanism to stop the runtime)

pub fn finish<F, B>(self, backend: &mut B, f: F) -> Result<()>

where F: FnMut(&mut Runtime<G>, &mut B) -> Result<()>, B: Backend,

pub fn register_function( &mut self, ident: impl Into<String>, f: impl Into<Function>, ) -> Result<()>