Introduce ViewContext::observe_focus

crates/gpui/src/app.rs

@@ -716,6 +716,7 @@ type GlobalActionCallback = dyn FnMut(&dyn Action, &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 FocusObservationCallback = Box<dyn FnMut(&mut MutableAppContext) -> bool>;
 type GlobalObservationCallback = Box<dyn FnMut(&dyn Any, &mut MutableAppContext)>;
 type ReleaseObservationCallback = Box<dyn FnMut(&dyn Any, &mut MutableAppContext)>;
 type DeserializeActionCallback = fn(json: &str) -> anyhow::Result<Box<dyn Action>>;
@@ -738,6 +739,8 @@ pub struct MutableAppContext {
     global_subscriptions:
         Arc<Mutex<HashMap<TypeId, BTreeMap<usize, Option<GlobalSubscriptionCallback>>>>>,
     observations: Arc<Mutex<HashMap<usize, BTreeMap<usize, Option<ObservationCallback>>>>>,
+    focus_observations:
+        Arc<Mutex<HashMap<usize, BTreeMap<usize, Option<FocusObservationCallback>>>>>,
     global_observations:
         Arc<Mutex<HashMap<TypeId, BTreeMap<usize, Option<GlobalObservationCallback>>>>>,
     release_observations: Arc<Mutex<HashMap<usize, BTreeMap<usize, ReleaseObservationCallback>>>>,
@@ -791,6 +794,7 @@ impl MutableAppContext {
             subscriptions: Default::default(),
             global_subscriptions: Default::default(),
             observations: Default::default(),
+            focus_observations: Default::default(),
             release_observations: Default::default(),
             global_observations: Default::default(),
             presenters_and_platform_windows: HashMap::new(),
@@ -1185,6 +1189,32 @@ impl MutableAppContext {
         }
     }
 
+    fn observe_focus<F, V>(&mut self, handle: &ViewHandle<V>, mut callback: F) -> Subscription
+    where
+        F: 'static + FnMut(ViewHandle<V>, &mut MutableAppContext) -> bool,
+        V: View,
+    {
+        let subscription_id = post_inc(&mut self.next_subscription_id);
+        let observed = handle.downgrade();
+        let view_id = handle.id();
+        self.pending_effects.push_back(Effect::FocusObservation {
+            view_id,
+            subscription_id,
+            callback: Box::new(move |cx| {
+                if let Some(observed) = observed.upgrade(cx) {
+                    callback(observed, cx)
+                } else {
+                    false
+                }
+            }),
+        });
+        Subscription::FocusObservation {
+            id: subscription_id,
+            view_id,
+            observations: Some(Arc::downgrade(&self.focus_observations)),
+        }
+    }
+
     pub fn observe_global<G, F>(&mut self, mut observe: F) -> Subscription
     where
         G: Any,
@@ -1748,6 +1778,13 @@ impl MutableAppContext {
                         Effect::Focus { window_id, view_id } => {
                             self.handle_focus_effect(window_id, view_id);
                         }
+                        Effect::FocusObservation {
+                            view_id,
+                            subscription_id,
+                            callback,
+                        } => {
+                            self.handle_focus_observation_effect(view_id, subscription_id, callback)
+                        }
                         Effect::ResizeWindow { window_id } => {
                             if let Some(window) = self.cx.windows.get_mut(&window_id) {
                                 window
@@ -1978,6 +2015,30 @@ impl MutableAppContext {
         }
     }
 
+    fn handle_focus_observation_effect(
+        &mut self,
+        view_id: usize,
+        subscription_id: usize,
+        callback: FocusObservationCallback,
+    ) {
+        match self
+            .focus_observations
+            .lock()
+            .entry(view_id)
+            .or_default()
+            .entry(subscription_id)
+        {
+            btree_map::Entry::Vacant(entry) => {
+                entry.insert(Some(callback));
+            }
+            // Observation was dropped before effect was processed
+            btree_map::Entry::Occupied(entry) => {
+                debug_assert!(entry.get().is_none());
+                entry.remove();
+            }
+        }
+    }
+
     fn handle_model_notification_effect(&mut self, observed_id: usize) {
         let callbacks = self.observations.lock().remove(&observed_id);
         if let Some(callbacks) = callbacks {
@@ -2102,8 +2163,6 @@ impl MutableAppContext {
             return;
         }
 
-        log::info!("process focus effect {:?}", focused_id);
-
         self.update(|this| {
             let blurred_id = this.cx.windows.get_mut(&window_id).and_then(|window| {
                 let blurred_id = window.focused_view_id;
@@ -2122,6 +2181,31 @@ impl MutableAppContext {
                 if let Some(mut focused_view) = this.cx.views.remove(&(window_id, focused_id)) {
                     focused_view.on_focus(this, window_id, focused_id);
                     this.cx.views.insert((window_id, focused_id), focused_view);
+
+                    let callbacks = this.focus_observations.lock().remove(&focused_id);
+                    if let Some(callbacks) = callbacks {
+                        for (id, callback) in callbacks {
+                            if let Some(mut callback) = callback {
+                                let alive = callback(this);
+                                if alive {
+                                    match this
+                                        .focus_observations
+                                        .lock()
+                                        .entry(focused_id)
+                                        .or_default()
+                                        .entry(id)
+                                    {
+                                        btree_map::Entry::Vacant(entry) => {
+                                            entry.insert(Some(callback));
+                                        }
+                                        btree_map::Entry::Occupied(entry) => {
+                                            entry.remove();
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
         })
@@ -2487,6 +2571,11 @@ pub enum Effect {
         window_id: usize,
         view_id: Option<usize>,
     },
+    FocusObservation {
+        view_id: usize,
+        subscription_id: usize,
+        callback: FocusObservationCallback,
+    },
     ResizeWindow {
         window_id: usize,
     },
@@ -2558,6 +2647,15 @@ impl Debug for Effect {
                 .field("window_id", window_id)
                 .field("view_id", view_id)
                 .finish(),
+            Effect::FocusObservation {
+                view_id,
+                subscription_id,
+                ..
+            } => f
+                .debug_struct("Effect::FocusObservation")
+                .field("view_id", view_id)
+                .field("subscription_id", subscription_id)
+                .finish(),
             Effect::ResizeWindow { window_id } => f
                 .debug_struct("Effect::RefreshWindow")
                 .field("window_id", window_id)
@@ -3045,6 +3143,24 @@ impl<'a, T: View> ViewContext<'a, T> {
         })
     }
 
+    pub fn observe_focus<F, V>(&mut self, handle: &ViewHandle<V>, mut callback: F) -> Subscription
+    where
+        F: 'static + FnMut(&mut T, ViewHandle<V>, &mut ViewContext<T>),
+        V: View,
+    {
+        let observer = self.weak_handle();
+        self.app.observe_focus(handle, move |observed, cx| {
+            if let Some(observer) = observer.upgrade(cx) {
+                observer.update(cx, |observer, cx| {
+                    callback(observer, observed, cx);
+                });
+                true
+            } else {
+                false
+            }
+        })
+    }
+
     pub fn observe_release<E, F, H>(&mut self, handle: &H, mut callback: F) -> Subscription
     where
         E: Entity,
@@ -4309,6 +4425,12 @@ pub enum Subscription {
             Weak<Mutex<HashMap<TypeId, BTreeMap<usize, Option<GlobalObservationCallback>>>>>,
         >,
     },
+    FocusObservation {
+        id: usize,
+        view_id: usize,
+        observations:
+            Option<Weak<Mutex<HashMap<usize, BTreeMap<usize, Option<FocusObservationCallback>>>>>>,
+    },
     ReleaseObservation {
         id: usize,
         entity_id: usize,
@@ -4335,6 +4457,9 @@ impl Subscription {
             Subscription::ReleaseObservation { observations, .. } => {
                 observations.take();
             }
+            Subscription::FocusObservation { observations, .. } => {
+                observations.take();
+            }
         }
     }
 }
@@ -4427,6 +4552,22 @@ impl Drop for Subscription {
                     }
                 }
             }
+            Subscription::FocusObservation {
+                id,
+                view_id,
+                observations,
+            } => {
+                if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
+                    match observations.lock().entry(*view_id).or_default().entry(*id) {
+                        btree_map::Entry::Vacant(entry) => {
+                            entry.insert(None);
+                        }
+                        btree_map::Entry::Occupied(entry) => {
+                            entry.remove();
+                        }
+                    }
+                }
+            }
         }
     }
 }
@@ -5715,23 +5856,56 @@ mod tests {
             }
         }
 
-        let events: Arc<Mutex<Vec<String>>> = Default::default();
+        let view_events: Arc<Mutex<Vec<String>>> = Default::default();
         let (window_id, view_1) = cx.add_window(Default::default(), |_| View {
-            events: events.clone(),
+            events: view_events.clone(),
             name: "view 1".to_string(),
         });
         let view_2 = cx.add_view(window_id, |_| View {
-            events: events.clone(),
+            events: view_events.clone(),
             name: "view 2".to_string(),
         });
 
-        view_1.update(cx, |_, cx| cx.focus(&view_2));
+        let observed_events: Arc<Mutex<Vec<String>>> = Default::default();
+        view_1.update(cx, |_, cx| {
+            cx.observe_focus(&view_2, {
+                let observed_events = observed_events.clone();
+                move |this, view, cx| {
+                    observed_events.lock().push(format!(
+                        "{} observed {} focus",
+                        this.name,
+                        view.read(cx).name
+                    ))
+                }
+            })
+            .detach();
+        });
+        view_2.update(cx, |_, cx| {
+            cx.observe_focus(&view_1, {
+                let observed_events = observed_events.clone();
+                move |this, view, cx| {
+                    observed_events.lock().push(format!(
+                        "{} observed {}'s focus",
+                        this.name,
+                        view.read(cx).name
+                    ))
+                }
+            })
+            .detach();
+        });
+
+        view_1.update(cx, |_, cx| {
+            // Ensure only the latest focus is honored.
+            cx.focus(&view_2);
+            cx.focus(&view_1);
+            cx.focus(&view_2);
+        });
         view_1.update(cx, |_, cx| cx.focus(&view_1));
         view_1.update(cx, |_, cx| cx.focus(&view_2));
         view_1.update(cx, |_, _| drop(view_2));
 
         assert_eq!(
-            *events.lock(),
+            *view_events.lock(),
             [
                 "view 1 focused".to_string(),
                 "view 1 blurred".to_string(),
@@ -5743,6 +5917,14 @@ mod tests {
                 "view 1 focused".to_string(),
             ],
         );
+        assert_eq!(
+            *observed_events.lock(),
+            [
+                "view 1 observed view 2's focus".to_string(),
+                "view 2 observed view 1's focus".to_string(),
+                "view 1 observed view 2's focus".to_string(),
+            ]
+        );
     }
 
     #[crate::test(self)]