@@ -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) -> bool>;
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) -> bool,
+ {
+ 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,22 @@ impl MutableAppContext {
}
pub fn default_global<T: 'static + Default>(&mut self) -> &T {
+ let type_id = TypeId::of::<T>();
+ if !self.cx.globals.contains_key(&type_id) {
+ self.notify_global(type_id);
+ }
self.cx
.globals
- .entry(TypeId::of::<T>())
+ .entry(type_id)
.or_insert_with(|| Box::new(T::default()))
.downcast_ref()
.unwrap()
}
pub fn set_global<T: 'static>(&mut self, state: T) {
- self.cx.globals.insert(TypeId::of::<T>(), Box::new(state));
+ let type_id = TypeId::of::<T>();
+ self.cx.globals.insert(type_id, Box::new(state));
+ self.notify_global(type_id);
}
pub fn update_default_global<T, F, U>(&mut self, update: F) -> U
@@ -1405,6 +1445,7 @@ impl MutableAppContext {
.unwrap_or_else(|| Box::new(T::default()));
let result = update(state.downcast_mut().unwrap(), self);
self.cx.globals.insert(type_id, state);
+ self.notify_global(type_id);
result
}
@@ -1421,6 +1462,7 @@ impl MutableAppContext {
.expect("no global has been added for this type");
let result = update(state.downcast_mut().unwrap(), self);
self.cx.globals.insert(type_id, state);
+ self.notify_global(type_id);
result
}
@@ -1686,6 +1728,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 +1779,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 +2050,35 @@ 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 {
+ let alive = callback(self);
+ if alive {
+ 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 +2452,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 +2520,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 +2703,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 +4269,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 +4296,9 @@ impl Subscription {
Subscription::Observation { observations, .. } => {
observations.take();
}
+ Subscription::GlobalObservation { observations, .. } => {
+ observations.take();
+ }
Subscription::ReleaseObservation { observations, .. } => {
observations.take();
}
@@ -4266,6 +4367,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,
@@ -5437,6 +5554,8 @@ mod tests {
});
assert_eq!(*observation_count.borrow(), 1);
+
+ // Global Observation
}
#[crate::test(self)]