Add ViewContext::observe_window_activation

crates/gpui/src/app.rs

@@ -783,6 +783,7 @@ type FocusObservationCallback = Box<dyn FnMut(&mut MutableAppContext) -> bool>;
 type GlobalObservationCallback = Box<dyn FnMut(&mut MutableAppContext)>;
 type ReleaseObservationCallback = Box<dyn FnOnce(&dyn Any, &mut MutableAppContext)>;
 type ActionObservationCallback = Box<dyn FnMut(TypeId, &mut MutableAppContext)>;
+type WindowActivationCallback = Box<dyn FnMut(bool, &mut MutableAppContext) -> bool>;
 type DeserializeActionCallback = fn(json: &str) -> anyhow::Result<Box<dyn Action>>;
 type WindowShouldCloseSubscriptionCallback = Box<dyn FnMut(&mut MutableAppContext) -> bool>;
 
@@ -809,6 +810,8 @@ pub struct MutableAppContext {
     global_observations:
         Arc<Mutex<HashMap<TypeId, BTreeMap<usize, Option<GlobalObservationCallback>>>>>,
     release_observations: Arc<Mutex<HashMap<usize, BTreeMap<usize, ReleaseObservationCallback>>>>,
+    window_activation_observations:
+        Arc<Mutex<HashMap<usize, BTreeMap<usize, Option<WindowActivationCallback>>>>>,
     action_dispatch_observations: Arc<Mutex<BTreeMap<usize, ActionObservationCallback>>>,
     presenters_and_platform_windows:
         HashMap<usize, (Rc<RefCell<Presenter>>, Box<dyn platform::Window>)>,
@@ -862,6 +865,7 @@ impl MutableAppContext {
             focus_observations: Default::default(),
             release_observations: Default::default(),
             global_observations: Default::default(),
+            window_activation_observations: Default::default(),
             action_dispatch_observations: Default::default(),
             presenters_and_platform_windows: HashMap::new(),
             foreground,
@@ -1358,6 +1362,24 @@ impl MutableAppContext {
         }
     }
 
+    fn observe_window_activation<F>(&mut self, window_id: usize, callback: F) -> Subscription
+    where
+        F: 'static + FnMut(bool, &mut MutableAppContext) -> bool,
+    {
+        let subscription_id = post_inc(&mut self.next_subscription_id);
+        self.pending_effects
+            .push_back(Effect::WindowActivationObservation {
+                window_id,
+                subscription_id,
+                callback: Box::new(callback),
+            });
+        Subscription::WindowActivationObservation {
+            id: subscription_id,
+            window_id,
+            observations: Some(Arc::downgrade(&self.window_activation_observations)),
+        }
+    }
+
     pub fn defer(&mut self, callback: impl 'static + FnOnce(&mut MutableAppContext)) {
         self.pending_effects.push_back(Effect::Deferred {
             callback: Box::new(callback),
@@ -1715,19 +1737,16 @@ impl MutableAppContext {
         self.update(|this| {
             let window_id = post_inc(&mut this.next_window_id);
             let root_view = this.add_view(window_id, build_root_view);
-
             this.cx.windows.insert(
                 window_id,
                 Window {
                     root_view: root_view.clone().into(),
                     focused_view_id: Some(root_view.id()),
-                    is_active: true,
+                    is_active: false,
                     invalidation: None,
                 },
             );
-            root_view.update(this, |view, cx| {
+            root_view.update(this, |view, cx| view.on_focus(cx));
-                view.on_focus(cx);
-            });
             this.open_platform_window(window_id, window_options);
 
             (window_id, root_view)
@@ -1995,10 +2014,19 @@ impl MutableAppContext {
                                     .get_or_insert(WindowInvalidation::default());
                             }
                         }
+                        Effect::WindowActivationObservation {
+                            window_id,
+                            subscription_id,
+                            callback,
+                        } => self.handle_window_activation_observation_effect(
+                            window_id,
+                            subscription_id,
+                            callback,
+                        ),
                         Effect::ActivateWindow {
                             window_id,
                             is_active,
-                        } => self.handle_activation_effect(window_id, is_active),
+                        } => self.handle_window_activation_effect(window_id, is_active),
                         Effect::RefreshWindows => {
                             refreshing = true;
                         }
@@ -2361,7 +2389,31 @@ impl MutableAppContext {
         }
     }
 
-    fn handle_activation_effect(&mut self, window_id: usize, active: bool) {
+    fn handle_window_activation_observation_effect(
+        &mut self,
+        window_id: usize,
+        subscription_id: usize,
+        callback: WindowActivationCallback,
+    ) {
+        match self
+            .window_activation_observations
+            .lock()
+            .entry(window_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_window_activation_effect(&mut self, window_id: usize, active: bool) {
         if self
             .cx
             .windows
@@ -2385,6 +2437,34 @@ impl MutableAppContext {
                 this.cx.views.insert((window_id, view_id), view);
             }
 
+            let callbacks = this
+                .window_activation_observations
+                .lock()
+                .remove(&window_id);
+            if let Some(callbacks) = callbacks {
+                for (id, callback) in callbacks {
+                    if let Some(mut callback) = callback {
+                        let alive = callback(active, this);
+                        if alive {
+                            match this
+                                .window_activation_observations
+                                .lock()
+                                .entry(window_id)
+                                .or_default()
+                                .entry(id)
+                            {
+                                btree_map::Entry::Vacant(entry) => {
+                                    entry.insert(Some(callback));
+                                }
+                                btree_map::Entry::Occupied(entry) => {
+                                    entry.remove();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
             Some(())
         });
     }
@@ -2842,6 +2922,11 @@ pub enum Effect {
         window_id: usize,
         is_active: bool,
     },
+    WindowActivationObservation {
+        window_id: usize,
+        subscription_id: usize,
+        callback: WindowActivationCallback,
+    },
     RefreshWindows,
     ActionDispatchNotification {
         action_id: TypeId,
@@ -2934,6 +3019,15 @@ impl Debug for Effect {
                 .debug_struct("Effect::RefreshWindow")
                 .field("window_id", window_id)
                 .finish(),
+            Effect::WindowActivationObservation {
+                window_id,
+                subscription_id,
+                ..
+            } => f
+                .debug_struct("Effect::WindowActivationObservation")
+                .field("window_id", window_id)
+                .field("subscription_id", subscription_id)
+                .finish(),
             Effect::ActivateWindow {
                 window_id,
                 is_active,
@@ -3518,6 +3612,24 @@ impl<'a, T: View> ViewContext<'a, T> {
         })
     }
 
+    pub fn observe_window_activation<F>(&mut self, mut callback: F) -> Subscription
+    where
+        F: 'static + FnMut(&mut T, bool, &mut ViewContext<T>),
+    {
+        let observer = self.weak_handle();
+        self.app
+            .observe_window_activation(self.window_id(), move |active, cx| {
+                if let Some(observer) = observer.upgrade(cx) {
+                    observer.update(cx, |observer, cx| {
+                        callback(observer, active, cx);
+                    });
+                    true
+                } else {
+                    false
+                }
+            })
+    }
+
     pub fn emit(&mut self, payload: T::Event) {
         self.app.pending_effects.push_back(Effect::Event {
             entity_id: self.view_id,
@@ -4833,6 +4945,12 @@ pub enum Subscription {
         id: usize,
         observations: Option<Weak<Mutex<BTreeMap<usize, ActionObservationCallback>>>>,
     },
+    WindowActivationObservation {
+        id: usize,
+        window_id: usize,
+        observations:
+            Option<Weak<Mutex<HashMap<usize, BTreeMap<usize, Option<WindowActivationCallback>>>>>>,
+    },
 }
 
 impl Subscription {
@@ -4859,6 +4977,9 @@ impl Subscription {
             Subscription::ActionObservation { observations, .. } => {
                 observations.take();
             }
+            Subscription::WindowActivationObservation { observations, .. } => {
+                observations.take();
+            }
         }
     }
 }
@@ -4972,6 +5093,27 @@ impl Drop for Subscription {
                     observations.lock().remove(&id);
                 }
             }
+            Subscription::WindowActivationObservation {
+                id,
+                window_id,
+                observations,
+            } => {
+                if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
+                    match observations
+                        .lock()
+                        .entry(*window_id)
+                        .or_default()
+                        .entry(*id)
+                    {
+                        btree_map::Entry::Vacant(entry) => {
+                            entry.insert(None);
+                        }
+                        btree_map::Entry::Occupied(entry) => {
+                            entry.remove();
+                        }
+                    }
+                }
+            }
         }
     }
 }