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)

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 AsyncWindowContext

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

where T: 'static,

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, _: &Entity<T>) -> 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, ) -> 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 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 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

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

The result type for window operations.

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

where V: Focusable,

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