Merge pull request #657 from zed-industries/global-observations

Add global change observations

crates/gpui/src/app.rs

@@ -763,6 +763,7 @@ type GlobalActionCallback = dyn FnMut(&dyn AnyAction, &mut MutableAppContext);
 type SubscriptionCallback = Box<dyn FnMut(&dyn Any, &mut MutableAppContext) -> bool>;
 type GlobalSubscriptionCallback = Box<dyn FnMut(&dyn Any, &mut MutableAppContext)>;
 type ObservationCallback = Box<dyn FnMut(&mut MutableAppContext) -> bool>;
+type GlobalObservationCallback = Box<dyn FnMut(&mut MutableAppContext)>;
 type ReleaseObservationCallback = Box<dyn FnMut(&dyn Any, &mut MutableAppContext)>;
 
 pub struct MutableAppContext {
@@ -782,12 +783,15 @@ pub struct MutableAppContext {
     global_subscriptions:
         Arc<Mutex<HashMap<TypeId, BTreeMap<usize, Option<GlobalSubscriptionCallback>>>>>,
     observations: Arc<Mutex<HashMap<usize, BTreeMap<usize, Option<ObservationCallback>>>>>,
+    global_observations:
+        Arc<Mutex<HashMap<TypeId, BTreeMap<usize, Option<GlobalObservationCallback>>>>>,
     release_observations: Arc<Mutex<HashMap<usize, BTreeMap<usize, ReleaseObservationCallback>>>>,
     presenters_and_platform_windows:
         HashMap<usize, (Rc<RefCell<Presenter>>, Box<dyn platform::Window>)>,
     foreground: Rc<executor::Foreground>,
     pending_effects: VecDeque<Effect>,
     pending_notifications: HashSet<usize>,
+    pending_global_notifications: HashSet<TypeId>,
     pending_flushes: usize,
     flushing_effects: bool,
     next_cursor_style_handle_id: Arc<AtomicUsize>,
@@ -831,10 +835,12 @@ impl MutableAppContext {
             global_subscriptions: Default::default(),
             observations: Default::default(),
             release_observations: Default::default(),
+            global_observations: Default::default(),
             presenters_and_platform_windows: HashMap::new(),
             foreground,
             pending_effects: VecDeque::new(),
             pending_notifications: HashSet::new(),
+            pending_global_notifications: HashSet::new(),
             pending_flushes: 0,
             flushing_effects: false,
             next_cursor_style_handle_id: Default::default(),
@@ -1197,6 +1203,27 @@ impl MutableAppContext {
         }
     }
 
+    pub fn observe_global<G, F>(&mut self, observe: F) -> Subscription
+    where
+        G: Any,
+        F: 'static + FnMut(&mut MutableAppContext),
+    {
+        let type_id = TypeId::of::<G>();
+        let id = post_inc(&mut self.next_subscription_id);
+
+        self.global_observations
+            .lock()
+            .entry(type_id)
+            .or_default()
+            .insert(id, Some(Box::new(observe)));
+
+        Subscription::GlobalObservation {
+            id,
+            type_id,
+            observations: Some(Arc::downgrade(&self.global_observations)),
+        }
+    }
+
     pub fn observe_release<E, H, F>(&mut self, handle: &H, mut callback: F) -> Subscription
     where
         E: Entity,
@@ -1251,6 +1278,13 @@ impl MutableAppContext {
         }
     }
 
+    pub(crate) fn notify_global(&mut self, type_id: TypeId) {
+        if self.pending_global_notifications.insert(type_id) {
+            self.pending_effects
+                .push_back(Effect::GlobalNotification { type_id });
+        }
+    }
+
     pub fn dispatch_action<A: Action>(
         &mut self,
         window_id: usize,
@@ -1380,16 +1414,26 @@ impl MutableAppContext {
     }
 
     pub fn default_global<T: 'static + Default>(&mut self) -> &T {
-        self.cx
-            .globals
-            .entry(TypeId::of::<T>())
-            .or_insert_with(|| Box::new(T::default()))
-            .downcast_ref()
-            .unwrap()
+        let type_id = TypeId::of::<T>();
+        self.update(|this| {
+            if !this.globals.contains_key(&type_id) {
+                this.notify_global(type_id);
+            }
+
+            this.cx
+                .globals
+                .entry(type_id)
+                .or_insert_with(|| Box::new(T::default()));
+        });
+        self.globals.get(&type_id).unwrap().downcast_ref().unwrap()
     }
 
     pub fn set_global<T: 'static>(&mut self, state: T) {
-        self.cx.globals.insert(TypeId::of::<T>(), Box::new(state));
+        self.update(|this| {
+            let type_id = TypeId::of::<T>();
+            this.cx.globals.insert(type_id, Box::new(state));
+            this.notify_global(type_id);
+        });
     }
 
     pub fn update_default_global<T, F, U>(&mut self, update: F) -> U
