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, so its methods are fallible to protect against cases where the App is dropped.

Implementations

impl AsyncApp

pub fn refresh(&self) -> Result<()>

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) -> Result<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, ) -> Result<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) -> Result<bool>

Determine whether global state of the specified type has been assigned. Returns an error if the App has been dropped.

pub fn read_global<G: Global, R>( &self, read: impl FnOnce(&G, &App) -> R, ) -> Result<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. Returns an error if the App has been dropped.

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 if no state of the specified type has been assigned.

Returns an error if no state of the specified type has been assigned the App has been dropped.

pub fn try_read_default_global<G: Global + Default, R>( &self, read: impl FnOnce(&G, &App) -> R, ) -> Result<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.

Errors

If the app has ben dropped this returns an error.

pub fn update_global<G: Global, R>( &self, update: impl FnOnce(&mut G, &mut App) -> R, ) -> Result<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

type Result<T> = Result<T, Error>

The result type for this context, used for async contexts that can’t hold a direct reference to the application context.

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

Create a new entity in the app context.

fn reserve_entity<T: 'static>(&mut self) -> Result<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, ) -> Result<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, ) -> Self::Result<R>

Update a entity in the app context.

fn as_mut<'a, T>( &'a mut self, _handle: &Entity<T>, ) -> Self::Result<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, ) -> Self::Result<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 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, ) -> Self::Result<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.