Struct Context 

pub struct Context {
    pub tree: Tree<Entity>,
    pub tree_updates: Vec<Option<TreeUpdate>>,
    pub windows: HashMap<Entity, WindowState>,
    pub mouse: MouseState<Entity>,
    pub text_context: TextContext,
    pub ignore_default_theme: bool,
    pub window_has_focus: bool,
    pub ime_state: ImeState,
    /* private fields */
}

The main storage and control object for a Vizia application.

Fields

tree: Tree<Entity>

tree_updates: Vec<Option<TreeUpdate>>

windows: HashMap<Entity, WindowState>

mouse: MouseState<Entity>

text_context: TextContext

ignore_default_theme: bool

window_has_focus: bool

ime_state: ImeState

Implementations

impl Context

pub fn new() -> Self

Creates a new context.

pub fn current(&self) -> Entity

The “current” entity, generally the entity which is currently being built or the entity which is currently having an event dispatched to it.

pub fn with_current<T>( &mut self, current: Entity, f: impl FnOnce(&mut Context) -> T, ) -> T

Makes the above black magic more explicit

pub fn environment(&self) -> &Environment

Returns a reference to the Environment model.

pub fn parent_window(&self) -> Entity

Returns the entity id of the parent window to the current view.

pub fn scale_factor(&self) -> f32

Returns the scale factor of the display.

pub fn needs_redraw(&mut self, entity: Entity)

Mark the application as needing to rerun the draw method

pub fn needs_restyle(&mut self, entity: Entity)

Mark the application as needing to recompute view styles

pub fn needs_retransform(&mut self, entity: Entity)

pub fn needs_reclip(&mut self, entity: Entity)

pub fn needs_relayout(&mut self)

Mark the application as needing to rerun layout computations

pub fn focus_with_visibility(&mut self, focus_visible: bool)

Sets application focus to the current entity with the specified focus visiblity

pub fn focus(&mut self)

Sets application focus to the current entity using the previous focus visibility

pub fn remove(&mut self, entity: Entity)

Removes the provided entity from the application.

pub fn toggle_class(&mut self, name: &str, applied: impl Res<bool>)

Sets whether a view should have the given class name.

pub fn add_listener<F, W>(&mut self, listener: F)

where W: View, F: 'static + Fn(&mut W, &mut EventContext<'_>, &mut Event),

Add a listener to an entity.

A listener can be used to handle events which would not normally propagate to the entity. For example, mouse events when a different entity has captured them. Useful for things like closing a popup when clicking outside of its bounding box.

pub fn add_global_listener<F>(&mut self, listener: F)

where F: 'static + Fn(&mut EventContext<'_>, &mut Event),

Adds a global listener to the application.

Global listeners have the first opportunity to handle every event that is sent in an application. They will never be removed. If you need a listener tied to the lifetime of a view, use add_listener.

pub fn load_font_mem(&mut self, data: impl AsRef<[u8]>)

Loads a font into the application from in-memory bytes.

pub fn resource_status_signal( &mut self, path: impl Into<String>, ) -> Signal<LoadingStatus>

Returns a reactive loading-status signal for the provided resource path.

The signal value is updated by resource loaders as the request progresses.

pub fn resource_status(&mut self, path: impl Into<String>) -> LoadingStatus

Returns the current loading status for the provided resource path.

This reads from the same reactive signal used by Context::resource_status_signal.

pub fn add_font( &mut self, path: impl Into<String>, options: Option<ResourceLoadOptions>, )

Adds a font to the application by loading it through the configured resource loaders.

