Struct AsyncWindowContext 

pub struct AsyncWindowContext { /* private fields */ }

A cloneable, owned handle to the application context, composed with the window associated with the current task.

Implementations

impl AsyncWindowContext

pub fn window_handle(&self) -> AnyWindowHandle

Get the handle of the window this context is associated with.

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

A convenience method for App::update_window.

pub fn update_root<R>( &mut self, update: impl FnOnce(AnyView, &mut Window, &mut App) -> R, ) -> Result<R>

A convenience method for App::update_window.

pub fn on_next_frame(&mut self, f: impl FnOnce(&mut Window, &mut App) + 'static)

A convenience method for Window::on_next_frame.

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

A convenience method for App::global.

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

where G: Global,

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

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

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

Schedule a future to be executed on the main thread. This is used for collecting the results of background tasks and updating the UI.

pub fn prompt<T>( &mut self, level: PromptLevel, message: &str, detail: Option<&str>, answers: &[T], ) -> Receiver<usize>

where T: Clone + Into<PromptButton>,

Present a platform dialog. The provided message will be presented, along with buttons for each answer. When a button is clicked, the returned Receiver will receive the index of the clicked button.

Methods from Deref<Target = 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 AsyncWindowContext

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>( &mut self, build_entity: impl FnOnce(&mut Context<'_, T>) -> T, ) -> Result<Entity<T>>

where T: 'static,

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, ) -> Self::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, ) -> Result<R>

Update a entity in the app context.

fn as_mut<'a, T>(&'a mut self, _: &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>, read: 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, update: 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) -> Result<R>

where G: Global,

Read a global from this app context

impl Clone for AsyncWindowContext

fn clone(&self) -> AsyncWindowContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Deref for AsyncWindowContext

type Target = AsyncApp

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for AsyncWindowContext

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl VisualContext for AsyncWindowContext

fn window_handle(&self) -> AnyWindowHandle

Returns the handle of the window associated with this context.

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

Create a new entity, with access to Window.

fn update_window_entity<T: 'static, R>( &mut self, view: &Entity<T>, update: impl FnOnce(&mut T, &mut Window, &mut Context<'_, T>) -> R, ) -> Self::Result<R>

Update a view with the given callback

fn replace_root_view<V>( &mut self, build_view: impl FnOnce(&mut Window, &mut Context<'_, V>) -> V, ) -> Self::Result<Entity<V>>

where V: 'static + Render,

Replace the root view of a window with a new view.

fn focus<V>(&mut self, view: &Entity<V>) -> Self::Result<()>

where V: Focusable,

Focus a entity in the window, if it implements the Focusable trait.