Struct AsyncApp 

pub struct AsyncApp { /* private fields */ }

An async-friendly version of App with a static lifetime so it can be held across await points in async code. You’re provided with an instance when calling App::spawn, and you can also create one with App::to_async.

Internally, this holds a weak reference to an App. Methods will panic if the app has been dropped, but this should not happen in practice when using foreground tasks spawned via cx.spawn(), as the executor checks if the app is alive before running each task.

Implementations

impl AsyncApp

pub fn refresh(&self)

Schedules all windows in the application to be redrawn.

pub fn background_executor(&self) -> &BackgroundExecutor

Get an executor which can be used to spawn futures in the background.

pub fn foreground_executor(&self) -> &ForegroundExecutor

Get an executor which can be used to spawn futures in the foreground.

pub fn update<R>(&self, f: impl FnOnce(&mut App) -> R) -> R

Invoke the given function in the context of the app, then flush any effects produced during its invocation.

pub fn subscribe<T, Event>( &mut self, entity: &Entity<T>, on_event: impl FnMut(Entity<T>, &Event, &mut App) + 'static, ) -> Subscription

where T: 'static + EventEmitter<Event>, Event: 'static,

Arrange for the given callback to be invoked whenever the given entity emits an event of a given type. The callback is provided a handle to the emitting entity and a reference to the emitted event.

pub fn open_window<V>( &self, options: WindowOptions, build_root_view: impl FnOnce(&mut Window, &mut App) -> Entity<V>, ) -> Result<WindowHandle<V>>

where V: 'static + Render,

Open a window with the given options based on the root view returned by the given function.

pub fn spawn<AsyncFn, R>(&self, f: AsyncFn) -> Task<R>

where AsyncFn: AsyncFnOnce(&mut AsyncApp) -> R + 'static, R: 'static,

Schedule a future to be polled in the foreground.

pub fn has_global<G: Global>(&self) -> bool

Determine whether global state of the specified type has been assigned.

pub fn read_global<G: Global, R>(&self, read: impl FnOnce(&G, &App) -> R) -> R

Reads the global state of the specified type, passing it to the given callback.

Panics if no global state of the specified type has been assigned.

pub fn try_read_global<G: Global, R>( &self, read: impl FnOnce(&G, &App) -> R, ) -> Option<R>

Reads the global state of the specified type, passing it to the given callback.

Similar to AsyncApp::read_global, but returns an error instead of panicking

pub fn read_default_global<G: Global + Default, R>( &self, read: impl FnOnce(&G, &App) -> R, ) -> R

Reads the global state of the specified type, passing it to the given callback. A default value is assigned if a global of this type has not yet been assigned.

pub fn update_global<G: Global, R>( &self, update: impl FnOnce(&mut G, &mut App) -> R, ) -> R

A convenience method for App::update_global for updating the global state of the specified type.

pub fn on_drop<T: 'static, Callback: FnOnce(&mut T, &mut Context<'_, T>) + 'static>( &self, entity: &WeakEntity<T>, f: Callback, ) -> Deferred<impl FnOnce() + use<T, Callback>>

Run something using this entity and cx, when the returned struct is dropped

Trait Implementations

impl AppContext for AsyncApp

fn new<T: 'static>( &mut self, build_entity: impl FnOnce(&mut Context<'_, T>) -> T, ) -> Entity<T>

Create a new entity in the app context.

fn reserve_entity<T: 'static>(&mut self) -> Reservation<T>

Reserve a slot for a entity to be inserted later. The returned Reservation allows you to obtain the EntityId for the future entity.

fn insert_entity<T: 'static>( &mut self, reservation: Reservation<T>, build_entity: impl FnOnce(&mut Context<'_, T>) -> T, ) -> Entity<T>

Insert a new entity in the app context based on a Reservation previously obtained from reserve_entity.

fn update_entity<T: 'static, R>( &mut self, handle: &Entity<T>, update: impl FnOnce(&mut T, &mut Context<'_, T>) -> R, ) -> R

Update a entity in the app context.

fn as_mut<'a, T>(&'a mut self, _handle: &Entity<T>) -> GpuiBorrow<'a, T>

where T: 'static,

Update a entity in the app context.

fn read_entity<T, R>( &self, handle: &Entity<T>, callback: impl FnOnce(&T, &App) -> R, ) -> R

where T: 'static,

Read a entity from the app context.

fn update_window<T, F>(&mut self, window: AnyWindowHandle, f: F) -> Result<T>

where F: FnOnce(AnyView, &mut Window, &mut App) -> T,

Update a window for the given handle.

fn with_window<R>( &mut self, entity_id: EntityId, f: impl FnOnce(&mut Window, &mut App) -> R, ) -> Option<R>

Run f against the entity’s current window — the most recently rendered window that referenced the entity. Returns None if the entity has no current window or that window is unavailable. See App::with_window for the underlying lookup.

fn read_window<T, R>( &self, window: &WindowHandle<T>, read: impl FnOnce(Entity<T>, &App) -> R, ) -> Result<R>

where T: 'static,

Read a window off of the application context.

fn background_spawn<R>( &self, future: impl Future<Output = R> + Send + 'static, ) -> Task<R>

where R: Send + 'static,

Spawn a future on a background thread

fn read_global<G, R>(&self, callback: impl FnOnce(&G, &App) -> R) -> R

where G: Global,

Read a global from this app context

impl Clone for AsyncApp

fn clone(&self) -> AsyncApp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.