@@ -1397,15 +1441,18 @@ impl MutableAppContext {
         T: 'static + Default,
         F: FnOnce(&mut T, &mut MutableAppContext) -> U,
     {
-        let type_id = TypeId::of::<T>();
-        let mut state = self
-            .cx
-            .globals
-            .remove(&type_id)
-            .unwrap_or_else(|| Box::new(T::default()));
-        let result = update(state.downcast_mut().unwrap(), self);
-        self.cx.globals.insert(type_id, state);
-        result
+        self.update(|this| {
+            let type_id = TypeId::of::<T>();
+            let mut state = this
+                .cx
+                .globals
+                .remove(&type_id)
+                .unwrap_or_else(|| Box::new(T::default()));
+            let result = update(state.downcast_mut().unwrap(), this);
+            this.cx.globals.insert(type_id, state);
+            this.notify_global(type_id);
+            result
+        })
     }
 
     pub fn update_global<T, F, U>(&mut self, update: F) -> U
@@ -1413,15 +1460,18 @@ impl MutableAppContext {
         T: 'static,
         F: FnOnce(&mut T, &mut MutableAppContext) -> U,
     {
-        let type_id = TypeId::of::<T>();
-        let mut state = self
-            .cx
-            .globals
-            .remove(&type_id)
-            .expect("no global has been added for this type");
-        let result = update(state.downcast_mut().unwrap(), self);
-        self.cx.globals.insert(type_id, state);
-        result
+        self.update(|this| {
+            let type_id = TypeId::of::<T>();
+            let mut state = this
+                .cx
+                .globals
+                .remove(&type_id)
+                .expect("no global has been added for this type");
+            let result = update(state.downcast_mut().unwrap(), this);
+            this.cx.globals.insert(type_id, state);
+            this.notify_global(type_id);
+            result
+        })
     }
 
     pub fn add_model<T, F>(&mut self, build_model: F) -> ModelHandle<T>
@@ -1686,6 +1736,9 @@ impl MutableAppContext {
                         Effect::ViewNotification { window_id, view_id } => {
                             self.notify_view_observers(window_id, view_id)
                         }
+                        Effect::GlobalNotification { type_id } => {
+                            self.notify_global_observers(type_id)
+                        }
                         Effect::Deferred {
                             callback,
                             after_window_update,
@@ -1734,6 +1787,7 @@ impl MutableAppContext {
                         if self.pending_effects.is_empty() {
                             self.flushing_effects = false;
                             self.pending_notifications.clear();
+                            self.pending_global_notifications.clear();
                             break;
                         }
                     }
@@ -2004,6 +2058,33 @@ impl MutableAppContext {
         }
     }
 
+    fn notify_global_observers(&mut self, observed_type_id: TypeId) {
+        let callbacks = self.global_observations.lock().remove(&observed_type_id);
+        if let Some(callbacks) = callbacks {
+            if self.cx.globals.contains_key(&observed_type_id) {
+                for (id, callback) in callbacks {
+                    if let Some(mut callback) = callback {
+                        callback(self);
+                        match self
+                            .global_observations
+                            .lock()
+                            .entry(observed_type_id)
+                            .or_default()
+                            .entry(id)
+                        {
+                            collections::btree_map::Entry::Vacant(entry) => {
+                                entry.insert(Some(callback));
+                            }
+                            collections::btree_map::Entry::Occupied(entry) => {
+                                entry.remove();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     fn notify_release_observers(&mut self, entity_id: usize, entity: &dyn Any) {
         let callbacks = self.release_observations.lock().remove(&entity_id);
         if let Some(callbacks) = callbacks {
@@ -2377,6 +2458,9 @@ pub enum Effect {
         callback: Box<dyn FnOnce(&mut MutableAppContext)>,
         after_window_update: bool,
     },
+    GlobalNotification {
+        type_id: TypeId,
+    },
     ModelRelease {
         model_id: usize,
         model: Box<dyn AnyModel>,
@@ -2442,6 +2526,10 @@ impl Debug for Effect {
                 .field("window_id", window_id)
                 .field("view_id", view_id)
                 .finish(),
+            Effect::GlobalNotification { type_id } => f
+                .debug_struct("Effect::GlobalNotification")
+                .field("type_id", type_id)
+                .finish(),
             Effect::Deferred { .. } => f.debug_struct("Effect::Deferred").finish(),
             Effect::ModelRelease { model_id, .. } => f
                 .debug_struct("Effect::ModelRelease")
@@ -2621,6 +2709,15 @@ impl<'a, T: Entity> ModelContext<'a, T> {
         self.app.add_model(build_model)
     }
 
+    pub fn defer(&mut self, callback: impl 'static + FnOnce(&mut T, &mut ModelContext<T>)) {
+        let handle = self.handle();
+        self.app.defer(Box::new(move |cx| {
+            handle.update(cx, |model, cx| {
+                callback(model, cx);
+            })
+        }))
+    }
+
     pub fn emit(&mut self, payload: T::Event) {
         self.app.pending_effects.push_back(Effect::Event {
             entity_id: self.model_id,
@@ -4178,6 +4275,13 @@ pub enum Subscription {
         observations:
             Option<Weak<Mutex<HashMap<usize, BTreeMap<usize, Option<ObservationCallback>>>>>>,
     },
+    GlobalObservation {
+        id: usize,
+        type_id: TypeId,
+        observations: Option<
+            Weak<Mutex<HashMap<TypeId, BTreeMap<usize, Option<GlobalObservationCallback>>>>>,
+        >,
+    },
     ReleaseObservation {
         id: usize,
         entity_id: usize,
@@ -4198,6 +4302,9 @@ impl Subscription {
             Subscription::Observation { observations, .. } => {
                 observations.take();
             }
+            Subscription::GlobalObservation { observations, .. } => {
+                observations.take();
+            }
             Subscription::ReleaseObservation { observations, .. } => {
                 observations.take();
             }
@@ -4266,6 +4373,22 @@ impl Drop for Subscription {
                     }
                 }
             }
+            Subscription::GlobalObservation {
+                id,
+                type_id,
+                observations,
+            } => {
+                if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
+                    match observations.lock().entry(*type_id).or_default().entry(*id) {
+                        collections::btree_map::Entry::Vacant(entry) => {
+                            entry.insert(None);
+                        }
+                        collections::btree_map::Entry::Occupied(entry) => {
+                            entry.remove();
+                        }
+                    }
+                }
+            }
             Subscription::ReleaseObservation {
                 id,
                 entity_id,
@@ -5088,6 +5211,61 @@ mod tests {
         );
     }
 
+    #[crate::test(self)]
+    fn test_global(cx: &mut MutableAppContext) {
+        type Global = usize;
+
+        let observation_count = Rc::new(RefCell::new(0));
+        let subscription = cx.observe_global::<Global, _>({
+            let observation_count = observation_count.clone();
+            move |_| {
+                *observation_count.borrow_mut() += 1;
+            }
+        });
+
+        assert!(!cx.has_global::<Global>());
+        assert_eq!(cx.default_global::<Global>(), &0);
+        assert_eq!(*observation_count.borrow(), 1);
+        assert!(cx.has_global::<Global>());
+        assert_eq!(
+            cx.update_global::<Global, _, _>(|global, _| {
+                *global = 1;
+                "Update Result"
+            }),
+            "Update Result"
+        );
+        assert_eq!(*observation_count.borrow(), 2);
+        assert_eq!(cx.global::<Global>(), &1);
+
+        drop(subscription);
+        cx.update_global::<Global, _, _>(|global, _| {
+            *global = 2;
+        });
+        assert_eq!(*observation_count.borrow(), 2);
+
+        type OtherGlobal = f32;
+
+        let observation_count = Rc::new(RefCell::new(0));
+        cx.observe_global::<OtherGlobal, _>({
+            let observation_count = observation_count.clone();
+            move |_| {
+                *observation_count.borrow_mut() += 1;
+            }
+        })
+        .detach();
+
+        assert_eq!(
+            cx.update_default_global::<OtherGlobal, _, _>(|global, _| {
+                assert_eq!(global, &0.0);
+                *global = 2.0;
+                "Default update result"
+            }),
+            "Default update result"
+        );
+        assert_eq!(cx.global::<OtherGlobal>(), &2.0);
+        assert_eq!(*observation_count.borrow(), 1);
+    }
+
     #[crate::test(self)]
     fn test_dropping_subscribers(cx: &mut MutableAppContext) {
         struct View;
@@ -5437,6 +5615,22 @@ mod tests {
         });
 
         assert_eq!(*observation_count.borrow(), 1);
+
+        // Global Observation
+        let observation_count = Rc::new(RefCell::new(0));
+        let subscription = Rc::new(RefCell::new(None));
+        *subscription.borrow_mut() = Some(cx.observe_global::<(), _>({
+            let observation_count = observation_count.clone();
+            let subscription = subscription.clone();
+            move |_| {
+                subscription.borrow_mut().take();
+                *observation_count.borrow_mut() += 1;
+            }
+        }));
+
+        cx.default_global::<()>();
+        cx.set_global(());
+        assert_eq!(*observation_count.borrow(), 1);
     }
 
     #[crate::test(self)]