This supports local files (including file:// URLs) and any custom loader you register.

pub fn add_image( &mut self, name: impl Into<String>, path: impl Into<String>, policy: ImageRetentionPolicy, options: Option<ResourceLoadOptions>, ) -> Signal<LoadingStatus>

Queues an image resource request and returns a reactive loading-status signal.

name is the key used to reference the image from CSS and Image::new. path can be a filesystem path, file:// URL, or HTTP(S) URL (with url-loader).

pub fn add_translation_file( &mut self, lang: LanguageIdentifier, path: impl Into<String>, options: Option<ResourceLoadOptions>, )

Adds a translation file to the application by loading it through the configured resource loaders.

This supports local files (including file:// URLs), HTTP(S) URLs when the url-loader feature is enabled, and any custom loader you register.

pub fn focused_element(&self) -> Option<&'static str>

Returns the element name (e.g. "textbox") of the currently focused view, or None if the focused entity has no view or the view doesn’t declare an element name.

Mirrors [BackendContext::focused_element] for use from contexts (such as the on_idle application callback) that receive a &mut Context directly.

pub fn add_stylesheet(&mut self, style: impl IntoCssStr) -> Result<(), Error>

pub fn add_built_in_styles(&mut self)

Remove all user themes from the application.

pub fn add_built_in_translations(&mut self)

Adds built-in translations for default view strings.

pub fn add_animation(&mut self, animation: AnimationBuilder<'_>) -> Animation

pub fn add_resource_loader<L: ResourceLoader>(&mut self, loader: L)

Adds a resource loader to the loading chain.

Loaders are tried in list order, and this method inserts at the front so custom loaders take priority over built-in loaders. The first loader that returns true handles the request, and subsequent loaders are skipped.

pub fn load_translation( &mut self, lang: LanguageIdentifier, ftl: impl ToString, ) -> Result<(), TranslationError>

Loads a translation into the application for the provided language.

Returns an error if the FTL syntax is invalid or the resource cannot be added to the bundle.

pub fn add_timer( &mut self, interval: Duration, duration: Option<Duration>, callback: impl Fn(&mut EventContext<'_>, TimerAction) + 'static, ) -> Timer

Adds a timer to the application.

interval - The time between ticks of the timer. duration - An optional duration for the timer. Pass None for a continuos timer. callback - A callback which is called on when the timer is started, ticks, and stops. Disambiguated by the TimerAction parameter of the callback.

Returns a Timer id which can be used to start and stop the timer.

Example

Creates a timer which calls the provided callback every second for 5 seconds:

let timer = cx.add_timer(Duration::from_secs(1), Some(Duration::from_secs(5)), |cx, reason|{
    match reason {
        TimerAction::Start => {
            debug!("Start timer");
        }
     
        TimerAction::Tick(delta) => {
            debug!("Tick timer: {:?}", delta);
        }

        TimerAction::Stop => {
            debug!("Stop timer");
        }
    }
});

pub fn start_timer(&mut self, timer: Timer)

Starts a timer with the provided timer id.

Events sent within the timer callback provided in add_timer() will target the current view.

pub fn modify_timer( &mut self, timer: Timer, timer_function: impl Fn(&mut TimerState), )

Modifies the state of an existing timer with the provided Timer id.

pub fn timer_is_running(&mut self, timer: Timer) -> bool

Returns true if the timer with the provided timer id is currently running.

pub fn stop_timer(&mut self, timer: Timer)

Stops the timer with the given timer id.

Any events emitted in response to the timer stopping, as determined by the callback provided in add_timer(), will target the view which called start_timer().

pub fn load_image( &mut self, path: &str, data: &'static [u8], policy: ImageRetentionPolicy, )

Loads an image from memory and associates it with the provided path.

pub fn load_svg( &mut self, path: &str, data: &[u8], policy: ImageRetentionPolicy, ) -> ImageId

pub fn spawn<F>(&self, target: F)

where F: 'static + Send + FnOnce(&mut ContextProxy),

pub fn get_proxy(&self) -> ContextProxy

pub fn set_ime_state(&mut self, new_state: ImeState)

Trait Implementations

impl<V> AsMut<Context> for Handle<'_, V>

fn as_mut(&mut self) -> &mut Context

Converts this type into a mutable reference of the (usually inferred) input type.

impl DataContext for Context

fn try_data<T: 'static>(&self) -> Option<&T>

Get model/view data from the context. Returns None if the data does not exist.

fn localization_context(&self) -> Option<LocalizationContext<'_>>

Convert the current context into a LocalizationContext.

fn data<T: 'static>(&self) -> &T

Get model/view data from the context. Panics if the data does not exist.

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.

impl EmitContext for Context

fn emit<M: Any>(&mut self, message: M)

Send an event containing the provided message up the tree from the current entity.

fn emit_to<M: Any>(&mut self, target: Entity, message: M)

Send an event containing the provided message directly to a specified entity from the current entity.

fn emit_custom(&mut self, event: Event)

Send a custom event with custom origin and propagation information.

fn schedule_emit<M: Any>(&mut self, message: M, at: Instant) -> TimedEventHandle

Send an event containing the provided message up the tree at a particular time instant.

fn schedule_emit_to<M: Any>( &mut self, target: Entity, message: M, at: Instant, ) -> TimedEventHandle

Send an event containing the provided message directly to a specified view at a particular time instant.

fn schedule_emit_custom( &mut self, event: Event, at: Instant, ) -> TimedEventHandle

Send a custom event with custom origin and propagation information at a particular time instant.

fn cancel_scheduled(&mut self, handle: TimedEventHandle)

Cancel a scheduled event before it is sent.