Checkpoint

crates/gpui3/src/app.rs

@@ -1,10 +1,12 @@
+mod async_context;
 mod model_context;
 
+pub use async_context::*;
 pub use model_context::*;
 
 use crate::{
-    current_platform, AnyWindowHandle, Context, LayoutId, MainThreadOnly, Platform, RootView,
+    current_platform, Context, LayoutId, MainThreadOnly, Platform, RootView, TextSystem, Window,
-    TextSystem, Window, WindowContext, WindowHandle, WindowId,
+    WindowContext, WindowHandle, WindowId,
 };
 use anyhow::{anyhow, Result};
 use collections::{HashMap, VecDeque};
@@ -72,14 +74,13 @@ pub struct AppContext {
     this: Weak<Mutex<AppContext>>,
     platform: MainThreadOnly<dyn Platform>,
     text_system: Arc<TextSystem>,
+    pending_updates: usize,
     pub(crate) unit_entity: Handle<()>,
     pub(crate) entities: SlotMap<EntityId, Option<Box<dyn Any + Send>>>,
     pub(crate) windows: SlotMap<WindowId, Option<Window>>,
-    pending_updates: usize,
     pub(crate) pending_effects: VecDeque<Effect>,
     pub(crate) observers: HashMap<EntityId, Handlers>,
-    // We recycle this memory across layout requests.
+    pub(crate) layout_id_buffer: Vec<LayoutId>, // We recycle this memory across layout requests.
-    pub(crate) layout_id_buffer: Vec<LayoutId>,
 }
 
 impl AppContext {
@@ -230,54 +231,6 @@ impl Context for AppContext {
     }
 }
 
-#[derive(Clone)]
-pub struct AsyncContext(Weak<Mutex<AppContext>>);
-
-impl Context for AsyncContext {
-    type EntityContext<'a, 'b, T: Send + Sync + 'static> = ModelContext<'a, T>;
-    type Result<T> = Result<T>;
-
-    fn entity<T: Send + Sync + 'static>(
-        &mut self,
-        build_entity: impl FnOnce(&mut Self::EntityContext<'_, '_, T>) -> T,
-    ) -> Result<Handle<T>> {
-        let app = self
-            .0
-            .upgrade()
-            .ok_or_else(|| anyhow!("app was released"))?;
-        let mut lock = app.lock();
-        Ok(lock.entity(build_entity))
-    }
-
-    fn update_entity<T: Send + Sync + 'static, R>(
-        &mut self,
-        handle: &Handle<T>,
-        update: impl FnOnce(&mut T, &mut Self::EntityContext<'_, '_, T>) -> R,
-    ) -> Result<R> {
-        let app = self
-            .0
-            .upgrade()
-            .ok_or_else(|| anyhow!("app was released"))?;
-        let mut lock = app.lock();
-        Ok(lock.update_entity(handle, update))
-    }
-}
-
-impl AsyncContext {
-    pub fn update_window<T>(
-        &self,
-        handle: AnyWindowHandle,
-        update: impl FnOnce(&mut WindowContext) -> T + Send + Sync,
-    ) -> Result<T> {
-        let app = self
-            .0
-            .upgrade()
-            .ok_or_else(|| anyhow!("app was released"))?;
-        let mut app_context = app.lock();
-        app_context.update_window(handle.id, update)
-    }
-}
-
 slotmap::new_key_type! { pub struct EntityId; }
 
 pub struct Handle<T> {

crates/gpui3/src/app/async_context.rs

@@ -0,0 +1,52 @@
+use crate::{AnyWindowHandle, AppContext, Context, Handle, ModelContext, Result, WindowContext};
+use anyhow::anyhow;
+use parking_lot::Mutex;
+use std::sync::Weak;
+
+#[derive(Clone)]
+pub struct AsyncContext(pub(crate) Weak<Mutex<AppContext>>);
+
+impl Context for AsyncContext {
+    type EntityContext<'a, 'b, T: Send + Sync + 'static> = ModelContext<'a, T>;
+    type Result<T> = Result<T>;
+
+    fn entity<T: Send + Sync + 'static>(
+        &mut self,
+        build_entity: impl FnOnce(&mut Self::EntityContext<'_, '_, T>) -> T,
+    ) -> Result<Handle<T>> {
+        let app = self
+            .0
+            .upgrade()
+            .ok_or_else(|| anyhow!("app was released"))?;
+        let mut lock = app.lock();
+        Ok(lock.entity(build_entity))
+    }
+
+    fn update_entity<T: Send + Sync + 'static, R>(
+        &mut self,
+        handle: &Handle<T>,
+        update: impl FnOnce(&mut T, &mut Self::EntityContext<'_, '_, T>) -> R,
+    ) -> Result<R> {
+        let app = self
+            .0
+            .upgrade()
+            .ok_or_else(|| anyhow!("app was released"))?;
+        let mut lock = app.lock();
+        Ok(lock.update_entity(handle, update))
+    }
+}
+
+impl AsyncContext {
+    pub fn update_window<T>(
+        &self,
+        handle: AnyWindowHandle,
+        update: impl FnOnce(&mut WindowContext) -> T + Send + Sync,
+    ) -> Result<T> {
+        let app = self
+            .0
+            .upgrade()
+            .ok_or_else(|| anyhow!("app was released"))?;
+        let mut app_context = app.lock();
+        app_context.update_window(handle.id, update)
+    }
+}