1pub mod action;
2mod callback_collection;
3
4use crate::{
5 elements::ElementBox,
6 executor::{self, Task},
7 geometry::rect::RectF,
8 keymap::{self, Binding, Keystroke},
9 platform::{self, KeyDownEvent, Platform, PromptLevel, WindowOptions},
10 presenter::Presenter,
11 util::post_inc,
12 AssetCache, AssetSource, ClipboardItem, FontCache, InputHandler, MouseButton, MouseRegionId,
13 PathPromptOptions, TextLayoutCache,
14};
15pub use action::*;
16use anyhow::{anyhow, Context, Result};
17use callback_collection::CallbackCollection;
18use collections::{btree_map, hash_map::Entry, BTreeMap, HashMap, HashSet, VecDeque};
19use keymap::MatchResult;
20use lazy_static::lazy_static;
21use parking_lot::Mutex;
22use platform::Event;
23use postage::oneshot;
24use smallvec::SmallVec;
25use smol::prelude::*;
26use std::{
27 any::{type_name, Any, TypeId},
28 cell::RefCell,
29 fmt::{self, Debug},
30 hash::{Hash, Hasher},
31 marker::PhantomData,
32 mem,
33 ops::{Deref, DerefMut, Range},
34 path::{Path, PathBuf},
35 pin::Pin,
36 rc::{self, Rc},
37 sync::{Arc, Weak},
38 time::Duration,
39};
40
41use self::callback_collection::Mapping;
42
43pub trait Entity: 'static {
44 type Event;
45
46 fn release(&mut self, _: &mut MutableAppContext) {}
47 fn app_will_quit(
48 &mut self,
49 _: &mut MutableAppContext,
50 ) -> Option<Pin<Box<dyn 'static + Future<Output = ()>>>> {
51 None
52 }
53}
54
55pub trait View: Entity + Sized {
56 fn ui_name() -> &'static str;
57 fn render(&mut self, cx: &mut RenderContext<'_, Self>) -> ElementBox;
58 fn on_focus_in(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
59 fn on_focus_out(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
60 fn keymap_context(&self, _: &AppContext) -> keymap::Context {
61 Self::default_keymap_context()
62 }
63 fn default_keymap_context() -> keymap::Context {
64 let mut cx = keymap::Context::default();
65 cx.set.insert(Self::ui_name().into());
66 cx
67 }
68 fn debug_json(&self, _: &AppContext) -> serde_json::Value {
69 serde_json::Value::Null
70 }
71
72 fn text_for_range(&self, _: Range<usize>, _: &AppContext) -> Option<String> {
73 None
74 }
75 fn selected_text_range(&self, _: &AppContext) -> Option<Range<usize>> {
76 None
77 }
78 fn marked_text_range(&self, _: &AppContext) -> Option<Range<usize>> {
79 None
80 }
81 fn unmark_text(&mut self, _: &mut ViewContext<Self>) {}
82 fn replace_text_in_range(
83 &mut self,
84 _: Option<Range<usize>>,
85 _: &str,
86 _: &mut ViewContext<Self>,
87 ) {
88 }
89 fn replace_and_mark_text_in_range(
90 &mut self,
91 _: Option<Range<usize>>,
92 _: &str,
93 _: Option<Range<usize>>,
94 _: &mut ViewContext<Self>,
95 ) {
96 }
97}
98
99pub trait ReadModel {
100 fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T;
101}
102
103pub trait ReadModelWith {
104 fn read_model_with<E: Entity, T>(
105 &self,
106 handle: &ModelHandle<E>,
107 read: &mut dyn FnMut(&E, &AppContext) -> T,
108 ) -> T;
109}
110
111pub trait UpdateModel {
112 fn update_model<T: Entity, O>(
113 &mut self,
114 handle: &ModelHandle<T>,
115 update: &mut dyn FnMut(&mut T, &mut ModelContext<T>) -> O,
116 ) -> O;
117}
118
119pub trait UpgradeModelHandle {
120 fn upgrade_model_handle<T: Entity>(
121 &self,
122 handle: &WeakModelHandle<T>,
123 ) -> Option<ModelHandle<T>>;
124
125 fn model_handle_is_upgradable<T: Entity>(&self, handle: &WeakModelHandle<T>) -> bool;
126
127 fn upgrade_any_model_handle(&self, handle: &AnyWeakModelHandle) -> Option<AnyModelHandle>;
128}
129
130pub trait UpgradeViewHandle {
131 fn upgrade_view_handle<T: View>(&self, handle: &WeakViewHandle<T>) -> Option<ViewHandle<T>>;
132
133 fn upgrade_any_view_handle(&self, handle: &AnyWeakViewHandle) -> Option<AnyViewHandle>;
134}
135
136pub trait ReadView {
137 fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T;
138}
139
140pub trait ReadViewWith {
141 fn read_view_with<V, T>(
142 &self,
143 handle: &ViewHandle<V>,
144 read: &mut dyn FnMut(&V, &AppContext) -> T,
145 ) -> T
146 where
147 V: View;
148}
149
150pub trait UpdateView {
151 fn update_view<T, S>(
152 &mut self,
153 handle: &ViewHandle<T>,
154 update: &mut dyn FnMut(&mut T, &mut ViewContext<T>) -> S,
155 ) -> S
156 where
157 T: View;
158}
159
160pub struct Menu<'a> {
161 pub name: &'a str,
162 pub items: Vec<MenuItem<'a>>,
163}
164
165pub enum MenuItem<'a> {
166 Separator,
167 Submenu(Menu<'a>),
168 Action {
169 name: &'a str,
170 action: Box<dyn Action>,
171 },
172}
173
174#[derive(Clone)]
175pub struct App(Rc<RefCell<MutableAppContext>>);
176
177#[derive(Clone)]
178pub struct AsyncAppContext(Rc<RefCell<MutableAppContext>>);
179
180#[cfg(any(test, feature = "test-support"))]
181pub struct TestAppContext {
182 cx: Rc<RefCell<MutableAppContext>>,
183 foreground_platform: Rc<platform::test::ForegroundPlatform>,
184 condition_duration: Option<Duration>,
185}
186
187pub struct WindowInputHandler {
188 app: Rc<RefCell<MutableAppContext>>,
189 window_id: usize,
190}
191
192impl App {
193 pub fn new(asset_source: impl AssetSource) -> Result<Self> {
194 let platform = platform::current::platform();
195 let foreground_platform = platform::current::foreground_platform();
196 let foreground = Rc::new(executor::Foreground::platform(platform.dispatcher())?);
197 let app = Self(Rc::new(RefCell::new(MutableAppContext::new(
198 foreground,
199 Arc::new(executor::Background::new()),
200 platform.clone(),
201 foreground_platform.clone(),
202 Arc::new(FontCache::new(platform.fonts())),
203 Default::default(),
204 asset_source,
205 ))));
206
207 foreground_platform.on_quit(Box::new({
208 let cx = app.0.clone();
209 move || {
210 cx.borrow_mut().quit();
211 }
212 }));
213 foreground_platform.on_will_open_menu(Box::new({
214 let cx = app.0.clone();
215 move || {
216 let mut cx = cx.borrow_mut();
217 cx.keystroke_matcher.clear_pending();
218 }
219 }));
220 foreground_platform.on_validate_menu_command(Box::new({
221 let cx = app.0.clone();
222 move |action| {
223 let cx = cx.borrow_mut();
224 !cx.keystroke_matcher.has_pending_keystrokes() && cx.is_action_available(action)
225 }
226 }));
227 foreground_platform.on_menu_command(Box::new({
228 let cx = app.0.clone();
229 move |action| {
230 let mut cx = cx.borrow_mut();
231 if let Some(key_window_id) = cx.cx.platform.key_window_id() {
232 if let Some(view_id) = cx.focused_view_id(key_window_id) {
233 cx.handle_dispatch_action_from_effect(key_window_id, Some(view_id), action);
234 return;
235 }
236 }
237 cx.dispatch_global_action_any(action);
238 }
239 }));
240
241 app.0.borrow_mut().weak_self = Some(Rc::downgrade(&app.0));
242 Ok(app)
243 }
244
245 pub fn background(&self) -> Arc<executor::Background> {
246 self.0.borrow().background().clone()
247 }
248
249 pub fn on_become_active<F>(self, mut callback: F) -> Self
250 where
251 F: 'static + FnMut(&mut MutableAppContext),
252 {
253 let cx = self.0.clone();
254 self.0
255 .borrow_mut()
256 .foreground_platform
257 .on_become_active(Box::new(move || callback(&mut *cx.borrow_mut())));
258 self
259 }
260
261 pub fn on_resign_active<F>(self, mut callback: F) -> Self
262 where
263 F: 'static + FnMut(&mut MutableAppContext),
264 {
265 let cx = self.0.clone();
266 self.0
267 .borrow_mut()
268 .foreground_platform
269 .on_resign_active(Box::new(move || callback(&mut *cx.borrow_mut())));
270 self
271 }
272
273 pub fn on_quit<F>(&mut self, mut callback: F) -> &mut Self
274 where
275 F: 'static + FnMut(&mut MutableAppContext),
276 {
277 let cx = self.0.clone();
278 self.0
279 .borrow_mut()
280 .foreground_platform
281 .on_quit(Box::new(move || callback(&mut *cx.borrow_mut())));
282 self
283 }
284
285 pub fn on_event<F>(&mut self, mut callback: F) -> &mut Self
286 where
287 F: 'static + FnMut(Event, &mut MutableAppContext) -> bool,
288 {
289 let cx = self.0.clone();
290 self.0
291 .borrow_mut()
292 .foreground_platform
293 .on_event(Box::new(move |event| {
294 callback(event, &mut *cx.borrow_mut())
295 }));
296 self
297 }
298
299 pub fn on_open_urls<F>(&mut self, mut callback: F) -> &mut Self
300 where
301 F: 'static + FnMut(Vec<String>, &mut MutableAppContext),
302 {
303 let cx = self.0.clone();
304 self.0
305 .borrow_mut()
306 .foreground_platform
307 .on_open_urls(Box::new(move |paths| {
308 callback(paths, &mut *cx.borrow_mut())
309 }));
310 self
311 }
312
313 pub fn run<F>(self, on_finish_launching: F)
314 where
315 F: 'static + FnOnce(&mut MutableAppContext),
316 {
317 let platform = self.0.borrow().foreground_platform.clone();
318 platform.run(Box::new(move || {
319 let mut cx = self.0.borrow_mut();
320 let cx = &mut *cx;
321 crate::views::init(cx);
322 on_finish_launching(cx);
323 }))
324 }
325
326 pub fn platform(&self) -> Arc<dyn Platform> {
327 self.0.borrow().platform()
328 }
329
330 pub fn font_cache(&self) -> Arc<FontCache> {
331 self.0.borrow().cx.font_cache.clone()
332 }
333
334 fn update<T, F: FnOnce(&mut MutableAppContext) -> T>(&mut self, callback: F) -> T {
335 let mut state = self.0.borrow_mut();
336 let result = state.update(callback);
337 state.pending_notifications.clear();
338 result
339 }
340}
341
342impl WindowInputHandler {
343 fn read_focused_view<T, F>(&self, f: F) -> Option<T>
344 where
345 F: FnOnce(&dyn AnyView, &AppContext) -> T,
346 {
347 // Input-related application hooks are sometimes called by the OS during
348 // a call to a window-manipulation API, like prompting the user for file
349 // paths. In that case, the AppContext will already be borrowed, so any
350 // InputHandler methods need to fail gracefully.
351 //
352 // See https://github.com/zed-industries/feedback/issues/444
353 let app = self.app.try_borrow().ok()?;
354
355 let view_id = app.focused_view_id(self.window_id)?;
356 let view = app.cx.views.get(&(self.window_id, view_id))?;
357 let result = f(view.as_ref(), &app);
358 Some(result)
359 }
360
361 fn update_focused_view<T, F>(&mut self, f: F) -> Option<T>
362 where
363 F: FnOnce(usize, usize, &mut dyn AnyView, &mut MutableAppContext) -> T,
364 {
365 let mut app = self.app.try_borrow_mut().ok()?;
366 app.update(|app| {
367 let view_id = app.focused_view_id(self.window_id)?;
368 let mut view = app.cx.views.remove(&(self.window_id, view_id))?;
369 let result = f(self.window_id, view_id, view.as_mut(), &mut *app);
370 app.cx.views.insert((self.window_id, view_id), view);
371 Some(result)
372 })
373 }
374}
375
376impl InputHandler for WindowInputHandler {
377 fn text_for_range(&self, range: Range<usize>) -> Option<String> {
378 self.read_focused_view(|view, cx| view.text_for_range(range.clone(), cx))
379 .flatten()
380 }
381
382 fn selected_text_range(&self) -> Option<Range<usize>> {
383 self.read_focused_view(|view, cx| view.selected_text_range(cx))
384 .flatten()
385 }
386
387 fn replace_text_in_range(&mut self, range: Option<Range<usize>>, text: &str) {
388 self.update_focused_view(|window_id, view_id, view, cx| {
389 view.replace_text_in_range(range, text, cx, window_id, view_id);
390 });
391 }
392
393 fn marked_text_range(&self) -> Option<Range<usize>> {
394 self.read_focused_view(|view, cx| view.marked_text_range(cx))
395 .flatten()
396 }
397
398 fn unmark_text(&mut self) {
399 self.update_focused_view(|window_id, view_id, view, cx| {
400 view.unmark_text(cx, window_id, view_id);
401 });
402 }
403
404 fn replace_and_mark_text_in_range(
405 &mut self,
406 range: Option<Range<usize>>,
407 new_text: &str,
408 new_selected_range: Option<Range<usize>>,
409 ) {
410 self.update_focused_view(|window_id, view_id, view, cx| {
411 view.replace_and_mark_text_in_range(
412 range,
413 new_text,
414 new_selected_range,
415 cx,
416 window_id,
417 view_id,
418 );
419 });
420 }
421
422 fn rect_for_range(&self, range_utf16: Range<usize>) -> Option<RectF> {
423 let app = self.app.borrow();
424 let (presenter, _) = app.presenters_and_platform_windows.get(&self.window_id)?;
425 let presenter = presenter.borrow();
426 presenter.rect_for_text_range(range_utf16, &app)
427 }
428}
429
430#[cfg(any(test, feature = "test-support"))]
431impl TestAppContext {
432 pub fn new(
433 foreground_platform: Rc<platform::test::ForegroundPlatform>,
434 platform: Arc<dyn Platform>,
435 foreground: Rc<executor::Foreground>,
436 background: Arc<executor::Background>,
437 font_cache: Arc<FontCache>,
438 leak_detector: Arc<Mutex<LeakDetector>>,
439 first_entity_id: usize,
440 ) -> Self {
441 let mut cx = MutableAppContext::new(
442 foreground,
443 background,
444 platform,
445 foreground_platform.clone(),
446 font_cache,
447 RefCounts {
448 #[cfg(any(test, feature = "test-support"))]
449 leak_detector,
450 ..Default::default()
451 },
452 (),
453 );
454 cx.next_entity_id = first_entity_id;
455 let cx = TestAppContext {
456 cx: Rc::new(RefCell::new(cx)),
457 foreground_platform,
458 condition_duration: None,
459 };
460 cx.cx.borrow_mut().weak_self = Some(Rc::downgrade(&cx.cx));
461 cx
462 }
463
464 pub fn dispatch_action<A: Action>(&self, window_id: usize, action: A) {
465 let mut cx = self.cx.borrow_mut();
466 if let Some(view_id) = cx.focused_view_id(window_id) {
467 cx.handle_dispatch_action_from_effect(window_id, Some(view_id), &action);
468 }
469 }
470
471 pub fn dispatch_global_action<A: Action>(&self, action: A) {
472 self.cx.borrow_mut().dispatch_global_action(action);
473 }
474
475 pub fn dispatch_keystroke(&mut self, window_id: usize, keystroke: Keystroke, is_held: bool) {
476 let handled = self.cx.borrow_mut().update(|cx| {
477 let presenter = cx
478 .presenters_and_platform_windows
479 .get(&window_id)
480 .unwrap()
481 .0
482 .clone();
483
484 if cx.dispatch_keystroke(window_id, &keystroke) {
485 return true;
486 }
487
488 if presenter.borrow_mut().dispatch_event(
489 Event::KeyDown(KeyDownEvent {
490 keystroke: keystroke.clone(),
491 is_held,
492 }),
493 false,
494 cx,
495 ) {
496 return true;
497 }
498
499 false
500 });
501
502 if !handled && !keystroke.cmd && !keystroke.ctrl {
503 WindowInputHandler {
504 app: self.cx.clone(),
505 window_id,
506 }
507 .replace_text_in_range(None, &keystroke.key)
508 }
509 }
510
511 pub fn add_model<T, F>(&mut self, build_model: F) -> ModelHandle<T>
512 where
513 T: Entity,
514 F: FnOnce(&mut ModelContext<T>) -> T,
515 {
516 self.cx.borrow_mut().add_model(build_model)
517 }
518
519 pub fn add_window<T, F>(&mut self, build_root_view: F) -> (usize, ViewHandle<T>)
520 where
521 T: View,
522 F: FnOnce(&mut ViewContext<T>) -> T,
523 {
524 let (window_id, view) = self
525 .cx
526 .borrow_mut()
527 .add_window(Default::default(), build_root_view);
528 self.simulate_window_activation(Some(window_id));
529 (window_id, view)
530 }
531
532 pub fn add_view<T, F>(
533 &mut self,
534 parent_handle: impl Into<AnyViewHandle>,
535 build_view: F,
536 ) -> ViewHandle<T>
537 where
538 T: View,
539 F: FnOnce(&mut ViewContext<T>) -> T,
540 {
541 self.cx.borrow_mut().add_view(parent_handle, build_view)
542 }
543
544 pub fn window_ids(&self) -> Vec<usize> {
545 self.cx.borrow().window_ids().collect()
546 }
547
548 pub fn root_view<T: View>(&self, window_id: usize) -> Option<ViewHandle<T>> {
549 self.cx.borrow().root_view(window_id)
550 }
551
552 pub fn read<T, F: FnOnce(&AppContext) -> T>(&self, callback: F) -> T {
553 callback(self.cx.borrow().as_ref())
554 }
555
556 pub fn update<T, F: FnOnce(&mut MutableAppContext) -> T>(&mut self, callback: F) -> T {
557 let mut state = self.cx.borrow_mut();
558 // Don't increment pending flushes in order for effects to be flushed before the callback
559 // completes, which is helpful in tests.
560 let result = callback(&mut *state);
561 // Flush effects after the callback just in case there are any. This can happen in edge
562 // cases such as the closure dropping handles.
563 state.flush_effects();
564 result
565 }
566
567 pub fn render<F, V, T>(&mut self, handle: &ViewHandle<V>, f: F) -> T
568 where
569 F: FnOnce(&mut V, &mut RenderContext<V>) -> T,
570 V: View,
571 {
572 handle.update(&mut *self.cx.borrow_mut(), |view, cx| {
573 let mut render_cx = RenderContext {
574 app: cx,
575 window_id: handle.window_id(),
576 view_id: handle.id(),
577 view_type: PhantomData,
578 titlebar_height: 0.,
579 hovered_region_ids: Default::default(),
580 clicked_region_ids: None,
581 refreshing: false,
582 };
583 f(view, &mut render_cx)
584 })
585 }
586
587 pub fn to_async(&self) -> AsyncAppContext {
588 AsyncAppContext(self.cx.clone())
589 }
590
591 pub fn font_cache(&self) -> Arc<FontCache> {
592 self.cx.borrow().cx.font_cache.clone()
593 }
594
595 pub fn foreground_platform(&self) -> Rc<platform::test::ForegroundPlatform> {
596 self.foreground_platform.clone()
597 }
598
599 pub fn platform(&self) -> Arc<dyn platform::Platform> {
600 self.cx.borrow().cx.platform.clone()
601 }
602
603 pub fn foreground(&self) -> Rc<executor::Foreground> {
604 self.cx.borrow().foreground().clone()
605 }
606
607 pub fn background(&self) -> Arc<executor::Background> {
608 self.cx.borrow().background().clone()
609 }
610
611 pub fn spawn<F, Fut, T>(&self, f: F) -> Task<T>
612 where
613 F: FnOnce(AsyncAppContext) -> Fut,
614 Fut: 'static + Future<Output = T>,
615 T: 'static,
616 {
617 let foreground = self.foreground();
618 let future = f(self.to_async());
619 let cx = self.to_async();
620 foreground.spawn(async move {
621 let result = future.await;
622 cx.0.borrow_mut().flush_effects();
623 result
624 })
625 }
626
627 pub fn simulate_new_path_selection(&self, result: impl FnOnce(PathBuf) -> Option<PathBuf>) {
628 self.foreground_platform.simulate_new_path_selection(result);
629 }
630
631 pub fn did_prompt_for_new_path(&self) -> bool {
632 self.foreground_platform.as_ref().did_prompt_for_new_path()
633 }
634
635 pub fn simulate_prompt_answer(&self, window_id: usize, answer: usize) {
636 use postage::prelude::Sink as _;
637
638 let mut done_tx = self
639 .window_mut(window_id)
640 .pending_prompts
641 .borrow_mut()
642 .pop_front()
643 .expect("prompt was not called");
644 let _ = done_tx.try_send(answer);
645 }
646
647 pub fn has_pending_prompt(&self, window_id: usize) -> bool {
648 let window = self.window_mut(window_id);
649 let prompts = window.pending_prompts.borrow_mut();
650 !prompts.is_empty()
651 }
652
653 pub fn current_window_title(&self, window_id: usize) -> Option<String> {
654 self.window_mut(window_id).title.clone()
655 }
656
657 pub fn simulate_window_close(&self, window_id: usize) -> bool {
658 let handler = self.window_mut(window_id).should_close_handler.take();
659 if let Some(mut handler) = handler {
660 let should_close = handler();
661 self.window_mut(window_id).should_close_handler = Some(handler);
662 should_close
663 } else {
664 false
665 }
666 }
667
668 pub fn simulate_window_activation(&self, to_activate: Option<usize>) {
669 let mut handlers = BTreeMap::new();
670 {
671 let mut cx = self.cx.borrow_mut();
672 for (window_id, (_, window)) in &mut cx.presenters_and_platform_windows {
673 let window = window
674 .as_any_mut()
675 .downcast_mut::<platform::test::Window>()
676 .unwrap();
677 handlers.insert(
678 *window_id,
679 mem::take(&mut window.active_status_change_handlers),
680 );
681 }
682 };
683 let mut handlers = handlers.into_iter().collect::<Vec<_>>();
684 handlers.sort_unstable_by_key(|(window_id, _)| Some(*window_id) == to_activate);
685
686 for (window_id, mut window_handlers) in handlers {
687 for window_handler in &mut window_handlers {
688 window_handler(Some(window_id) == to_activate);
689 }
690
691 self.window_mut(window_id)
692 .active_status_change_handlers
693 .extend(window_handlers);
694 }
695 }
696
697 pub fn is_window_edited(&self, window_id: usize) -> bool {
698 self.window_mut(window_id).edited
699 }
700
701 pub fn leak_detector(&self) -> Arc<Mutex<LeakDetector>> {
702 self.cx.borrow().leak_detector()
703 }
704
705 pub fn assert_dropped(&self, handle: impl WeakHandle) {
706 self.cx
707 .borrow()
708 .leak_detector()
709 .lock()
710 .assert_dropped(handle.id())
711 }
712
713 fn window_mut(&self, window_id: usize) -> std::cell::RefMut<platform::test::Window> {
714 std::cell::RefMut::map(self.cx.borrow_mut(), |state| {
715 let (_, window) = state
716 .presenters_and_platform_windows
717 .get_mut(&window_id)
718 .unwrap();
719 let test_window = window
720 .as_any_mut()
721 .downcast_mut::<platform::test::Window>()
722 .unwrap();
723 test_window
724 })
725 }
726
727 pub fn set_condition_duration(&mut self, duration: Option<Duration>) {
728 self.condition_duration = duration;
729 }
730
731 pub fn condition_duration(&self) -> Duration {
732 self.condition_duration.unwrap_or_else(|| {
733 if std::env::var("CI").is_ok() {
734 Duration::from_secs(2)
735 } else {
736 Duration::from_millis(500)
737 }
738 })
739 }
740
741 pub fn assert_clipboard_content(&mut self, expected_content: Option<&str>) {
742 self.update(|cx| {
743 let actual_content = cx.read_from_clipboard().map(|item| item.text().to_owned());
744 let expected_content = expected_content.map(|content| content.to_owned());
745 assert_eq!(actual_content, expected_content);
746 })
747 }
748}
749
750impl AsyncAppContext {
751 pub fn spawn<F, Fut, T>(&self, f: F) -> Task<T>
752 where
753 F: FnOnce(AsyncAppContext) -> Fut,
754 Fut: 'static + Future<Output = T>,
755 T: 'static,
756 {
757 self.0.borrow().foreground.spawn(f(self.clone()))
758 }
759
760 pub fn read<T, F: FnOnce(&AppContext) -> T>(&self, callback: F) -> T {
761 callback(self.0.borrow().as_ref())
762 }
763
764 pub fn update<T, F: FnOnce(&mut MutableAppContext) -> T>(&mut self, callback: F) -> T {
765 self.0.borrow_mut().update(callback)
766 }
767
768 pub fn add_model<T, F>(&mut self, build_model: F) -> ModelHandle<T>
769 where
770 T: Entity,
771 F: FnOnce(&mut ModelContext<T>) -> T,
772 {
773 self.update(|cx| cx.add_model(build_model))
774 }
775
776 pub fn add_window<T, F>(
777 &mut self,
778 window_options: WindowOptions,
779 build_root_view: F,
780 ) -> (usize, ViewHandle<T>)
781 where
782 T: View,
783 F: FnOnce(&mut ViewContext<T>) -> T,
784 {
785 self.update(|cx| cx.add_window(window_options, build_root_view))
786 }
787
788 pub fn platform(&self) -> Arc<dyn Platform> {
789 self.0.borrow().platform()
790 }
791
792 pub fn foreground(&self) -> Rc<executor::Foreground> {
793 self.0.borrow().foreground.clone()
794 }
795
796 pub fn background(&self) -> Arc<executor::Background> {
797 self.0.borrow().cx.background.clone()
798 }
799}
800
801impl UpdateModel for AsyncAppContext {
802 fn update_model<E: Entity, O>(
803 &mut self,
804 handle: &ModelHandle<E>,
805 update: &mut dyn FnMut(&mut E, &mut ModelContext<E>) -> O,
806 ) -> O {
807 self.0.borrow_mut().update_model(handle, update)
808 }
809}
810
811impl UpgradeModelHandle for AsyncAppContext {
812 fn upgrade_model_handle<T: Entity>(
813 &self,
814 handle: &WeakModelHandle<T>,
815 ) -> Option<ModelHandle<T>> {
816 self.0.borrow().upgrade_model_handle(handle)
817 }
818
819 fn model_handle_is_upgradable<T: Entity>(&self, handle: &WeakModelHandle<T>) -> bool {
820 self.0.borrow().model_handle_is_upgradable(handle)
821 }
822
823 fn upgrade_any_model_handle(&self, handle: &AnyWeakModelHandle) -> Option<AnyModelHandle> {
824 self.0.borrow().upgrade_any_model_handle(handle)
825 }
826}
827
828impl UpgradeViewHandle for AsyncAppContext {
829 fn upgrade_view_handle<T: View>(&self, handle: &WeakViewHandle<T>) -> Option<ViewHandle<T>> {
830 self.0.borrow_mut().upgrade_view_handle(handle)
831 }
832
833 fn upgrade_any_view_handle(&self, handle: &AnyWeakViewHandle) -> Option<AnyViewHandle> {
834 self.0.borrow_mut().upgrade_any_view_handle(handle)
835 }
836}
837
838impl ReadModelWith for AsyncAppContext {
839 fn read_model_with<E: Entity, T>(
840 &self,
841 handle: &ModelHandle<E>,
842 read: &mut dyn FnMut(&E, &AppContext) -> T,
843 ) -> T {
844 let cx = self.0.borrow();
845 let cx = cx.as_ref();
846 read(handle.read(cx), cx)
847 }
848}
849
850impl UpdateView for AsyncAppContext {
851 fn update_view<T, S>(
852 &mut self,
853 handle: &ViewHandle<T>,
854 update: &mut dyn FnMut(&mut T, &mut ViewContext<T>) -> S,
855 ) -> S
856 where
857 T: View,
858 {
859 self.0.borrow_mut().update_view(handle, update)
860 }
861}
862
863impl ReadViewWith for AsyncAppContext {
864 fn read_view_with<V, T>(
865 &self,
866 handle: &ViewHandle<V>,
867 read: &mut dyn FnMut(&V, &AppContext) -> T,
868 ) -> T
869 where
870 V: View,
871 {
872 let cx = self.0.borrow();
873 let cx = cx.as_ref();
874 read(handle.read(cx), cx)
875 }
876}
877
878#[cfg(any(test, feature = "test-support"))]
879impl UpdateModel for TestAppContext {
880 fn update_model<T: Entity, O>(
881 &mut self,
882 handle: &ModelHandle<T>,
883 update: &mut dyn FnMut(&mut T, &mut ModelContext<T>) -> O,
884 ) -> O {
885 self.cx.borrow_mut().update_model(handle, update)
886 }
887}
888
889#[cfg(any(test, feature = "test-support"))]
890impl ReadModelWith for TestAppContext {
891 fn read_model_with<E: Entity, T>(
892 &self,
893 handle: &ModelHandle<E>,
894 read: &mut dyn FnMut(&E, &AppContext) -> T,
895 ) -> T {
896 let cx = self.cx.borrow();
897 let cx = cx.as_ref();
898 read(handle.read(cx), cx)
899 }
900}
901
902#[cfg(any(test, feature = "test-support"))]
903impl UpdateView for TestAppContext {
904 fn update_view<T, S>(
905 &mut self,
906 handle: &ViewHandle<T>,
907 update: &mut dyn FnMut(&mut T, &mut ViewContext<T>) -> S,
908 ) -> S
909 where
910 T: View,
911 {
912 self.cx.borrow_mut().update_view(handle, update)
913 }
914}
915
916#[cfg(any(test, feature = "test-support"))]
917impl ReadViewWith for TestAppContext {
918 fn read_view_with<V, T>(
919 &self,
920 handle: &ViewHandle<V>,
921 read: &mut dyn FnMut(&V, &AppContext) -> T,
922 ) -> T
923 where
924 V: View,
925 {
926 let cx = self.cx.borrow();
927 let cx = cx.as_ref();
928 read(handle.read(cx), cx)
929 }
930}
931
932type ActionCallback =
933 dyn FnMut(&mut dyn AnyView, &dyn Action, &mut MutableAppContext, usize, usize);
934type GlobalActionCallback = dyn FnMut(&dyn Action, &mut MutableAppContext);
935
936type SubscriptionCallback = Box<dyn FnMut(&dyn Any, &mut MutableAppContext) -> bool>;
937type GlobalSubscriptionCallback = Box<dyn FnMut(&dyn Any, &mut MutableAppContext)>;
938type ObservationCallback = Box<dyn FnMut(&mut MutableAppContext) -> bool>;
939type FocusObservationCallback = Box<dyn FnMut(bool, &mut MutableAppContext) -> bool>;
940type GlobalObservationCallback = Box<dyn FnMut(&mut MutableAppContext)>;
941type ReleaseObservationCallback = Box<dyn FnOnce(&dyn Any, &mut MutableAppContext)>;
942type ActionObservationCallback = Box<dyn FnMut(TypeId, &mut MutableAppContext)>;
943type WindowActivationCallback = Box<dyn FnMut(bool, &mut MutableAppContext) -> bool>;
944type WindowFullscreenCallback = Box<dyn FnMut(bool, &mut MutableAppContext) -> bool>;
945type DeserializeActionCallback = fn(json: &str) -> anyhow::Result<Box<dyn Action>>;
946type WindowShouldCloseSubscriptionCallback = Box<dyn FnMut(&mut MutableAppContext) -> bool>;
947
948pub struct MutableAppContext {
949 weak_self: Option<rc::Weak<RefCell<Self>>>,
950 foreground_platform: Rc<dyn platform::ForegroundPlatform>,
951 assets: Arc<AssetCache>,
952 cx: AppContext,
953 action_deserializers: HashMap<&'static str, (TypeId, DeserializeActionCallback)>,
954 capture_actions: HashMap<TypeId, HashMap<TypeId, Vec<Box<ActionCallback>>>>,
955 actions: HashMap<TypeId, HashMap<TypeId, Vec<Box<ActionCallback>>>>,
956 global_actions: HashMap<TypeId, Box<GlobalActionCallback>>,
957 keystroke_matcher: keymap::Matcher,
958 next_entity_id: usize,
959 next_window_id: usize,
960 next_subscription_id: usize,
961 frame_count: usize,
962
963 focus_observations: CallbackCollection<usize, FocusObservationCallback>,
964 global_subscriptions: CallbackCollection<TypeId, GlobalSubscriptionCallback>,
965 global_observations: CallbackCollection<TypeId, GlobalObservationCallback>,
966 subscriptions: CallbackCollection<usize, SubscriptionCallback>,
967 observations: CallbackCollection<usize, ObservationCallback>,
968 window_activation_observations: CallbackCollection<usize, WindowActivationCallback>,
969 window_fullscreen_observations: CallbackCollection<usize, WindowFullscreenCallback>,
970
971 release_observations: Arc<Mutex<HashMap<usize, BTreeMap<usize, ReleaseObservationCallback>>>>,
972 action_dispatch_observations: Arc<Mutex<BTreeMap<usize, ActionObservationCallback>>>,
973
974 #[allow(clippy::type_complexity)]
975 presenters_and_platform_windows:
976 HashMap<usize, (Rc<RefCell<Presenter>>, Box<dyn platform::Window>)>,
977 foreground: Rc<executor::Foreground>,
978 pending_effects: VecDeque<Effect>,
979 pending_focus_index: Option<usize>,
980 pending_notifications: HashSet<usize>,
981 pending_global_notifications: HashSet<TypeId>,
982 pending_flushes: usize,
983 flushing_effects: bool,
984 halt_action_dispatch: bool,
985}
986
987impl MutableAppContext {
988 fn new(
989 foreground: Rc<executor::Foreground>,
990 background: Arc<executor::Background>,
991 platform: Arc<dyn platform::Platform>,
992 foreground_platform: Rc<dyn platform::ForegroundPlatform>,
993 font_cache: Arc<FontCache>,
994 ref_counts: RefCounts,
995 asset_source: impl AssetSource,
996 ) -> Self {
997 Self {
998 weak_self: None,
999 foreground_platform,
1000 assets: Arc::new(AssetCache::new(asset_source)),
1001 cx: AppContext {
1002 models: Default::default(),
1003 views: Default::default(),
1004 parents: Default::default(),
1005 windows: Default::default(),
1006 globals: Default::default(),
1007 element_states: Default::default(),
1008 ref_counts: Arc::new(Mutex::new(ref_counts)),
1009 background,
1010 font_cache,
1011 platform,
1012 },
1013 action_deserializers: Default::default(),
1014 capture_actions: Default::default(),
1015 actions: Default::default(),
1016 global_actions: Default::default(),
1017 keystroke_matcher: keymap::Matcher::default(),
1018 next_entity_id: 0,
1019 next_window_id: 0,
1020 next_subscription_id: 0,
1021 frame_count: 0,
1022 subscriptions: Default::default(),
1023 global_subscriptions: Default::default(),
1024 observations: Default::default(),
1025 focus_observations: Default::default(),
1026 release_observations: Default::default(),
1027 global_observations: Default::default(),
1028 window_activation_observations: Default::default(),
1029 window_fullscreen_observations: Default::default(),
1030 action_dispatch_observations: Default::default(),
1031 presenters_and_platform_windows: Default::default(),
1032 foreground,
1033 pending_effects: VecDeque::new(),
1034 pending_focus_index: None,
1035 pending_notifications: Default::default(),
1036 pending_global_notifications: Default::default(),
1037 pending_flushes: 0,
1038 flushing_effects: false,
1039 halt_action_dispatch: false,
1040 }
1041 }
1042
1043 pub fn upgrade(&self) -> App {
1044 App(self.weak_self.as_ref().unwrap().upgrade().unwrap())
1045 }
1046
1047 pub fn quit(&mut self) {
1048 let mut futures = Vec::new();
1049 for model_id in self.cx.models.keys().copied().collect::<Vec<_>>() {
1050 let mut model = self.cx.models.remove(&model_id).unwrap();
1051 futures.extend(model.app_will_quit(self));
1052 self.cx.models.insert(model_id, model);
1053 }
1054
1055 for view_id in self.cx.views.keys().copied().collect::<Vec<_>>() {
1056 let mut view = self.cx.views.remove(&view_id).unwrap();
1057 futures.extend(view.app_will_quit(self));
1058 self.cx.views.insert(view_id, view);
1059 }
1060
1061 self.remove_all_windows();
1062
1063 let futures = futures::future::join_all(futures);
1064 if self
1065 .background
1066 .block_with_timeout(Duration::from_millis(100), futures)
1067 .is_err()
1068 {
1069 log::error!("timed out waiting on app_will_quit");
1070 }
1071 }
1072
1073 pub fn remove_all_windows(&mut self) {
1074 for (window_id, _) in self.cx.windows.drain() {
1075 self.presenters_and_platform_windows.remove(&window_id);
1076 }
1077 self.flush_effects();
1078 }
1079
1080 pub fn platform(&self) -> Arc<dyn platform::Platform> {
1081 self.cx.platform.clone()
1082 }
1083
1084 pub fn font_cache(&self) -> &Arc<FontCache> {
1085 &self.cx.font_cache
1086 }
1087
1088 pub fn foreground(&self) -> &Rc<executor::Foreground> {
1089 &self.foreground
1090 }
1091
1092 pub fn background(&self) -> &Arc<executor::Background> {
1093 &self.cx.background
1094 }
1095
1096 pub fn debug_elements(&self, window_id: usize) -> Option<crate::json::Value> {
1097 self.presenters_and_platform_windows
1098 .get(&window_id)
1099 .and_then(|(presenter, _)| presenter.borrow().debug_elements(self))
1100 }
1101
1102 pub fn deserialize_action(
1103 &self,
1104 name: &str,
1105 argument: Option<&str>,
1106 ) -> Result<Box<dyn Action>> {
1107 let callback = self
1108 .action_deserializers
1109 .get(name)
1110 .ok_or_else(|| anyhow!("unknown action {}", name))?
1111 .1;
1112 callback(argument.unwrap_or("{}"))
1113 .with_context(|| format!("invalid data for action {}", name))
1114 }
1115
1116 pub fn add_action<A, V, F>(&mut self, handler: F)
1117 where
1118 A: Action,
1119 V: View,
1120 F: 'static + FnMut(&mut V, &A, &mut ViewContext<V>),
1121 {
1122 self.add_action_internal(handler, false)
1123 }
1124
1125 pub fn capture_action<A, V, F>(&mut self, handler: F)
1126 where
1127 A: Action,
1128 V: View,
1129 F: 'static + FnMut(&mut V, &A, &mut ViewContext<V>),
1130 {
1131 self.add_action_internal(handler, true)
1132 }
1133
1134 fn add_action_internal<A, V, F>(&mut self, mut handler: F, capture: bool)
1135 where
1136 A: Action,
1137 V: View,
1138 F: 'static + FnMut(&mut V, &A, &mut ViewContext<V>),
1139 {
1140 let handler = Box::new(
1141 move |view: &mut dyn AnyView,
1142 action: &dyn Action,
1143 cx: &mut MutableAppContext,
1144 window_id: usize,
1145 view_id: usize| {
1146 let action = action.as_any().downcast_ref().unwrap();
1147 let mut cx = ViewContext::new(cx, window_id, view_id);
1148 handler(
1149 view.as_any_mut()
1150 .downcast_mut()
1151 .expect("downcast is type safe"),
1152 action,
1153 &mut cx,
1154 );
1155 },
1156 );
1157
1158 self.action_deserializers
1159 .entry(A::qualified_name())
1160 .or_insert((TypeId::of::<A>(), A::from_json_str));
1161
1162 let actions = if capture {
1163 &mut self.capture_actions
1164 } else {
1165 &mut self.actions
1166 };
1167
1168 actions
1169 .entry(TypeId::of::<V>())
1170 .or_default()
1171 .entry(TypeId::of::<A>())
1172 .or_default()
1173 .push(handler);
1174 }
1175
1176 pub fn add_async_action<A, V, F>(&mut self, mut handler: F)
1177 where
1178 A: Action,
1179 V: View,
1180 F: 'static + FnMut(&mut V, &A, &mut ViewContext<V>) -> Option<Task<Result<()>>>,
1181 {
1182 self.add_action(move |view, action, cx| {
1183 if let Some(task) = handler(view, action, cx) {
1184 task.detach_and_log_err(cx);
1185 }
1186 })
1187 }
1188
1189 pub fn add_global_action<A, F>(&mut self, mut handler: F)
1190 where
1191 A: Action,
1192 F: 'static + FnMut(&A, &mut MutableAppContext),
1193 {
1194 let handler = Box::new(move |action: &dyn Action, cx: &mut MutableAppContext| {
1195 let action = action.as_any().downcast_ref().unwrap();
1196 handler(action, cx);
1197 });
1198
1199 self.action_deserializers
1200 .entry(A::qualified_name())
1201 .or_insert((TypeId::of::<A>(), A::from_json_str));
1202
1203 if self
1204 .global_actions
1205 .insert(TypeId::of::<A>(), handler)
1206 .is_some()
1207 {
1208 panic!(
1209 "registered multiple global handlers for {}",
1210 type_name::<A>()
1211 );
1212 }
1213 }
1214
1215 pub fn window_ids(&self) -> impl Iterator<Item = usize> + '_ {
1216 self.cx.windows.keys().cloned()
1217 }
1218
1219 pub fn activate_window(&self, window_id: usize) {
1220 if let Some((_, window)) = self.presenters_and_platform_windows.get(&window_id) {
1221 window.activate()
1222 }
1223 }
1224
1225 pub fn root_view<T: View>(&self, window_id: usize) -> Option<ViewHandle<T>> {
1226 self.cx
1227 .windows
1228 .get(&window_id)
1229 .and_then(|window| window.root_view.clone().downcast::<T>())
1230 }
1231
1232 pub fn window_is_active(&self, window_id: usize) -> bool {
1233 self.cx
1234 .windows
1235 .get(&window_id)
1236 .map_or(false, |window| window.is_active)
1237 }
1238
1239 pub fn window_is_fullscreen(&self, window_id: usize) -> bool {
1240 self.cx
1241 .windows
1242 .get(&window_id)
1243 .map_or(false, |window| window.is_fullscreen)
1244 }
1245
1246 pub fn render_view(&mut self, params: RenderParams) -> Result<ElementBox> {
1247 let window_id = params.window_id;
1248 let view_id = params.view_id;
1249 let mut view = self
1250 .cx
1251 .views
1252 .remove(&(window_id, view_id))
1253 .ok_or_else(|| anyhow!("view not found"))?;
1254 let element = view.render(params, self);
1255 self.cx.views.insert((window_id, view_id), view);
1256 Ok(element)
1257 }
1258
1259 pub fn render_views(
1260 &mut self,
1261 window_id: usize,
1262 titlebar_height: f32,
1263 ) -> HashMap<usize, ElementBox> {
1264 self.start_frame();
1265 #[allow(clippy::needless_collect)]
1266 let view_ids = self
1267 .views
1268 .keys()
1269 .filter_map(|(win_id, view_id)| {
1270 if *win_id == window_id {
1271 Some(*view_id)
1272 } else {
1273 None
1274 }
1275 })
1276 .collect::<Vec<_>>();
1277
1278 view_ids
1279 .into_iter()
1280 .map(|view_id| {
1281 (
1282 view_id,
1283 self.render_view(RenderParams {
1284 window_id,
1285 view_id,
1286 titlebar_height,
1287 hovered_region_ids: Default::default(),
1288 clicked_region_ids: None,
1289 refreshing: false,
1290 })
1291 .unwrap(),
1292 )
1293 })
1294 .collect()
1295 }
1296
1297 pub(crate) fn start_frame(&mut self) {
1298 self.frame_count += 1;
1299 }
1300
1301 pub fn update<T, F: FnOnce(&mut Self) -> T>(&mut self, callback: F) -> T {
1302 self.pending_flushes += 1;
1303 let result = callback(self);
1304 self.flush_effects();
1305 result
1306 }
1307
1308 pub fn set_menus(&mut self, menus: Vec<Menu>) {
1309 self.foreground_platform
1310 .set_menus(menus, &self.keystroke_matcher);
1311 }
1312
1313 fn show_character_palette(&self, window_id: usize) {
1314 let (_, window) = &self.presenters_and_platform_windows[&window_id];
1315 window.show_character_palette();
1316 }
1317
1318 pub fn minimize_window(&self, window_id: usize) {
1319 let (_, window) = &self.presenters_and_platform_windows[&window_id];
1320 window.minimize();
1321 }
1322
1323 pub fn zoom_window(&self, window_id: usize) {
1324 let (_, window) = &self.presenters_and_platform_windows[&window_id];
1325 window.zoom();
1326 }
1327
1328 pub fn toggle_window_full_screen(&self, window_id: usize) {
1329 let (_, window) = &self.presenters_and_platform_windows[&window_id];
1330 window.toggle_full_screen();
1331 }
1332
1333 fn prompt(
1334 &self,
1335 window_id: usize,
1336 level: PromptLevel,
1337 msg: &str,
1338 answers: &[&str],
1339 ) -> oneshot::Receiver<usize> {
1340 let (_, window) = &self.presenters_and_platform_windows[&window_id];
1341 window.prompt(level, msg, answers)
1342 }
1343
1344 pub fn prompt_for_paths(
1345 &self,
1346 options: PathPromptOptions,
1347 ) -> oneshot::Receiver<Option<Vec<PathBuf>>> {
1348 self.foreground_platform.prompt_for_paths(options)
1349 }
1350
1351 pub fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Option<PathBuf>> {
1352 self.foreground_platform.prompt_for_new_path(directory)
1353 }
1354
1355 pub fn emit_global<E: Any>(&mut self, payload: E) {
1356 self.pending_effects.push_back(Effect::GlobalEvent {
1357 payload: Box::new(payload),
1358 });
1359 }
1360
1361 pub fn subscribe<E, H, F>(&mut self, handle: &H, mut callback: F) -> Subscription
1362 where
1363 E: Entity,
1364 E::Event: 'static,
1365 H: Handle<E>,
1366 F: 'static + FnMut(H, &E::Event, &mut Self),
1367 {
1368 self.subscribe_internal(handle, move |handle, event, cx| {
1369 callback(handle, event, cx);
1370 true
1371 })
1372 }
1373
1374 pub fn subscribe_global<E, F>(&mut self, mut callback: F) -> Subscription
1375 where
1376 E: Any,
1377 F: 'static + FnMut(&E, &mut Self),
1378 {
1379 let subscription_id = post_inc(&mut self.next_subscription_id);
1380 let type_id = TypeId::of::<E>();
1381 self.pending_effects.push_back(Effect::GlobalSubscription {
1382 type_id,
1383 subscription_id,
1384 callback: Box::new(move |payload, cx| {
1385 let payload = payload.downcast_ref().expect("downcast is type safe");
1386 callback(payload, cx)
1387 }),
1388 });
1389
1390 Subscription::GlobalSubscription {
1391 id: subscription_id,
1392 type_id,
1393 subscriptions: Some(self.global_subscriptions.downgrade()),
1394 }
1395 }
1396
1397 pub fn observe<E, H, F>(&mut self, handle: &H, mut callback: F) -> Subscription
1398 where
1399 E: Entity,
1400 E::Event: 'static,
1401 H: Handle<E>,
1402 F: 'static + FnMut(H, &mut Self),
1403 {
1404 self.observe_internal(handle, move |handle, cx| {
1405 callback(handle, cx);
1406 true
1407 })
1408 }
1409
1410 pub fn subscribe_internal<E, H, F>(&mut self, handle: &H, mut callback: F) -> Subscription
1411 where
1412 E: Entity,
1413 E::Event: 'static,
1414 H: Handle<E>,
1415 F: 'static + FnMut(H, &E::Event, &mut Self) -> bool,
1416 {
1417 let subscription_id = post_inc(&mut self.next_subscription_id);
1418 let emitter = handle.downgrade();
1419 self.pending_effects.push_back(Effect::Subscription {
1420 entity_id: handle.id(),
1421 subscription_id,
1422 callback: Box::new(move |payload, cx| {
1423 if let Some(emitter) = H::upgrade_from(&emitter, cx.as_ref()) {
1424 let payload = payload.downcast_ref().expect("downcast is type safe");
1425 callback(emitter, payload, cx)
1426 } else {
1427 false
1428 }
1429 }),
1430 });
1431 Subscription::Subscription {
1432 id: subscription_id,
1433 entity_id: handle.id(),
1434 subscriptions: Some(self.subscriptions.downgrade()),
1435 }
1436 }
1437
1438 fn observe_internal<E, H, F>(&mut self, handle: &H, mut callback: F) -> Subscription
1439 where
1440 E: Entity,
1441 E::Event: 'static,
1442 H: Handle<E>,
1443 F: 'static + FnMut(H, &mut Self) -> bool,
1444 {
1445 let subscription_id = post_inc(&mut self.next_subscription_id);
1446 let observed = handle.downgrade();
1447 let entity_id = handle.id();
1448 self.pending_effects.push_back(Effect::Observation {
1449 entity_id,
1450 subscription_id,
1451 callback: Box::new(move |cx| {
1452 if let Some(observed) = H::upgrade_from(&observed, cx) {
1453 callback(observed, cx)
1454 } else {
1455 false
1456 }
1457 }),
1458 });
1459 Subscription::Observation {
1460 id: subscription_id,
1461 entity_id,
1462 observations: Some(self.observations.downgrade()),
1463 }
1464 }
1465
1466 fn observe_focus<F, V>(&mut self, handle: &ViewHandle<V>, mut callback: F) -> Subscription
1467 where
1468 F: 'static + FnMut(ViewHandle<V>, bool, &mut MutableAppContext) -> bool,
1469 V: View,
1470 {
1471 let subscription_id = post_inc(&mut self.next_subscription_id);
1472 let observed = handle.downgrade();
1473 let view_id = handle.id();
1474
1475 self.pending_effects.push_back(Effect::FocusObservation {
1476 view_id,
1477 subscription_id,
1478 callback: Box::new(move |focused, cx| {
1479 if let Some(observed) = observed.upgrade(cx) {
1480 callback(observed, focused, cx)
1481 } else {
1482 false
1483 }
1484 }),
1485 });
1486
1487 Subscription::FocusObservation {
1488 id: subscription_id,
1489 view_id,
1490 observations: Some(self.focus_observations.downgrade()),
1491 }
1492 }
1493
1494 pub fn observe_global<G, F>(&mut self, mut observe: F) -> Subscription
1495 where
1496 G: Any,
1497 F: 'static + FnMut(&mut MutableAppContext),
1498 {
1499 let type_id = TypeId::of::<G>();
1500 let id = post_inc(&mut self.next_subscription_id);
1501
1502 self.global_observations.add_callback(
1503 type_id,
1504 id,
1505 Box::new(move |cx: &mut MutableAppContext| observe(cx)),
1506 );
1507
1508 Subscription::GlobalObservation {
1509 id,
1510 type_id,
1511 observations: Some(self.global_observations.downgrade()),
1512 }
1513 }
1514
1515 pub fn observe_release<E, H, F>(&mut self, handle: &H, callback: F) -> Subscription
1516 where
1517 E: Entity,
1518 E::Event: 'static,
1519 H: Handle<E>,
1520 F: 'static + FnOnce(&E, &mut Self),
1521 {
1522 let id = post_inc(&mut self.next_subscription_id);
1523 self.release_observations
1524 .lock()
1525 .entry(handle.id())
1526 .or_default()
1527 .insert(
1528 id,
1529 Box::new(move |released, cx| {
1530 let released = released.downcast_ref().unwrap();
1531 callback(released, cx)
1532 }),
1533 );
1534 Subscription::ReleaseObservation {
1535 id,
1536 entity_id: handle.id(),
1537 observations: Some(Arc::downgrade(&self.release_observations)),
1538 }
1539 }
1540
1541 pub fn observe_actions<F>(&mut self, callback: F) -> Subscription
1542 where
1543 F: 'static + FnMut(TypeId, &mut MutableAppContext),
1544 {
1545 let id = post_inc(&mut self.next_subscription_id);
1546 self.action_dispatch_observations
1547 .lock()
1548 .insert(id, Box::new(callback));
1549 Subscription::ActionObservation {
1550 id,
1551 observations: Some(Arc::downgrade(&self.action_dispatch_observations)),
1552 }
1553 }
1554
1555 fn observe_window_activation<F>(&mut self, window_id: usize, callback: F) -> Subscription
1556 where
1557 F: 'static + FnMut(bool, &mut MutableAppContext) -> bool,
1558 {
1559 let subscription_id = post_inc(&mut self.next_subscription_id);
1560 self.pending_effects
1561 .push_back(Effect::WindowActivationObservation {
1562 window_id,
1563 subscription_id,
1564 callback: Box::new(callback),
1565 });
1566 Subscription::WindowActivationObservation {
1567 id: subscription_id,
1568 window_id,
1569 observations: Some(self.window_activation_observations.downgrade()),
1570 }
1571 }
1572
1573 fn observe_fullscreen<F>(&mut self, window_id: usize, callback: F) -> Subscription
1574 where
1575 F: 'static + FnMut(bool, &mut MutableAppContext) -> bool,
1576 {
1577 let subscription_id = post_inc(&mut self.next_subscription_id);
1578 self.pending_effects
1579 .push_back(Effect::WindowFullscreenObservation {
1580 window_id,
1581 subscription_id,
1582 callback: Box::new(callback),
1583 });
1584 Subscription::WindowFullscreenObservation {
1585 id: subscription_id,
1586 window_id,
1587 observations: Some(self.window_activation_observations.downgrade()),
1588 }
1589 }
1590
1591 pub fn defer(&mut self, callback: impl 'static + FnOnce(&mut MutableAppContext)) {
1592 self.pending_effects.push_back(Effect::Deferred {
1593 callback: Box::new(callback),
1594 after_window_update: false,
1595 })
1596 }
1597
1598 pub fn after_window_update(&mut self, callback: impl 'static + FnOnce(&mut MutableAppContext)) {
1599 self.pending_effects.push_back(Effect::Deferred {
1600 callback: Box::new(callback),
1601 after_window_update: true,
1602 })
1603 }
1604
1605 pub(crate) fn notify_model(&mut self, model_id: usize) {
1606 if self.pending_notifications.insert(model_id) {
1607 self.pending_effects
1608 .push_back(Effect::ModelNotification { model_id });
1609 }
1610 }
1611
1612 pub(crate) fn notify_view(&mut self, window_id: usize, view_id: usize) {
1613 if self.pending_notifications.insert(view_id) {
1614 self.pending_effects
1615 .push_back(Effect::ViewNotification { window_id, view_id });
1616 }
1617 }
1618
1619 pub(crate) fn notify_global(&mut self, type_id: TypeId) {
1620 if self.pending_global_notifications.insert(type_id) {
1621 self.pending_effects
1622 .push_back(Effect::GlobalNotification { type_id });
1623 }
1624 }
1625
1626 pub(crate) fn name_for_view(&self, window_id: usize, view_id: usize) -> Option<&str> {
1627 self.views
1628 .get(&(window_id, view_id))
1629 .map(|view| view.ui_name())
1630 }
1631
1632 pub fn all_action_names<'a>(&'a self) -> impl Iterator<Item = &'static str> + 'a {
1633 self.action_deserializers.keys().copied()
1634 }
1635
1636 pub fn available_actions(
1637 &self,
1638 window_id: usize,
1639 view_id: usize,
1640 ) -> impl Iterator<Item = (&'static str, Box<dyn Action>, SmallVec<[&Binding; 1]>)> {
1641 let mut action_types: HashSet<_> = self.global_actions.keys().copied().collect();
1642
1643 for view_id in self.parents(window_id, view_id) {
1644 if let Some(view) = self.views.get(&(window_id, view_id)) {
1645 let view_type = view.as_any().type_id();
1646 if let Some(actions) = self.actions.get(&view_type) {
1647 action_types.extend(actions.keys().copied());
1648 }
1649 }
1650 }
1651
1652 self.action_deserializers
1653 .iter()
1654 .filter_map(move |(name, (type_id, deserialize))| {
1655 if action_types.contains(type_id) {
1656 Some((
1657 *name,
1658 deserialize("{}").ok()?,
1659 self.keystroke_matcher
1660 .bindings_for_action_type(*type_id)
1661 .collect(),
1662 ))
1663 } else {
1664 None
1665 }
1666 })
1667 }
1668
1669 pub fn is_action_available(&self, action: &dyn Action) -> bool {
1670 let action_type = action.as_any().type_id();
1671 if let Some(window_id) = self.cx.platform.key_window_id() {
1672 if let Some(focused_view_id) = self.focused_view_id(window_id) {
1673 for view_id in self.parents(window_id, focused_view_id) {
1674 if let Some(view) = self.views.get(&(window_id, view_id)) {
1675 let view_type = view.as_any().type_id();
1676 if let Some(actions) = self.actions.get(&view_type) {
1677 if actions.contains_key(&action_type) {
1678 return true;
1679 }
1680 }
1681 }
1682 }
1683 }
1684 }
1685 self.global_actions.contains_key(&action_type)
1686 }
1687
1688 /// Return keystrokes that would dispatch the given action closest to the focused view, if there are any.
1689 pub(crate) fn keystrokes_for_action(
1690 &self,
1691 window_id: usize,
1692 dispatch_path: &[usize],
1693 action: &dyn Action,
1694 ) -> Option<SmallVec<[Keystroke; 2]>> {
1695 for view_id in dispatch_path.iter().rev() {
1696 let view = self
1697 .cx
1698 .views
1699 .get(&(window_id, *view_id))
1700 .expect("view in responder chain does not exist");
1701 let cx = view.keymap_context(self.as_ref());
1702 let keystrokes = self.keystroke_matcher.keystrokes_for_action(action, &cx);
1703 if keystrokes.is_some() {
1704 return keystrokes;
1705 }
1706 }
1707
1708 None
1709 }
1710
1711 // Traverses the parent tree. Walks down the tree toward the passed
1712 // view calling visit with true. Then walks back up the tree calling visit with false.
1713 // If `visit` returns false this function will immediately return.
1714 // Returns a bool indicating if the traversal was completed early.
1715 fn visit_dispatch_path(
1716 &mut self,
1717 window_id: usize,
1718 view_id: usize,
1719 mut visit: impl FnMut(usize, bool, &mut MutableAppContext) -> bool,
1720 ) -> bool {
1721 // List of view ids from the leaf to the root of the window
1722 let path = self.parents(window_id, view_id).collect::<Vec<_>>();
1723
1724 // Walk down from the root to the leaf calling visit with capture_phase = true
1725 for view_id in path.iter().rev() {
1726 if !visit(*view_id, true, self) {
1727 return false;
1728 }
1729 }
1730
1731 // Walk up from the leaf to the root calling visit with capture_phase = false
1732 for view_id in path.iter() {
1733 if !visit(*view_id, false, self) {
1734 return false;
1735 }
1736 }
1737
1738 true
1739 }
1740
1741 // Returns an iterator over all of the view ids from the passed view up to the root of the window
1742 // Includes the passed view itself
1743 fn parents(&self, window_id: usize, mut view_id: usize) -> impl Iterator<Item = usize> + '_ {
1744 std::iter::once(view_id)
1745 .into_iter()
1746 .chain(std::iter::from_fn(move || {
1747 if let Some(ParentId::View(parent_id)) = self.parents.get(&(window_id, view_id)) {
1748 view_id = *parent_id;
1749 Some(view_id)
1750 } else {
1751 None
1752 }
1753 }))
1754 }
1755
1756 fn actions_mut(
1757 &mut self,
1758 capture_phase: bool,
1759 ) -> &mut HashMap<TypeId, HashMap<TypeId, Vec<Box<ActionCallback>>>> {
1760 if capture_phase {
1761 &mut self.capture_actions
1762 } else {
1763 &mut self.actions
1764 }
1765 }
1766
1767 pub fn dispatch_global_action<A: Action>(&mut self, action: A) {
1768 self.dispatch_global_action_any(&action);
1769 }
1770
1771 fn dispatch_global_action_any(&mut self, action: &dyn Action) -> bool {
1772 self.update(|this| {
1773 if let Some((name, mut handler)) = this.global_actions.remove_entry(&action.id()) {
1774 handler(action, this);
1775 this.global_actions.insert(name, handler);
1776 true
1777 } else {
1778 false
1779 }
1780 })
1781 }
1782
1783 pub fn add_bindings<T: IntoIterator<Item = keymap::Binding>>(&mut self, bindings: T) {
1784 self.keystroke_matcher.add_bindings(bindings);
1785 }
1786
1787 pub fn clear_bindings(&mut self) {
1788 self.keystroke_matcher.clear_bindings();
1789 }
1790
1791 pub fn dispatch_keystroke(&mut self, window_id: usize, keystroke: &Keystroke) -> bool {
1792 let mut pending = false;
1793
1794 if let Some(focused_view_id) = self.focused_view_id(window_id) {
1795 for view_id in self.parents(window_id, focused_view_id).collect::<Vec<_>>() {
1796 let keymap_context = self
1797 .cx
1798 .views
1799 .get(&(window_id, view_id))
1800 .unwrap()
1801 .keymap_context(self.as_ref());
1802
1803 match self.keystroke_matcher.push_keystroke(
1804 keystroke.clone(),
1805 view_id,
1806 &keymap_context,
1807 ) {
1808 MatchResult::None => {}
1809 MatchResult::Pending => pending = true,
1810 MatchResult::Action(action) => {
1811 if self.handle_dispatch_action_from_effect(
1812 window_id,
1813 Some(view_id),
1814 action.as_ref(),
1815 ) {
1816 self.keystroke_matcher.clear_pending();
1817 return true;
1818 }
1819 }
1820 }
1821 }
1822 }
1823
1824 pending
1825 }
1826
1827 pub fn default_global<T: 'static + Default>(&mut self) -> &T {
1828 let type_id = TypeId::of::<T>();
1829 self.update(|this| {
1830 if let Entry::Vacant(entry) = this.cx.globals.entry(type_id) {
1831 entry.insert(Box::new(T::default()));
1832 this.notify_global(type_id);
1833 }
1834 });
1835 self.globals.get(&type_id).unwrap().downcast_ref().unwrap()
1836 }
1837
1838 pub fn set_global<T: 'static>(&mut self, state: T) {
1839 self.update(|this| {
1840 let type_id = TypeId::of::<T>();
1841 this.cx.globals.insert(type_id, Box::new(state));
1842 this.notify_global(type_id);
1843 });
1844 }
1845
1846 pub fn update_default_global<T, F, U>(&mut self, update: F) -> U
1847 where
1848 T: 'static + Default,
1849 F: FnOnce(&mut T, &mut MutableAppContext) -> U,
1850 {
1851 self.update(|this| {
1852 let type_id = TypeId::of::<T>();
1853 let mut state = this
1854 .cx
1855 .globals
1856 .remove(&type_id)
1857 .unwrap_or_else(|| Box::new(T::default()));
1858 let result = update(state.downcast_mut().unwrap(), this);
1859 this.cx.globals.insert(type_id, state);
1860 this.notify_global(type_id);
1861 result
1862 })
1863 }
1864
1865 pub fn update_global<T, F, U>(&mut self, update: F) -> U
1866 where
1867 T: 'static,
1868 F: FnOnce(&mut T, &mut MutableAppContext) -> U,
1869 {
1870 self.update(|this| {
1871 let type_id = TypeId::of::<T>();
1872 if let Some(mut state) = this.cx.globals.remove(&type_id) {
1873 let result = update(state.downcast_mut().unwrap(), this);
1874 this.cx.globals.insert(type_id, state);
1875 this.notify_global(type_id);
1876 result
1877 } else {
1878 panic!("No global added for {}", std::any::type_name::<T>());
1879 }
1880 })
1881 }
1882
1883 pub fn add_model<T, F>(&mut self, build_model: F) -> ModelHandle<T>
1884 where
1885 T: Entity,
1886 F: FnOnce(&mut ModelContext<T>) -> T,
1887 {
1888 self.update(|this| {
1889 let model_id = post_inc(&mut this.next_entity_id);
1890 let handle = ModelHandle::new(model_id, &this.cx.ref_counts);
1891 let mut cx = ModelContext::new(this, model_id);
1892 let model = build_model(&mut cx);
1893 this.cx.models.insert(model_id, Box::new(model));
1894 handle
1895 })
1896 }
1897
1898 pub fn add_window<T, F>(
1899 &mut self,
1900 window_options: WindowOptions,
1901 build_root_view: F,
1902 ) -> (usize, ViewHandle<T>)
1903 where
1904 T: View,
1905 F: FnOnce(&mut ViewContext<T>) -> T,
1906 {
1907 self.update(|this| {
1908 let window_id = post_inc(&mut this.next_window_id);
1909 let root_view = this
1910 .build_and_insert_view(window_id, ParentId::Root, |cx| Some(build_root_view(cx)))
1911 .unwrap();
1912 this.cx.windows.insert(
1913 window_id,
1914 Window {
1915 root_view: root_view.clone().into(),
1916 focused_view_id: Some(root_view.id()),
1917 is_active: false,
1918 invalidation: None,
1919 is_fullscreen: false,
1920 },
1921 );
1922 root_view.update(this, |view, cx| view.on_focus_in(cx.handle().into(), cx));
1923 this.open_platform_window(window_id, window_options);
1924
1925 (window_id, root_view)
1926 })
1927 }
1928
1929 // pub fn add_status_bar_item<I, F>(&mut self, build_item: F)
1930 // where
1931 // I: View,
1932 // F: FnOnce(&mut ViewContext<I>) -> I,
1933 // {
1934 // mem::forget(self.platform.add_status_item());
1935 // }
1936
1937 pub fn replace_root_view<T, F>(&mut self, window_id: usize, build_root_view: F) -> ViewHandle<T>
1938 where
1939 T: View,
1940 F: FnOnce(&mut ViewContext<T>) -> T,
1941 {
1942 self.update(|this| {
1943 let root_view = this
1944 .build_and_insert_view(window_id, ParentId::Root, |cx| Some(build_root_view(cx)))
1945 .unwrap();
1946 let window = this.cx.windows.get_mut(&window_id).unwrap();
1947 window.root_view = root_view.clone().into();
1948 window.focused_view_id = Some(root_view.id());
1949 root_view
1950 })
1951 }
1952
1953 pub fn remove_window(&mut self, window_id: usize) {
1954 self.cx.windows.remove(&window_id);
1955 self.presenters_and_platform_windows.remove(&window_id);
1956 self.flush_effects();
1957 }
1958
1959 fn open_platform_window(&mut self, window_id: usize, window_options: WindowOptions) {
1960 let mut window =
1961 self.cx
1962 .platform
1963 .open_window(window_id, window_options, self.foreground.clone());
1964 let presenter = Rc::new(RefCell::new(
1965 self.build_presenter(window_id, window.titlebar_height()),
1966 ));
1967
1968 {
1969 let mut app = self.upgrade();
1970 let presenter = Rc::downgrade(&presenter);
1971 window.on_event(Box::new(move |event| {
1972 app.update(|cx| {
1973 if let Some(presenter) = presenter.upgrade() {
1974 if let Event::KeyDown(KeyDownEvent { keystroke, .. }) = &event {
1975 if cx.dispatch_keystroke(window_id, keystroke) {
1976 return true;
1977 }
1978 }
1979
1980 presenter.borrow_mut().dispatch_event(event, false, cx)
1981 } else {
1982 false
1983 }
1984 })
1985 }));
1986 }
1987
1988 {
1989 let mut app = self.upgrade();
1990 window.on_active_status_change(Box::new(move |is_active| {
1991 app.update(|cx| cx.window_changed_active_status(window_id, is_active))
1992 }));
1993 }
1994
1995 {
1996 let mut app = self.upgrade();
1997 window.on_resize(Box::new(move || {
1998 app.update(|cx| cx.window_was_resized(window_id))
1999 }));
2000 }
2001
2002 {
2003 let mut app = self.upgrade();
2004 window.on_fullscreen(Box::new(move |is_fullscreen| {
2005 app.update(|cx| cx.window_was_fullscreen_changed(window_id, is_fullscreen))
2006 }));
2007 }
2008
2009 {
2010 let mut app = self.upgrade();
2011 window.on_close(Box::new(move || {
2012 app.update(|cx| cx.remove_window(window_id));
2013 }));
2014 }
2015
2016 window.set_input_handler(Box::new(WindowInputHandler {
2017 app: self.upgrade().0,
2018 window_id,
2019 }));
2020
2021 let scene =
2022 presenter
2023 .borrow_mut()
2024 .build_scene(window.size(), window.scale_factor(), false, self);
2025 window.present_scene(scene);
2026 self.presenters_and_platform_windows
2027 .insert(window_id, (presenter.clone(), window));
2028 }
2029
2030 pub fn build_presenter(&mut self, window_id: usize, titlebar_height: f32) -> Presenter {
2031 Presenter::new(
2032 window_id,
2033 titlebar_height,
2034 self.cx.font_cache.clone(),
2035 TextLayoutCache::new(self.cx.platform.fonts()),
2036 self.assets.clone(),
2037 self,
2038 )
2039 }
2040
2041 pub fn add_view<T, F>(
2042 &mut self,
2043 parent_handle: impl Into<AnyViewHandle>,
2044 build_view: F,
2045 ) -> ViewHandle<T>
2046 where
2047 T: View,
2048 F: FnOnce(&mut ViewContext<T>) -> T,
2049 {
2050 let parent_handle = parent_handle.into();
2051 self.build_and_insert_view(
2052 parent_handle.window_id,
2053 ParentId::View(parent_handle.view_id),
2054 |cx| Some(build_view(cx)),
2055 )
2056 .unwrap()
2057 }
2058
2059 pub fn add_option_view<T, F>(
2060 &mut self,
2061 parent_handle: impl Into<AnyViewHandle>,
2062 build_view: F,
2063 ) -> Option<ViewHandle<T>>
2064 where
2065 T: View,
2066 F: FnOnce(&mut ViewContext<T>) -> Option<T>,
2067 {
2068 let parent_handle = parent_handle.into();
2069 self.build_and_insert_view(
2070 parent_handle.window_id,
2071 ParentId::View(parent_handle.view_id),
2072 build_view,
2073 )
2074 }
2075
2076 pub(crate) fn build_and_insert_view<T, F>(
2077 &mut self,
2078 window_id: usize,
2079 parent_id: ParentId,
2080 build_view: F,
2081 ) -> Option<ViewHandle<T>>
2082 where
2083 T: View,
2084 F: FnOnce(&mut ViewContext<T>) -> Option<T>,
2085 {
2086 self.update(|this| {
2087 let view_id = post_inc(&mut this.next_entity_id);
2088 let mut cx = ViewContext::new(this, window_id, view_id);
2089 let handle = if let Some(view) = build_view(&mut cx) {
2090 this.cx.views.insert((window_id, view_id), Box::new(view));
2091 this.cx.parents.insert((window_id, view_id), parent_id);
2092 if let Some(window) = this.cx.windows.get_mut(&window_id) {
2093 window
2094 .invalidation
2095 .get_or_insert_with(Default::default)
2096 .updated
2097 .insert(view_id);
2098 }
2099 Some(ViewHandle::new(window_id, view_id, &this.cx.ref_counts))
2100 } else {
2101 None
2102 };
2103 handle
2104 })
2105 }
2106
2107 fn remove_dropped_entities(&mut self) {
2108 loop {
2109 let (dropped_models, dropped_views, dropped_element_states) =
2110 self.cx.ref_counts.lock().take_dropped();
2111 if dropped_models.is_empty()
2112 && dropped_views.is_empty()
2113 && dropped_element_states.is_empty()
2114 {
2115 break;
2116 }
2117
2118 for model_id in dropped_models {
2119 self.subscriptions.remove(model_id);
2120 self.observations.remove(model_id);
2121 let mut model = self.cx.models.remove(&model_id).unwrap();
2122 model.release(self);
2123 self.pending_effects
2124 .push_back(Effect::ModelRelease { model_id, model });
2125 }
2126
2127 for (window_id, view_id) in dropped_views {
2128 self.subscriptions.remove(view_id);
2129 self.observations.remove(view_id);
2130 let mut view = self.cx.views.remove(&(window_id, view_id)).unwrap();
2131 view.release(self);
2132 let change_focus_to = self.cx.windows.get_mut(&window_id).and_then(|window| {
2133 window
2134 .invalidation
2135 .get_or_insert_with(Default::default)
2136 .removed
2137 .push(view_id);
2138 if window.focused_view_id == Some(view_id) {
2139 Some(window.root_view.id())
2140 } else {
2141 None
2142 }
2143 });
2144 self.cx.parents.remove(&(window_id, view_id));
2145
2146 if let Some(view_id) = change_focus_to {
2147 self.handle_focus_effect(window_id, Some(view_id));
2148 }
2149
2150 self.pending_effects
2151 .push_back(Effect::ViewRelease { view_id, view });
2152 }
2153
2154 for key in dropped_element_states {
2155 self.cx.element_states.remove(&key);
2156 }
2157 }
2158 }
2159
2160 fn flush_effects(&mut self) {
2161 self.pending_flushes = self.pending_flushes.saturating_sub(1);
2162 let mut after_window_update_callbacks = Vec::new();
2163
2164 if !self.flushing_effects && self.pending_flushes == 0 {
2165 self.flushing_effects = true;
2166
2167 let mut refreshing = false;
2168 loop {
2169 if let Some(effect) = self.pending_effects.pop_front() {
2170 if let Some(pending_focus_index) = self.pending_focus_index.as_mut() {
2171 *pending_focus_index = pending_focus_index.saturating_sub(1);
2172 }
2173 match effect {
2174 Effect::Subscription {
2175 entity_id,
2176 subscription_id,
2177 callback,
2178 } => self.subscriptions.add_or_remove_callback(
2179 entity_id,
2180 subscription_id,
2181 callback,
2182 ),
2183
2184 Effect::Event { entity_id, payload } => {
2185 let mut subscriptions = self.subscriptions.clone();
2186 subscriptions.emit_and_cleanup(entity_id, self, |callback, this| {
2187 callback(payload.as_ref(), this)
2188 })
2189 }
2190
2191 Effect::GlobalSubscription {
2192 type_id,
2193 subscription_id,
2194 callback,
2195 } => self.global_subscriptions.add_or_remove_callback(
2196 type_id,
2197 subscription_id,
2198 callback,
2199 ),
2200
2201 Effect::GlobalEvent { payload } => self.emit_global_event(payload),
2202
2203 Effect::Observation {
2204 entity_id,
2205 subscription_id,
2206 callback,
2207 } => self.observations.add_or_remove_callback(
2208 entity_id,
2209 subscription_id,
2210 callback,
2211 ),
2212
2213 Effect::ModelNotification { model_id } => {
2214 let mut observations = self.observations.clone();
2215 observations
2216 .emit_and_cleanup(model_id, self, |callback, this| callback(this));
2217 }
2218
2219 Effect::ViewNotification { window_id, view_id } => {
2220 self.handle_view_notification_effect(window_id, view_id)
2221 }
2222
2223 Effect::GlobalNotification { type_id } => {
2224 let mut subscriptions = self.global_observations.clone();
2225 subscriptions.emit_and_cleanup(type_id, self, |callback, this| {
2226 callback(this);
2227 true
2228 });
2229 }
2230
2231 Effect::Deferred {
2232 callback,
2233 after_window_update,
2234 } => {
2235 if after_window_update {
2236 after_window_update_callbacks.push(callback);
2237 } else {
2238 callback(self)
2239 }
2240 }
2241
2242 Effect::ModelRelease { model_id, model } => {
2243 self.handle_entity_release_effect(model_id, model.as_any())
2244 }
2245
2246 Effect::ViewRelease { view_id, view } => {
2247 self.handle_entity_release_effect(view_id, view.as_any())
2248 }
2249
2250 Effect::Focus { window_id, view_id } => {
2251 self.handle_focus_effect(window_id, view_id);
2252 }
2253
2254 Effect::FocusObservation {
2255 view_id,
2256 subscription_id,
2257 callback,
2258 } => {
2259 self.focus_observations.add_or_remove_callback(
2260 view_id,
2261 subscription_id,
2262 callback,
2263 );
2264 }
2265
2266 Effect::ResizeWindow { window_id } => {
2267 if let Some(window) = self.cx.windows.get_mut(&window_id) {
2268 window
2269 .invalidation
2270 .get_or_insert(WindowInvalidation::default());
2271 }
2272 }
2273
2274 Effect::WindowActivationObservation {
2275 window_id,
2276 subscription_id,
2277 callback,
2278 } => self.window_activation_observations.add_or_remove_callback(
2279 window_id,
2280 subscription_id,
2281 callback,
2282 ),
2283
2284 Effect::ActivateWindow {
2285 window_id,
2286 is_active,
2287 } => self.handle_window_activation_effect(window_id, is_active),
2288
2289 Effect::WindowFullscreenObservation {
2290 window_id,
2291 subscription_id,
2292 callback,
2293 } => self.window_fullscreen_observations.add_or_remove_callback(
2294 window_id,
2295 subscription_id,
2296 callback,
2297 ),
2298
2299 Effect::FullscreenWindow {
2300 window_id,
2301 is_fullscreen,
2302 } => self.handle_fullscreen_effect(window_id, is_fullscreen),
2303
2304 Effect::RefreshWindows => {
2305 refreshing = true;
2306 }
2307 Effect::DispatchActionFrom {
2308 window_id,
2309 view_id,
2310 action,
2311 } => {
2312 self.handle_dispatch_action_from_effect(
2313 window_id,
2314 Some(view_id),
2315 action.as_ref(),
2316 );
2317 }
2318 Effect::ActionDispatchNotification { action_id } => {
2319 self.handle_action_dispatch_notification_effect(action_id)
2320 }
2321 Effect::WindowShouldCloseSubscription {
2322 window_id,
2323 callback,
2324 } => {
2325 self.handle_window_should_close_subscription_effect(window_id, callback)
2326 }
2327 }
2328 self.pending_notifications.clear();
2329 self.remove_dropped_entities();
2330 } else {
2331 self.remove_dropped_entities();
2332 if refreshing {
2333 self.perform_window_refresh();
2334 } else {
2335 self.update_windows();
2336 }
2337
2338 if self.pending_effects.is_empty() {
2339 for callback in after_window_update_callbacks.drain(..) {
2340 callback(self);
2341 }
2342
2343 if self.pending_effects.is_empty() {
2344 self.flushing_effects = false;
2345 self.pending_notifications.clear();
2346 self.pending_global_notifications.clear();
2347 break;
2348 }
2349 }
2350
2351 refreshing = false;
2352 }
2353 }
2354 }
2355 }
2356
2357 fn update_windows(&mut self) {
2358 let mut invalidations: HashMap<_, _> = Default::default();
2359 for (window_id, window) in &mut self.cx.windows {
2360 if let Some(invalidation) = window.invalidation.take() {
2361 invalidations.insert(*window_id, invalidation);
2362 }
2363 }
2364
2365 for (window_id, mut invalidation) in invalidations {
2366 if let Some((presenter, mut window)) =
2367 self.presenters_and_platform_windows.remove(&window_id)
2368 {
2369 {
2370 let mut presenter = presenter.borrow_mut();
2371 presenter.invalidate(&mut invalidation, self);
2372 let scene =
2373 presenter.build_scene(window.size(), window.scale_factor(), false, self);
2374 window.present_scene(scene);
2375 }
2376 self.presenters_and_platform_windows
2377 .insert(window_id, (presenter, window));
2378 }
2379 }
2380 }
2381
2382 fn window_was_resized(&mut self, window_id: usize) {
2383 self.pending_effects
2384 .push_back(Effect::ResizeWindow { window_id });
2385 }
2386
2387 fn window_was_fullscreen_changed(&mut self, window_id: usize, is_fullscreen: bool) {
2388 self.pending_effects.push_back(Effect::FullscreenWindow {
2389 window_id,
2390 is_fullscreen,
2391 });
2392 }
2393
2394 fn window_changed_active_status(&mut self, window_id: usize, is_active: bool) {
2395 self.pending_effects.push_back(Effect::ActivateWindow {
2396 window_id,
2397 is_active,
2398 });
2399 }
2400
2401 pub fn refresh_windows(&mut self) {
2402 self.pending_effects.push_back(Effect::RefreshWindows);
2403 }
2404
2405 pub fn dispatch_action_at(&mut self, window_id: usize, view_id: usize, action: impl Action) {
2406 self.dispatch_any_action_at(window_id, view_id, Box::new(action));
2407 }
2408
2409 pub fn dispatch_any_action_at(
2410 &mut self,
2411 window_id: usize,
2412 view_id: usize,
2413 action: Box<dyn Action>,
2414 ) {
2415 self.pending_effects.push_back(Effect::DispatchActionFrom {
2416 window_id,
2417 view_id,
2418 action,
2419 });
2420 }
2421
2422 fn perform_window_refresh(&mut self) {
2423 let mut presenters = mem::take(&mut self.presenters_and_platform_windows);
2424 for (window_id, (presenter, window)) in &mut presenters {
2425 let mut invalidation = self
2426 .cx
2427 .windows
2428 .get_mut(window_id)
2429 .unwrap()
2430 .invalidation
2431 .take();
2432 let mut presenter = presenter.borrow_mut();
2433 presenter.refresh(
2434 invalidation.as_mut().unwrap_or(&mut Default::default()),
2435 self,
2436 );
2437 let scene = presenter.build_scene(window.size(), window.scale_factor(), true, self);
2438 window.present_scene(scene);
2439 }
2440 self.presenters_and_platform_windows = presenters;
2441 }
2442
2443 fn emit_global_event(&mut self, payload: Box<dyn Any>) {
2444 let type_id = (&*payload).type_id();
2445
2446 let mut subscriptions = self.global_subscriptions.clone();
2447 subscriptions.emit_and_cleanup(type_id, self, |callback, this| {
2448 callback(payload.as_ref(), this);
2449 true //Always alive
2450 });
2451 }
2452
2453 fn handle_view_notification_effect(
2454 &mut self,
2455 observed_window_id: usize,
2456 observed_view_id: usize,
2457 ) {
2458 if self
2459 .cx
2460 .views
2461 .contains_key(&(observed_window_id, observed_view_id))
2462 {
2463 if let Some(window) = self.cx.windows.get_mut(&observed_window_id) {
2464 window
2465 .invalidation
2466 .get_or_insert_with(Default::default)
2467 .updated
2468 .insert(observed_view_id);
2469 }
2470
2471 let mut observations = self.observations.clone();
2472 observations.emit_and_cleanup(observed_view_id, self, |callback, this| callback(this));
2473 }
2474 }
2475
2476 fn handle_entity_release_effect(&mut self, entity_id: usize, entity: &dyn Any) {
2477 let callbacks = self.release_observations.lock().remove(&entity_id);
2478 if let Some(callbacks) = callbacks {
2479 for (_, callback) in callbacks {
2480 callback(entity, self);
2481 }
2482 }
2483 }
2484
2485 fn handle_fullscreen_effect(&mut self, window_id: usize, is_fullscreen: bool) {
2486 //Short circuit evaluation if we're already g2g
2487 if self
2488 .cx
2489 .windows
2490 .get(&window_id)
2491 .map(|w| w.is_fullscreen == is_fullscreen)
2492 .unwrap_or(false)
2493 {
2494 return;
2495 }
2496
2497 self.update(|this| {
2498 let window = this.cx.windows.get_mut(&window_id)?;
2499 window.is_fullscreen = is_fullscreen;
2500
2501 let mut observations = this.window_fullscreen_observations.clone();
2502 observations.emit_and_cleanup(window_id, this, |callback, this| {
2503 callback(is_fullscreen, this)
2504 });
2505
2506 Some(())
2507 });
2508 }
2509
2510 fn handle_window_activation_effect(&mut self, window_id: usize, active: bool) {
2511 //Short circuit evaluation if we're already g2g
2512 if self
2513 .cx
2514 .windows
2515 .get(&window_id)
2516 .map(|w| w.is_active == active)
2517 .unwrap_or(false)
2518 {
2519 return;
2520 }
2521
2522 self.update(|this| {
2523 let window = this.cx.windows.get_mut(&window_id)?;
2524 window.is_active = active;
2525
2526 //Handle focus
2527 let focused_id = window.focused_view_id?;
2528 for view_id in this.parents(window_id, focused_id).collect::<Vec<_>>() {
2529 if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
2530 if active {
2531 view.on_focus_in(this, window_id, view_id, focused_id);
2532 } else {
2533 view.on_focus_out(this, window_id, view_id, focused_id);
2534 }
2535 this.cx.views.insert((window_id, view_id), view);
2536 }
2537 }
2538
2539 let mut observations = this.window_activation_observations.clone();
2540 observations.emit_and_cleanup(window_id, this, |callback, this| callback(active, this));
2541
2542 Some(())
2543 });
2544 }
2545
2546 fn handle_focus_effect(&mut self, window_id: usize, focused_id: Option<usize>) {
2547 self.pending_focus_index.take();
2548
2549 if self
2550 .cx
2551 .windows
2552 .get(&window_id)
2553 .map(|w| w.focused_view_id)
2554 .map_or(false, |cur_focused| cur_focused == focused_id)
2555 {
2556 return;
2557 }
2558
2559 self.update(|this| {
2560 let blurred_id = this.cx.windows.get_mut(&window_id).and_then(|window| {
2561 let blurred_id = window.focused_view_id;
2562 window.focused_view_id = focused_id;
2563 blurred_id
2564 });
2565
2566 let blurred_parents = blurred_id
2567 .map(|blurred_id| this.parents(window_id, blurred_id).collect::<Vec<_>>())
2568 .unwrap_or_default();
2569 let focused_parents = focused_id
2570 .map(|focused_id| this.parents(window_id, focused_id).collect::<Vec<_>>())
2571 .unwrap_or_default();
2572
2573 if let Some(blurred_id) = blurred_id {
2574 for view_id in blurred_parents.iter().copied() {
2575 if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
2576 view.on_focus_out(this, window_id, view_id, blurred_id);
2577 this.cx.views.insert((window_id, view_id), view);
2578 }
2579 }
2580
2581 let mut subscriptions = this.focus_observations.clone();
2582 subscriptions
2583 .emit_and_cleanup(blurred_id, this, |callback, this| callback(false, this));
2584 }
2585
2586 if let Some(focused_id) = focused_id {
2587 for view_id in focused_parents {
2588 if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
2589 view.on_focus_in(this, window_id, view_id, focused_id);
2590 this.cx.views.insert((window_id, view_id), view);
2591 }
2592 }
2593
2594 let mut subscriptions = this.focus_observations.clone();
2595 subscriptions
2596 .emit_and_cleanup(focused_id, this, |callback, this| callback(true, this));
2597 }
2598 })
2599 }
2600
2601 fn handle_dispatch_action_from_effect(
2602 &mut self,
2603 window_id: usize,
2604 view_id: Option<usize>,
2605 action: &dyn Action,
2606 ) -> bool {
2607 self.update(|this| {
2608 if let Some(view_id) = view_id {
2609 this.halt_action_dispatch = false;
2610 this.visit_dispatch_path(window_id, view_id, |view_id, capture_phase, this| {
2611 if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
2612 let type_id = view.as_any().type_id();
2613
2614 if let Some((name, mut handlers)) = this
2615 .actions_mut(capture_phase)
2616 .get_mut(&type_id)
2617 .and_then(|h| h.remove_entry(&action.id()))
2618 {
2619 for handler in handlers.iter_mut().rev() {
2620 this.halt_action_dispatch = true;
2621 handler(view.as_mut(), action, this, window_id, view_id);
2622 if this.halt_action_dispatch {
2623 break;
2624 }
2625 }
2626 this.actions_mut(capture_phase)
2627 .get_mut(&type_id)
2628 .unwrap()
2629 .insert(name, handlers);
2630 }
2631
2632 this.cx.views.insert((window_id, view_id), view);
2633 }
2634
2635 !this.halt_action_dispatch
2636 });
2637 }
2638
2639 if !this.halt_action_dispatch {
2640 this.halt_action_dispatch = this.dispatch_global_action_any(action);
2641 }
2642
2643 this.pending_effects
2644 .push_back(Effect::ActionDispatchNotification {
2645 action_id: action.id(),
2646 });
2647 this.halt_action_dispatch
2648 })
2649 }
2650
2651 fn handle_action_dispatch_notification_effect(&mut self, action_id: TypeId) {
2652 let mut callbacks = mem::take(&mut *self.action_dispatch_observations.lock());
2653 for callback in callbacks.values_mut() {
2654 callback(action_id, self);
2655 }
2656 self.action_dispatch_observations.lock().extend(callbacks);
2657 }
2658
2659 fn handle_window_should_close_subscription_effect(
2660 &mut self,
2661 window_id: usize,
2662 mut callback: WindowShouldCloseSubscriptionCallback,
2663 ) {
2664 let mut app = self.upgrade();
2665 if let Some((_, window)) = self.presenters_and_platform_windows.get_mut(&window_id) {
2666 window.on_should_close(Box::new(move || app.update(|cx| callback(cx))))
2667 }
2668 }
2669
2670 pub fn focus(&mut self, window_id: usize, view_id: Option<usize>) {
2671 if let Some(pending_focus_index) = self.pending_focus_index {
2672 self.pending_effects.remove(pending_focus_index);
2673 }
2674 self.pending_focus_index = Some(self.pending_effects.len());
2675 self.pending_effects
2676 .push_back(Effect::Focus { window_id, view_id });
2677 }
2678
2679 pub fn spawn<F, Fut, T>(&self, f: F) -> Task<T>
2680 where
2681 F: FnOnce(AsyncAppContext) -> Fut,
2682 Fut: 'static + Future<Output = T>,
2683 T: 'static,
2684 {
2685 let future = f(self.to_async());
2686 let cx = self.to_async();
2687 self.foreground.spawn(async move {
2688 let result = future.await;
2689 cx.0.borrow_mut().flush_effects();
2690 result
2691 })
2692 }
2693
2694 pub fn to_async(&self) -> AsyncAppContext {
2695 AsyncAppContext(self.weak_self.as_ref().unwrap().upgrade().unwrap())
2696 }
2697
2698 pub fn write_to_clipboard(&self, item: ClipboardItem) {
2699 self.cx.platform.write_to_clipboard(item);
2700 }
2701
2702 pub fn read_from_clipboard(&self) -> Option<ClipboardItem> {
2703 self.cx.platform.read_from_clipboard()
2704 }
2705
2706 #[cfg(any(test, feature = "test-support"))]
2707 pub fn leak_detector(&self) -> Arc<Mutex<LeakDetector>> {
2708 self.cx.ref_counts.lock().leak_detector.clone()
2709 }
2710}
2711
2712impl ReadModel for MutableAppContext {
2713 fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
2714 if let Some(model) = self.cx.models.get(&handle.model_id) {
2715 model
2716 .as_any()
2717 .downcast_ref()
2718 .expect("downcast is type safe")
2719 } else {
2720 panic!("circular model reference");
2721 }
2722 }
2723}
2724
2725impl UpdateModel for MutableAppContext {
2726 fn update_model<T: Entity, V>(
2727 &mut self,
2728 handle: &ModelHandle<T>,
2729 update: &mut dyn FnMut(&mut T, &mut ModelContext<T>) -> V,
2730 ) -> V {
2731 if let Some(mut model) = self.cx.models.remove(&handle.model_id) {
2732 self.update(|this| {
2733 let mut cx = ModelContext::new(this, handle.model_id);
2734 let result = update(
2735 model
2736 .as_any_mut()
2737 .downcast_mut()
2738 .expect("downcast is type safe"),
2739 &mut cx,
2740 );
2741 this.cx.models.insert(handle.model_id, model);
2742 result
2743 })
2744 } else {
2745 panic!("circular model update");
2746 }
2747 }
2748}
2749
2750impl UpgradeModelHandle for MutableAppContext {
2751 fn upgrade_model_handle<T: Entity>(
2752 &self,
2753 handle: &WeakModelHandle<T>,
2754 ) -> Option<ModelHandle<T>> {
2755 self.cx.upgrade_model_handle(handle)
2756 }
2757
2758 fn model_handle_is_upgradable<T: Entity>(&self, handle: &WeakModelHandle<T>) -> bool {
2759 self.cx.model_handle_is_upgradable(handle)
2760 }
2761
2762 fn upgrade_any_model_handle(&self, handle: &AnyWeakModelHandle) -> Option<AnyModelHandle> {
2763 self.cx.upgrade_any_model_handle(handle)
2764 }
2765}
2766
2767impl UpgradeViewHandle for MutableAppContext {
2768 fn upgrade_view_handle<T: View>(&self, handle: &WeakViewHandle<T>) -> Option<ViewHandle<T>> {
2769 self.cx.upgrade_view_handle(handle)
2770 }
2771
2772 fn upgrade_any_view_handle(&self, handle: &AnyWeakViewHandle) -> Option<AnyViewHandle> {
2773 self.cx.upgrade_any_view_handle(handle)
2774 }
2775}
2776
2777impl ReadView for MutableAppContext {
2778 fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
2779 if let Some(view) = self.cx.views.get(&(handle.window_id, handle.view_id)) {
2780 view.as_any().downcast_ref().expect("downcast is type safe")
2781 } else {
2782 panic!("circular view reference for type {}", type_name::<T>());
2783 }
2784 }
2785}
2786
2787impl UpdateView for MutableAppContext {
2788 fn update_view<T, S>(
2789 &mut self,
2790 handle: &ViewHandle<T>,
2791 update: &mut dyn FnMut(&mut T, &mut ViewContext<T>) -> S,
2792 ) -> S
2793 where
2794 T: View,
2795 {
2796 self.update(|this| {
2797 let mut view = this
2798 .cx
2799 .views
2800 .remove(&(handle.window_id, handle.view_id))
2801 .expect("circular view update");
2802
2803 let mut cx = ViewContext::new(this, handle.window_id, handle.view_id);
2804 let result = update(
2805 view.as_any_mut()
2806 .downcast_mut()
2807 .expect("downcast is type safe"),
2808 &mut cx,
2809 );
2810 this.cx
2811 .views
2812 .insert((handle.window_id, handle.view_id), view);
2813 result
2814 })
2815 }
2816}
2817
2818impl AsRef<AppContext> for MutableAppContext {
2819 fn as_ref(&self) -> &AppContext {
2820 &self.cx
2821 }
2822}
2823
2824impl Deref for MutableAppContext {
2825 type Target = AppContext;
2826
2827 fn deref(&self) -> &Self::Target {
2828 &self.cx
2829 }
2830}
2831
2832#[derive(Debug)]
2833pub enum ParentId {
2834 View(usize),
2835 Root,
2836}
2837
2838pub struct AppContext {
2839 models: HashMap<usize, Box<dyn AnyModel>>,
2840 views: HashMap<(usize, usize), Box<dyn AnyView>>,
2841 pub(crate) parents: HashMap<(usize, usize), ParentId>,
2842 windows: HashMap<usize, Window>,
2843 globals: HashMap<TypeId, Box<dyn Any>>,
2844 element_states: HashMap<ElementStateId, Box<dyn Any>>,
2845 background: Arc<executor::Background>,
2846 ref_counts: Arc<Mutex<RefCounts>>,
2847 font_cache: Arc<FontCache>,
2848 platform: Arc<dyn Platform>,
2849}
2850
2851impl AppContext {
2852 pub(crate) fn root_view(&self, window_id: usize) -> Option<AnyViewHandle> {
2853 self.windows
2854 .get(&window_id)
2855 .map(|window| window.root_view.clone())
2856 }
2857
2858 pub fn root_view_id(&self, window_id: usize) -> Option<usize> {
2859 self.windows
2860 .get(&window_id)
2861 .map(|window| window.root_view.id())
2862 }
2863
2864 pub fn focused_view_id(&self, window_id: usize) -> Option<usize> {
2865 self.windows
2866 .get(&window_id)
2867 .and_then(|window| window.focused_view_id)
2868 }
2869
2870 pub fn background(&self) -> &Arc<executor::Background> {
2871 &self.background
2872 }
2873
2874 pub fn font_cache(&self) -> &Arc<FontCache> {
2875 &self.font_cache
2876 }
2877
2878 pub fn platform(&self) -> &Arc<dyn Platform> {
2879 &self.platform
2880 }
2881
2882 pub fn has_global<T: 'static>(&self) -> bool {
2883 self.globals.contains_key(&TypeId::of::<T>())
2884 }
2885
2886 pub fn global<T: 'static>(&self) -> &T {
2887 if let Some(global) = self.globals.get(&TypeId::of::<T>()) {
2888 global.downcast_ref().unwrap()
2889 } else {
2890 panic!("no global has been added for {}", type_name::<T>());
2891 }
2892 }
2893}
2894
2895impl ReadModel for AppContext {
2896 fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
2897 if let Some(model) = self.models.get(&handle.model_id) {
2898 model
2899 .as_any()
2900 .downcast_ref()
2901 .expect("downcast should be type safe")
2902 } else {
2903 panic!("circular model reference");
2904 }
2905 }
2906}
2907
2908impl UpgradeModelHandle for AppContext {
2909 fn upgrade_model_handle<T: Entity>(
2910 &self,
2911 handle: &WeakModelHandle<T>,
2912 ) -> Option<ModelHandle<T>> {
2913 if self.models.contains_key(&handle.model_id) {
2914 Some(ModelHandle::new(handle.model_id, &self.ref_counts))
2915 } else {
2916 None
2917 }
2918 }
2919
2920 fn model_handle_is_upgradable<T: Entity>(&self, handle: &WeakModelHandle<T>) -> bool {
2921 self.models.contains_key(&handle.model_id)
2922 }
2923
2924 fn upgrade_any_model_handle(&self, handle: &AnyWeakModelHandle) -> Option<AnyModelHandle> {
2925 if self.models.contains_key(&handle.model_id) {
2926 Some(AnyModelHandle::new(
2927 handle.model_id,
2928 handle.model_type,
2929 self.ref_counts.clone(),
2930 ))
2931 } else {
2932 None
2933 }
2934 }
2935}
2936
2937impl UpgradeViewHandle for AppContext {
2938 fn upgrade_view_handle<T: View>(&self, handle: &WeakViewHandle<T>) -> Option<ViewHandle<T>> {
2939 if self.ref_counts.lock().is_entity_alive(handle.view_id) {
2940 Some(ViewHandle::new(
2941 handle.window_id,
2942 handle.view_id,
2943 &self.ref_counts,
2944 ))
2945 } else {
2946 None
2947 }
2948 }
2949
2950 fn upgrade_any_view_handle(&self, handle: &AnyWeakViewHandle) -> Option<AnyViewHandle> {
2951 if self.ref_counts.lock().is_entity_alive(handle.view_id) {
2952 Some(AnyViewHandle::new(
2953 handle.window_id,
2954 handle.view_id,
2955 handle.view_type,
2956 self.ref_counts.clone(),
2957 ))
2958 } else {
2959 None
2960 }
2961 }
2962}
2963
2964impl ReadView for AppContext {
2965 fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
2966 if let Some(view) = self.views.get(&(handle.window_id, handle.view_id)) {
2967 view.as_any()
2968 .downcast_ref()
2969 .expect("downcast should be type safe")
2970 } else {
2971 panic!("circular view reference");
2972 }
2973 }
2974}
2975
2976struct Window {
2977 root_view: AnyViewHandle,
2978 focused_view_id: Option<usize>,
2979 is_active: bool,
2980 is_fullscreen: bool,
2981 invalidation: Option<WindowInvalidation>,
2982}
2983
2984#[derive(Default, Clone)]
2985pub struct WindowInvalidation {
2986 pub updated: HashSet<usize>,
2987 pub removed: Vec<usize>,
2988}
2989
2990pub enum Effect {
2991 Subscription {
2992 entity_id: usize,
2993 subscription_id: usize,
2994 callback: SubscriptionCallback,
2995 },
2996 Event {
2997 entity_id: usize,
2998 payload: Box<dyn Any>,
2999 },
3000 GlobalSubscription {
3001 type_id: TypeId,
3002 subscription_id: usize,
3003 callback: GlobalSubscriptionCallback,
3004 },
3005 GlobalEvent {
3006 payload: Box<dyn Any>,
3007 },
3008 Observation {
3009 entity_id: usize,
3010 subscription_id: usize,
3011 callback: ObservationCallback,
3012 },
3013 ModelNotification {
3014 model_id: usize,
3015 },
3016 ViewNotification {
3017 window_id: usize,
3018 view_id: usize,
3019 },
3020 Deferred {
3021 callback: Box<dyn FnOnce(&mut MutableAppContext)>,
3022 after_window_update: bool,
3023 },
3024 GlobalNotification {
3025 type_id: TypeId,
3026 },
3027 ModelRelease {
3028 model_id: usize,
3029 model: Box<dyn AnyModel>,
3030 },
3031 ViewRelease {
3032 view_id: usize,
3033 view: Box<dyn AnyView>,
3034 },
3035 Focus {
3036 window_id: usize,
3037 view_id: Option<usize>,
3038 },
3039 FocusObservation {
3040 view_id: usize,
3041 subscription_id: usize,
3042 callback: FocusObservationCallback,
3043 },
3044 ResizeWindow {
3045 window_id: usize,
3046 },
3047 FullscreenWindow {
3048 window_id: usize,
3049 is_fullscreen: bool,
3050 },
3051 ActivateWindow {
3052 window_id: usize,
3053 is_active: bool,
3054 },
3055 WindowActivationObservation {
3056 window_id: usize,
3057 subscription_id: usize,
3058 callback: WindowActivationCallback,
3059 },
3060 WindowFullscreenObservation {
3061 window_id: usize,
3062 subscription_id: usize,
3063 callback: WindowFullscreenCallback,
3064 },
3065 RefreshWindows,
3066 DispatchActionFrom {
3067 window_id: usize,
3068 view_id: usize,
3069 action: Box<dyn Action>,
3070 },
3071 ActionDispatchNotification {
3072 action_id: TypeId,
3073 },
3074 WindowShouldCloseSubscription {
3075 window_id: usize,
3076 callback: WindowShouldCloseSubscriptionCallback,
3077 },
3078}
3079
3080impl Debug for Effect {
3081 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3082 match self {
3083 Effect::Subscription {
3084 entity_id,
3085 subscription_id,
3086 ..
3087 } => f
3088 .debug_struct("Effect::Subscribe")
3089 .field("entity_id", entity_id)
3090 .field("subscription_id", subscription_id)
3091 .finish(),
3092 Effect::Event { entity_id, .. } => f
3093 .debug_struct("Effect::Event")
3094 .field("entity_id", entity_id)
3095 .finish(),
3096 Effect::GlobalSubscription {
3097 type_id,
3098 subscription_id,
3099 ..
3100 } => f
3101 .debug_struct("Effect::Subscribe")
3102 .field("type_id", type_id)
3103 .field("subscription_id", subscription_id)
3104 .finish(),
3105 Effect::GlobalEvent { payload, .. } => f
3106 .debug_struct("Effect::GlobalEvent")
3107 .field("type_id", &(&*payload).type_id())
3108 .finish(),
3109 Effect::Observation {
3110 entity_id,
3111 subscription_id,
3112 ..
3113 } => f
3114 .debug_struct("Effect::Observation")
3115 .field("entity_id", entity_id)
3116 .field("subscription_id", subscription_id)
3117 .finish(),
3118 Effect::ModelNotification { model_id } => f
3119 .debug_struct("Effect::ModelNotification")
3120 .field("model_id", model_id)
3121 .finish(),
3122 Effect::ViewNotification { window_id, view_id } => f
3123 .debug_struct("Effect::ViewNotification")
3124 .field("window_id", window_id)
3125 .field("view_id", view_id)
3126 .finish(),
3127 Effect::GlobalNotification { type_id } => f
3128 .debug_struct("Effect::GlobalNotification")
3129 .field("type_id", type_id)
3130 .finish(),
3131 Effect::Deferred { .. } => f.debug_struct("Effect::Deferred").finish(),
3132 Effect::ModelRelease { model_id, .. } => f
3133 .debug_struct("Effect::ModelRelease")
3134 .field("model_id", model_id)
3135 .finish(),
3136 Effect::ViewRelease { view_id, .. } => f
3137 .debug_struct("Effect::ViewRelease")
3138 .field("view_id", view_id)
3139 .finish(),
3140 Effect::Focus { window_id, view_id } => f
3141 .debug_struct("Effect::Focus")
3142 .field("window_id", window_id)
3143 .field("view_id", view_id)
3144 .finish(),
3145 Effect::FocusObservation {
3146 view_id,
3147 subscription_id,
3148 ..
3149 } => f
3150 .debug_struct("Effect::FocusObservation")
3151 .field("view_id", view_id)
3152 .field("subscription_id", subscription_id)
3153 .finish(),
3154 Effect::DispatchActionFrom {
3155 window_id, view_id, ..
3156 } => f
3157 .debug_struct("Effect::DispatchActionFrom")
3158 .field("window_id", window_id)
3159 .field("view_id", view_id)
3160 .finish(),
3161 Effect::ActionDispatchNotification { action_id, .. } => f
3162 .debug_struct("Effect::ActionDispatchNotification")
3163 .field("action_id", action_id)
3164 .finish(),
3165 Effect::ResizeWindow { window_id } => f
3166 .debug_struct("Effect::RefreshWindow")
3167 .field("window_id", window_id)
3168 .finish(),
3169 Effect::WindowActivationObservation {
3170 window_id,
3171 subscription_id,
3172 ..
3173 } => f
3174 .debug_struct("Effect::WindowActivationObservation")
3175 .field("window_id", window_id)
3176 .field("subscription_id", subscription_id)
3177 .finish(),
3178 Effect::ActivateWindow {
3179 window_id,
3180 is_active,
3181 } => f
3182 .debug_struct("Effect::ActivateWindow")
3183 .field("window_id", window_id)
3184 .field("is_active", is_active)
3185 .finish(),
3186 Effect::FullscreenWindow {
3187 window_id,
3188 is_fullscreen,
3189 } => f
3190 .debug_struct("Effect::FullscreenWindow")
3191 .field("window_id", window_id)
3192 .field("is_fullscreen", is_fullscreen)
3193 .finish(),
3194 Effect::WindowFullscreenObservation {
3195 window_id,
3196 subscription_id,
3197 callback: _,
3198 } => f
3199 .debug_struct("Effect::WindowFullscreenObservation")
3200 .field("window_id", window_id)
3201 .field("subscription_id", subscription_id)
3202 .finish(),
3203 Effect::RefreshWindows => f.debug_struct("Effect::FullViewRefresh").finish(),
3204 Effect::WindowShouldCloseSubscription { window_id, .. } => f
3205 .debug_struct("Effect::WindowShouldCloseSubscription")
3206 .field("window_id", window_id)
3207 .finish(),
3208 }
3209 }
3210}
3211
3212pub trait AnyModel {
3213 fn as_any(&self) -> &dyn Any;
3214 fn as_any_mut(&mut self) -> &mut dyn Any;
3215 fn release(&mut self, cx: &mut MutableAppContext);
3216 fn app_will_quit(
3217 &mut self,
3218 cx: &mut MutableAppContext,
3219 ) -> Option<Pin<Box<dyn 'static + Future<Output = ()>>>>;
3220}
3221
3222impl<T> AnyModel for T
3223where
3224 T: Entity,
3225{
3226 fn as_any(&self) -> &dyn Any {
3227 self
3228 }
3229
3230 fn as_any_mut(&mut self) -> &mut dyn Any {
3231 self
3232 }
3233
3234 fn release(&mut self, cx: &mut MutableAppContext) {
3235 self.release(cx);
3236 }
3237
3238 fn app_will_quit(
3239 &mut self,
3240 cx: &mut MutableAppContext,
3241 ) -> Option<Pin<Box<dyn 'static + Future<Output = ()>>>> {
3242 self.app_will_quit(cx)
3243 }
3244}
3245
3246pub trait AnyView {
3247 fn as_any(&self) -> &dyn Any;
3248 fn as_any_mut(&mut self) -> &mut dyn Any;
3249 fn release(&mut self, cx: &mut MutableAppContext);
3250 fn app_will_quit(
3251 &mut self,
3252 cx: &mut MutableAppContext,
3253 ) -> Option<Pin<Box<dyn 'static + Future<Output = ()>>>>;
3254 fn ui_name(&self) -> &'static str;
3255 fn render(&mut self, params: RenderParams, cx: &mut MutableAppContext) -> ElementBox;
3256 fn on_focus_in(
3257 &mut self,
3258 cx: &mut MutableAppContext,
3259 window_id: usize,
3260 view_id: usize,
3261 focused_id: usize,
3262 );
3263 fn on_focus_out(
3264 &mut self,
3265 cx: &mut MutableAppContext,
3266 window_id: usize,
3267 view_id: usize,
3268 focused_id: usize,
3269 );
3270 fn keymap_context(&self, cx: &AppContext) -> keymap::Context;
3271 fn debug_json(&self, cx: &AppContext) -> serde_json::Value;
3272
3273 fn text_for_range(&self, range: Range<usize>, cx: &AppContext) -> Option<String>;
3274 fn selected_text_range(&self, cx: &AppContext) -> Option<Range<usize>>;
3275 fn marked_text_range(&self, cx: &AppContext) -> Option<Range<usize>>;
3276 fn unmark_text(&mut self, cx: &mut MutableAppContext, window_id: usize, view_id: usize);
3277 fn replace_text_in_range(
3278 &mut self,
3279 range: Option<Range<usize>>,
3280 text: &str,
3281 cx: &mut MutableAppContext,
3282 window_id: usize,
3283 view_id: usize,
3284 );
3285 fn replace_and_mark_text_in_range(
3286 &mut self,
3287 range: Option<Range<usize>>,
3288 new_text: &str,
3289 new_selected_range: Option<Range<usize>>,
3290 cx: &mut MutableAppContext,
3291 window_id: usize,
3292 view_id: usize,
3293 );
3294 fn any_handle(&self, window_id: usize, view_id: usize, cx: &AppContext) -> AnyViewHandle {
3295 AnyViewHandle::new(
3296 window_id,
3297 view_id,
3298 self.as_any().type_id(),
3299 cx.ref_counts.clone(),
3300 )
3301 }
3302}
3303
3304impl<T> AnyView for T
3305where
3306 T: View,
3307{
3308 fn as_any(&self) -> &dyn Any {
3309 self
3310 }
3311
3312 fn as_any_mut(&mut self) -> &mut dyn Any {
3313 self
3314 }
3315
3316 fn release(&mut self, cx: &mut MutableAppContext) {
3317 self.release(cx);
3318 }
3319
3320 fn app_will_quit(
3321 &mut self,
3322 cx: &mut MutableAppContext,
3323 ) -> Option<Pin<Box<dyn 'static + Future<Output = ()>>>> {
3324 self.app_will_quit(cx)
3325 }
3326
3327 fn ui_name(&self) -> &'static str {
3328 T::ui_name()
3329 }
3330
3331 fn render(&mut self, params: RenderParams, cx: &mut MutableAppContext) -> ElementBox {
3332 View::render(self, &mut RenderContext::new(params, cx))
3333 }
3334
3335 fn on_focus_in(
3336 &mut self,
3337 cx: &mut MutableAppContext,
3338 window_id: usize,
3339 view_id: usize,
3340 focused_id: usize,
3341 ) {
3342 let mut cx = ViewContext::new(cx, window_id, view_id);
3343 let focused_view_handle: AnyViewHandle = if view_id == focused_id {
3344 cx.handle().into()
3345 } else {
3346 let focused_type = cx
3347 .views
3348 .get(&(window_id, focused_id))
3349 .unwrap()
3350 .as_any()
3351 .type_id();
3352 AnyViewHandle::new(window_id, focused_id, focused_type, cx.ref_counts.clone())
3353 };
3354 View::on_focus_in(self, focused_view_handle, &mut cx);
3355 }
3356
3357 fn on_focus_out(
3358 &mut self,
3359 cx: &mut MutableAppContext,
3360 window_id: usize,
3361 view_id: usize,
3362 blurred_id: usize,
3363 ) {
3364 let mut cx = ViewContext::new(cx, window_id, view_id);
3365 let blurred_view_handle: AnyViewHandle = if view_id == blurred_id {
3366 cx.handle().into()
3367 } else {
3368 let blurred_type = cx
3369 .views
3370 .get(&(window_id, blurred_id))
3371 .unwrap()
3372 .as_any()
3373 .type_id();
3374 AnyViewHandle::new(window_id, blurred_id, blurred_type, cx.ref_counts.clone())
3375 };
3376 View::on_focus_out(self, blurred_view_handle, &mut cx);
3377 }
3378
3379 fn keymap_context(&self, cx: &AppContext) -> keymap::Context {
3380 View::keymap_context(self, cx)
3381 }
3382
3383 fn debug_json(&self, cx: &AppContext) -> serde_json::Value {
3384 View::debug_json(self, cx)
3385 }
3386
3387 fn text_for_range(&self, range: Range<usize>, cx: &AppContext) -> Option<String> {
3388 View::text_for_range(self, range, cx)
3389 }
3390
3391 fn selected_text_range(&self, cx: &AppContext) -> Option<Range<usize>> {
3392 View::selected_text_range(self, cx)
3393 }
3394
3395 fn marked_text_range(&self, cx: &AppContext) -> Option<Range<usize>> {
3396 View::marked_text_range(self, cx)
3397 }
3398
3399 fn unmark_text(&mut self, cx: &mut MutableAppContext, window_id: usize, view_id: usize) {
3400 let mut cx = ViewContext::new(cx, window_id, view_id);
3401 View::unmark_text(self, &mut cx)
3402 }
3403
3404 fn replace_text_in_range(
3405 &mut self,
3406 range: Option<Range<usize>>,
3407 text: &str,
3408 cx: &mut MutableAppContext,
3409 window_id: usize,
3410 view_id: usize,
3411 ) {
3412 let mut cx = ViewContext::new(cx, window_id, view_id);
3413 View::replace_text_in_range(self, range, text, &mut cx)
3414 }
3415
3416 fn replace_and_mark_text_in_range(
3417 &mut self,
3418 range: Option<Range<usize>>,
3419 new_text: &str,
3420 new_selected_range: Option<Range<usize>>,
3421 cx: &mut MutableAppContext,
3422 window_id: usize,
3423 view_id: usize,
3424 ) {
3425 let mut cx = ViewContext::new(cx, window_id, view_id);
3426 View::replace_and_mark_text_in_range(self, range, new_text, new_selected_range, &mut cx)
3427 }
3428}
3429
3430pub struct ModelContext<'a, T: ?Sized> {
3431 app: &'a mut MutableAppContext,
3432 model_id: usize,
3433 model_type: PhantomData<T>,
3434 halt_stream: bool,
3435}
3436
3437impl<'a, T: Entity> ModelContext<'a, T> {
3438 fn new(app: &'a mut MutableAppContext, model_id: usize) -> Self {
3439 Self {
3440 app,
3441 model_id,
3442 model_type: PhantomData,
3443 halt_stream: false,
3444 }
3445 }
3446
3447 pub fn background(&self) -> &Arc<executor::Background> {
3448 &self.app.cx.background
3449 }
3450
3451 pub fn halt_stream(&mut self) {
3452 self.halt_stream = true;
3453 }
3454
3455 pub fn model_id(&self) -> usize {
3456 self.model_id
3457 }
3458
3459 pub fn add_model<S, F>(&mut self, build_model: F) -> ModelHandle<S>
3460 where
3461 S: Entity,
3462 F: FnOnce(&mut ModelContext<S>) -> S,
3463 {
3464 self.app.add_model(build_model)
3465 }
3466
3467 pub fn defer(&mut self, callback: impl 'static + FnOnce(&mut T, &mut ModelContext<T>)) {
3468 let handle = self.handle();
3469 self.app.defer(move |cx| {
3470 handle.update(cx, |model, cx| {
3471 callback(model, cx);
3472 })
3473 })
3474 }
3475
3476 pub fn emit(&mut self, payload: T::Event) {
3477 self.app.pending_effects.push_back(Effect::Event {
3478 entity_id: self.model_id,
3479 payload: Box::new(payload),
3480 });
3481 }
3482
3483 pub fn notify(&mut self) {
3484 self.app.notify_model(self.model_id);
3485 }
3486
3487 pub fn subscribe<S: Entity, F>(
3488 &mut self,
3489 handle: &ModelHandle<S>,
3490 mut callback: F,
3491 ) -> Subscription
3492 where
3493 S::Event: 'static,
3494 F: 'static + FnMut(&mut T, ModelHandle<S>, &S::Event, &mut ModelContext<T>),
3495 {
3496 let subscriber = self.weak_handle();
3497 self.app
3498 .subscribe_internal(handle, move |emitter, event, cx| {
3499 if let Some(subscriber) = subscriber.upgrade(cx) {
3500 subscriber.update(cx, |subscriber, cx| {
3501 callback(subscriber, emitter, event, cx);
3502 });
3503 true
3504 } else {
3505 false
3506 }
3507 })
3508 }
3509
3510 pub fn observe<S, F>(&mut self, handle: &ModelHandle<S>, mut callback: F) -> Subscription
3511 where
3512 S: Entity,
3513 F: 'static + FnMut(&mut T, ModelHandle<S>, &mut ModelContext<T>),
3514 {
3515 let observer = self.weak_handle();
3516 self.app.observe_internal(handle, move |observed, cx| {
3517 if let Some(observer) = observer.upgrade(cx) {
3518 observer.update(cx, |observer, cx| {
3519 callback(observer, observed, cx);
3520 });
3521 true
3522 } else {
3523 false
3524 }
3525 })
3526 }
3527
3528 pub fn observe_global<G, F>(&mut self, mut callback: F) -> Subscription
3529 where
3530 G: Any,
3531 F: 'static + FnMut(&mut T, &mut ModelContext<T>),
3532 {
3533 let observer = self.weak_handle();
3534 self.app.observe_global::<G, _>(move |cx| {
3535 if let Some(observer) = observer.upgrade(cx) {
3536 observer.update(cx, |observer, cx| callback(observer, cx));
3537 }
3538 })
3539 }
3540
3541 pub fn observe_release<S, F>(
3542 &mut self,
3543 handle: &ModelHandle<S>,
3544 mut callback: F,
3545 ) -> Subscription
3546 where
3547 S: Entity,
3548 F: 'static + FnMut(&mut T, &S, &mut ModelContext<T>),
3549 {
3550 let observer = self.weak_handle();
3551 self.app.observe_release(handle, move |released, cx| {
3552 if let Some(observer) = observer.upgrade(cx) {
3553 observer.update(cx, |observer, cx| {
3554 callback(observer, released, cx);
3555 });
3556 }
3557 })
3558 }
3559
3560 pub fn handle(&self) -> ModelHandle<T> {
3561 ModelHandle::new(self.model_id, &self.app.cx.ref_counts)
3562 }
3563
3564 pub fn weak_handle(&self) -> WeakModelHandle<T> {
3565 WeakModelHandle::new(self.model_id)
3566 }
3567
3568 pub fn spawn<F, Fut, S>(&self, f: F) -> Task<S>
3569 where
3570 F: FnOnce(ModelHandle<T>, AsyncAppContext) -> Fut,
3571 Fut: 'static + Future<Output = S>,
3572 S: 'static,
3573 {
3574 let handle = self.handle();
3575 self.app.spawn(|cx| f(handle, cx))
3576 }
3577
3578 pub fn spawn_weak<F, Fut, S>(&self, f: F) -> Task<S>
3579 where
3580 F: FnOnce(WeakModelHandle<T>, AsyncAppContext) -> Fut,
3581 Fut: 'static + Future<Output = S>,
3582 S: 'static,
3583 {
3584 let handle = self.weak_handle();
3585 self.app.spawn(|cx| f(handle, cx))
3586 }
3587}
3588
3589impl<M> AsRef<AppContext> for ModelContext<'_, M> {
3590 fn as_ref(&self) -> &AppContext {
3591 &self.app.cx
3592 }
3593}
3594
3595impl<M> AsMut<MutableAppContext> for ModelContext<'_, M> {
3596 fn as_mut(&mut self) -> &mut MutableAppContext {
3597 self.app
3598 }
3599}
3600
3601impl<M> ReadModel for ModelContext<'_, M> {
3602 fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
3603 self.app.read_model(handle)
3604 }
3605}
3606
3607impl<M> UpdateModel for ModelContext<'_, M> {
3608 fn update_model<T: Entity, V>(
3609 &mut self,
3610 handle: &ModelHandle<T>,
3611 update: &mut dyn FnMut(&mut T, &mut ModelContext<T>) -> V,
3612 ) -> V {
3613 self.app.update_model(handle, update)
3614 }
3615}
3616
3617impl<M> UpgradeModelHandle for ModelContext<'_, M> {
3618 fn upgrade_model_handle<T: Entity>(
3619 &self,
3620 handle: &WeakModelHandle<T>,
3621 ) -> Option<ModelHandle<T>> {
3622 self.cx.upgrade_model_handle(handle)
3623 }
3624
3625 fn model_handle_is_upgradable<T: Entity>(&self, handle: &WeakModelHandle<T>) -> bool {
3626 self.cx.model_handle_is_upgradable(handle)
3627 }
3628
3629 fn upgrade_any_model_handle(&self, handle: &AnyWeakModelHandle) -> Option<AnyModelHandle> {
3630 self.cx.upgrade_any_model_handle(handle)
3631 }
3632}
3633
3634impl<M> Deref for ModelContext<'_, M> {
3635 type Target = MutableAppContext;
3636
3637 fn deref(&self) -> &Self::Target {
3638 self.app
3639 }
3640}
3641
3642impl<M> DerefMut for ModelContext<'_, M> {
3643 fn deref_mut(&mut self) -> &mut Self::Target {
3644 &mut self.app
3645 }
3646}
3647
3648pub struct ViewContext<'a, T: ?Sized> {
3649 app: &'a mut MutableAppContext,
3650 window_id: usize,
3651 view_id: usize,
3652 view_type: PhantomData<T>,
3653}
3654
3655impl<'a, T: View> ViewContext<'a, T> {
3656 fn new(app: &'a mut MutableAppContext, window_id: usize, view_id: usize) -> Self {
3657 Self {
3658 app,
3659 window_id,
3660 view_id,
3661 view_type: PhantomData,
3662 }
3663 }
3664
3665 pub fn handle(&self) -> ViewHandle<T> {
3666 ViewHandle::new(self.window_id, self.view_id, &self.app.cx.ref_counts)
3667 }
3668
3669 pub fn weak_handle(&self) -> WeakViewHandle<T> {
3670 WeakViewHandle::new(self.window_id, self.view_id)
3671 }
3672
3673 pub fn window_id(&self) -> usize {
3674 self.window_id
3675 }
3676
3677 pub fn view_id(&self) -> usize {
3678 self.view_id
3679 }
3680
3681 pub fn foreground(&self) -> &Rc<executor::Foreground> {
3682 self.app.foreground()
3683 }
3684
3685 pub fn background_executor(&self) -> &Arc<executor::Background> {
3686 &self.app.cx.background
3687 }
3688
3689 pub fn platform(&self) -> Arc<dyn Platform> {
3690 self.app.platform()
3691 }
3692
3693 pub fn show_character_palette(&self) {
3694 self.app.show_character_palette(self.window_id);
3695 }
3696
3697 pub fn minimize_window(&self) {
3698 self.app.minimize_window(self.window_id)
3699 }
3700
3701 pub fn zoom_window(&self) {
3702 self.app.zoom_window(self.window_id)
3703 }
3704
3705 pub fn toggle_full_screen(&self) {
3706 self.app.toggle_window_full_screen(self.window_id)
3707 }
3708
3709 pub fn prompt(
3710 &self,
3711 level: PromptLevel,
3712 msg: &str,
3713 answers: &[&str],
3714 ) -> oneshot::Receiver<usize> {
3715 self.app.prompt(self.window_id, level, msg, answers)
3716 }
3717
3718 pub fn prompt_for_paths(
3719 &self,
3720 options: PathPromptOptions,
3721 ) -> oneshot::Receiver<Option<Vec<PathBuf>>> {
3722 self.app.prompt_for_paths(options)
3723 }
3724
3725 pub fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Option<PathBuf>> {
3726 self.app.prompt_for_new_path(directory)
3727 }
3728
3729 pub fn debug_elements(&self) -> crate::json::Value {
3730 self.app.debug_elements(self.window_id).unwrap()
3731 }
3732
3733 pub fn focus<S>(&mut self, handle: S)
3734 where
3735 S: Into<AnyViewHandle>,
3736 {
3737 let handle = handle.into();
3738 self.app.focus(handle.window_id, Some(handle.view_id));
3739 }
3740
3741 pub fn focus_self(&mut self) {
3742 self.app.focus(self.window_id, Some(self.view_id));
3743 }
3744
3745 pub fn is_self_focused(&self) -> bool {
3746 self.app.focused_view_id(self.window_id) == Some(self.view_id)
3747 }
3748
3749 pub fn blur(&mut self) {
3750 self.app.focus(self.window_id, None);
3751 }
3752
3753 pub fn set_window_title(&mut self, title: &str) {
3754 let window_id = self.window_id();
3755 if let Some((_, window)) = self.presenters_and_platform_windows.get_mut(&window_id) {
3756 window.set_title(title);
3757 }
3758 }
3759
3760 pub fn set_window_edited(&mut self, edited: bool) {
3761 let window_id = self.window_id();
3762 if let Some((_, window)) = self.presenters_and_platform_windows.get_mut(&window_id) {
3763 window.set_edited(edited);
3764 }
3765 }
3766
3767 pub fn on_window_should_close<F>(&mut self, mut callback: F)
3768 where
3769 F: 'static + FnMut(&mut T, &mut ViewContext<T>) -> bool,
3770 {
3771 let window_id = self.window_id();
3772 let view = self.weak_handle();
3773 self.pending_effects
3774 .push_back(Effect::WindowShouldCloseSubscription {
3775 window_id,
3776 callback: Box::new(move |cx| {
3777 if let Some(view) = view.upgrade(cx) {
3778 view.update(cx, |view, cx| callback(view, cx))
3779 } else {
3780 true
3781 }
3782 }),
3783 });
3784 }
3785
3786 pub fn add_model<S, F>(&mut self, build_model: F) -> ModelHandle<S>
3787 where
3788 S: Entity,
3789 F: FnOnce(&mut ModelContext<S>) -> S,
3790 {
3791 self.app.add_model(build_model)
3792 }
3793
3794 pub fn add_view<S, F>(&mut self, build_view: F) -> ViewHandle<S>
3795 where
3796 S: View,
3797 F: FnOnce(&mut ViewContext<S>) -> S,
3798 {
3799 self.app
3800 .build_and_insert_view(self.window_id, ParentId::View(self.view_id), |cx| {
3801 Some(build_view(cx))
3802 })
3803 .unwrap()
3804 }
3805
3806 pub fn add_option_view<S, F>(&mut self, build_view: F) -> Option<ViewHandle<S>>
3807 where
3808 S: View,
3809 F: FnOnce(&mut ViewContext<S>) -> Option<S>,
3810 {
3811 self.app
3812 .build_and_insert_view(self.window_id, ParentId::View(self.view_id), build_view)
3813 }
3814
3815 pub fn reparent(&mut self, view_handle: impl Into<AnyViewHandle>) {
3816 let view_handle = view_handle.into();
3817 if self.window_id != view_handle.window_id {
3818 panic!("Can't reparent view to a view from a different window");
3819 }
3820 self.cx
3821 .parents
3822 .remove(&(view_handle.window_id, view_handle.view_id));
3823 let new_parent_id = self.view_id;
3824 self.cx.parents.insert(
3825 (view_handle.window_id, view_handle.view_id),
3826 ParentId::View(new_parent_id),
3827 );
3828 }
3829
3830 pub fn replace_root_view<V, F>(&mut self, build_root_view: F) -> ViewHandle<V>
3831 where
3832 V: View,
3833 F: FnOnce(&mut ViewContext<V>) -> V,
3834 {
3835 let window_id = self.window_id;
3836 self.update(|this| {
3837 let root_view = this
3838 .build_and_insert_view(window_id, ParentId::Root, |cx| Some(build_root_view(cx)))
3839 .unwrap();
3840 let window = this.cx.windows.get_mut(&window_id).unwrap();
3841 window.root_view = root_view.clone().into();
3842 window.focused_view_id = Some(root_view.id());
3843 root_view
3844 })
3845 }
3846
3847 pub fn subscribe<E, H, F>(&mut self, handle: &H, mut callback: F) -> Subscription
3848 where
3849 E: Entity,
3850 E::Event: 'static,
3851 H: Handle<E>,
3852 F: 'static + FnMut(&mut T, H, &E::Event, &mut ViewContext<T>),
3853 {
3854 let subscriber = self.weak_handle();
3855 self.app
3856 .subscribe_internal(handle, move |emitter, event, cx| {
3857 if let Some(subscriber) = subscriber.upgrade(cx) {
3858 subscriber.update(cx, |subscriber, cx| {
3859 callback(subscriber, emitter, event, cx);
3860 });
3861 true
3862 } else {
3863 false
3864 }
3865 })
3866 }
3867
3868 pub fn observe<E, F, H>(&mut self, handle: &H, mut callback: F) -> Subscription
3869 where
3870 E: Entity,
3871 H: Handle<E>,
3872 F: 'static + FnMut(&mut T, H, &mut ViewContext<T>),
3873 {
3874 let observer = self.weak_handle();
3875 self.app.observe_internal(handle, move |observed, cx| {
3876 if let Some(observer) = observer.upgrade(cx) {
3877 observer.update(cx, |observer, cx| {
3878 callback(observer, observed, cx);
3879 });
3880 true
3881 } else {
3882 false
3883 }
3884 })
3885 }
3886
3887 pub fn observe_focus<F, V>(&mut self, handle: &ViewHandle<V>, mut callback: F) -> Subscription
3888 where
3889 F: 'static + FnMut(&mut T, ViewHandle<V>, bool, &mut ViewContext<T>),
3890 V: View,
3891 {
3892 let observer = self.weak_handle();
3893 self.app
3894 .observe_focus(handle, move |observed, focused, cx| {
3895 if let Some(observer) = observer.upgrade(cx) {
3896 observer.update(cx, |observer, cx| {
3897 callback(observer, observed, focused, cx);
3898 });
3899 true
3900 } else {
3901 false
3902 }
3903 })
3904 }
3905
3906 pub fn observe_release<E, F, H>(&mut self, handle: &H, mut callback: F) -> Subscription
3907 where
3908 E: Entity,
3909 H: Handle<E>,
3910 F: 'static + FnMut(&mut T, &E, &mut ViewContext<T>),
3911 {
3912 let observer = self.weak_handle();
3913 self.app.observe_release(handle, move |released, cx| {
3914 if let Some(observer) = observer.upgrade(cx) {
3915 observer.update(cx, |observer, cx| {
3916 callback(observer, released, cx);
3917 });
3918 }
3919 })
3920 }
3921
3922 pub fn observe_actions<F>(&mut self, mut callback: F) -> Subscription
3923 where
3924 F: 'static + FnMut(&mut T, TypeId, &mut ViewContext<T>),
3925 {
3926 let observer = self.weak_handle();
3927 self.app.observe_actions(move |action_id, cx| {
3928 if let Some(observer) = observer.upgrade(cx) {
3929 observer.update(cx, |observer, cx| {
3930 callback(observer, action_id, cx);
3931 });
3932 }
3933 })
3934 }
3935
3936 pub fn observe_window_activation<F>(&mut self, mut callback: F) -> Subscription
3937 where
3938 F: 'static + FnMut(&mut T, bool, &mut ViewContext<T>),
3939 {
3940 let observer = self.weak_handle();
3941 self.app
3942 .observe_window_activation(self.window_id(), move |active, cx| {
3943 if let Some(observer) = observer.upgrade(cx) {
3944 observer.update(cx, |observer, cx| {
3945 callback(observer, active, cx);
3946 });
3947 true
3948 } else {
3949 false
3950 }
3951 })
3952 }
3953
3954 pub fn observe_fullscreen<F>(&mut self, mut callback: F) -> Subscription
3955 where
3956 F: 'static + FnMut(&mut T, bool, &mut ViewContext<T>),
3957 {
3958 let observer = self.weak_handle();
3959 self.app
3960 .observe_fullscreen(self.window_id(), move |active, cx| {
3961 if let Some(observer) = observer.upgrade(cx) {
3962 observer.update(cx, |observer, cx| {
3963 callback(observer, active, cx);
3964 });
3965 true
3966 } else {
3967 false
3968 }
3969 })
3970 }
3971
3972 pub fn emit(&mut self, payload: T::Event) {
3973 self.app.pending_effects.push_back(Effect::Event {
3974 entity_id: self.view_id,
3975 payload: Box::new(payload),
3976 });
3977 }
3978
3979 pub fn notify(&mut self) {
3980 self.app.notify_view(self.window_id, self.view_id);
3981 }
3982
3983 pub fn dispatch_any_action(&mut self, action: Box<dyn Action>) {
3984 self.app
3985 .dispatch_any_action_at(self.window_id, self.view_id, action)
3986 }
3987
3988 pub fn defer(&mut self, callback: impl 'static + FnOnce(&mut T, &mut ViewContext<T>)) {
3989 let handle = self.handle();
3990 self.app.defer(move |cx| {
3991 handle.update(cx, |view, cx| {
3992 callback(view, cx);
3993 })
3994 })
3995 }
3996
3997 pub fn after_window_update(
3998 &mut self,
3999 callback: impl 'static + FnOnce(&mut T, &mut ViewContext<T>),
4000 ) {
4001 let handle = self.handle();
4002 self.app.after_window_update(move |cx| {
4003 handle.update(cx, |view, cx| {
4004 callback(view, cx);
4005 })
4006 })
4007 }
4008
4009 pub fn propagate_action(&mut self) {
4010 self.app.halt_action_dispatch = false;
4011 }
4012
4013 pub fn spawn<F, Fut, S>(&self, f: F) -> Task<S>
4014 where
4015 F: FnOnce(ViewHandle<T>, AsyncAppContext) -> Fut,
4016 Fut: 'static + Future<Output = S>,
4017 S: 'static,
4018 {
4019 let handle = self.handle();
4020 self.app.spawn(|cx| f(handle, cx))
4021 }
4022
4023 pub fn spawn_weak<F, Fut, S>(&self, f: F) -> Task<S>
4024 where
4025 F: FnOnce(WeakViewHandle<T>, AsyncAppContext) -> Fut,
4026 Fut: 'static + Future<Output = S>,
4027 S: 'static,
4028 {
4029 let handle = self.weak_handle();
4030 self.app.spawn(|cx| f(handle, cx))
4031 }
4032}
4033
4034pub struct RenderParams {
4035 pub window_id: usize,
4036 pub view_id: usize,
4037 pub titlebar_height: f32,
4038 pub hovered_region_ids: HashSet<MouseRegionId>,
4039 pub clicked_region_ids: Option<(Vec<MouseRegionId>, MouseButton)>,
4040 pub refreshing: bool,
4041}
4042
4043pub struct RenderContext<'a, T: View> {
4044 pub(crate) window_id: usize,
4045 pub(crate) view_id: usize,
4046 pub(crate) view_type: PhantomData<T>,
4047 pub(crate) hovered_region_ids: HashSet<MouseRegionId>,
4048 pub(crate) clicked_region_ids: Option<(Vec<MouseRegionId>, MouseButton)>,
4049 pub app: &'a mut MutableAppContext,
4050 pub titlebar_height: f32,
4051 pub refreshing: bool,
4052}
4053
4054#[derive(Clone, Copy, Default)]
4055pub struct MouseState {
4056 pub hovered: bool,
4057 pub clicked: Option<MouseButton>,
4058}
4059
4060impl<'a, V: View> RenderContext<'a, V> {
4061 fn new(params: RenderParams, app: &'a mut MutableAppContext) -> Self {
4062 Self {
4063 app,
4064 window_id: params.window_id,
4065 view_id: params.view_id,
4066 view_type: PhantomData,
4067 titlebar_height: params.titlebar_height,
4068 hovered_region_ids: params.hovered_region_ids.clone(),
4069 clicked_region_ids: params.clicked_region_ids.clone(),
4070 refreshing: params.refreshing,
4071 }
4072 }
4073
4074 pub fn handle(&self) -> WeakViewHandle<V> {
4075 WeakViewHandle::new(self.window_id, self.view_id)
4076 }
4077
4078 pub fn window_id(&self) -> usize {
4079 self.window_id
4080 }
4081
4082 pub fn view_id(&self) -> usize {
4083 self.view_id
4084 }
4085
4086 pub fn mouse_state<Tag: 'static>(&self, region_id: usize) -> MouseState {
4087 let region_id = MouseRegionId {
4088 view_id: self.view_id,
4089 discriminant: (TypeId::of::<Tag>(), region_id),
4090 };
4091 MouseState {
4092 hovered: self.hovered_region_ids.contains(®ion_id),
4093 clicked: self.clicked_region_ids.as_ref().and_then(|(ids, button)| {
4094 if ids.contains(®ion_id) {
4095 Some(*button)
4096 } else {
4097 None
4098 }
4099 }),
4100 }
4101 }
4102
4103 pub fn element_state<Tag: 'static, T: 'static + Default>(
4104 &mut self,
4105 element_id: usize,
4106 ) -> ElementStateHandle<T> {
4107 let id = ElementStateId {
4108 view_id: self.view_id(),
4109 element_id,
4110 tag: TypeId::of::<Tag>(),
4111 };
4112 self.cx
4113 .element_states
4114 .entry(id)
4115 .or_insert_with(|| Box::new(T::default()));
4116 ElementStateHandle::new(id, self.frame_count, &self.cx.ref_counts)
4117 }
4118}
4119
4120impl AsRef<AppContext> for &AppContext {
4121 fn as_ref(&self) -> &AppContext {
4122 self
4123 }
4124}
4125
4126impl<V: View> Deref for RenderContext<'_, V> {
4127 type Target = MutableAppContext;
4128
4129 fn deref(&self) -> &Self::Target {
4130 self.app
4131 }
4132}
4133
4134impl<V: View> DerefMut for RenderContext<'_, V> {
4135 fn deref_mut(&mut self) -> &mut Self::Target {
4136 self.app
4137 }
4138}
4139
4140impl<V: View> ReadModel for RenderContext<'_, V> {
4141 fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
4142 self.app.read_model(handle)
4143 }
4144}
4145
4146impl<V: View> UpdateModel for RenderContext<'_, V> {
4147 fn update_model<T: Entity, O>(
4148 &mut self,
4149 handle: &ModelHandle<T>,
4150 update: &mut dyn FnMut(&mut T, &mut ModelContext<T>) -> O,
4151 ) -> O {
4152 self.app.update_model(handle, update)
4153 }
4154}
4155
4156impl<V: View> ReadView for RenderContext<'_, V> {
4157 fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
4158 self.app.read_view(handle)
4159 }
4160}
4161
4162impl<M> AsRef<AppContext> for ViewContext<'_, M> {
4163 fn as_ref(&self) -> &AppContext {
4164 &self.app.cx
4165 }
4166}
4167
4168impl<M> Deref for ViewContext<'_, M> {
4169 type Target = MutableAppContext;
4170
4171 fn deref(&self) -> &Self::Target {
4172 self.app
4173 }
4174}
4175
4176impl<M> DerefMut for ViewContext<'_, M> {
4177 fn deref_mut(&mut self) -> &mut Self::Target {
4178 &mut self.app
4179 }
4180}
4181
4182impl<M> AsMut<MutableAppContext> for ViewContext<'_, M> {
4183 fn as_mut(&mut self) -> &mut MutableAppContext {
4184 self.app
4185 }
4186}
4187
4188impl<V> ReadModel for ViewContext<'_, V> {
4189 fn read_model<T: Entity>(&self, handle: &ModelHandle<T>) -> &T {
4190 self.app.read_model(handle)
4191 }
4192}
4193
4194impl<V> UpgradeModelHandle for ViewContext<'_, V> {
4195 fn upgrade_model_handle<T: Entity>(
4196 &self,
4197 handle: &WeakModelHandle<T>,
4198 ) -> Option<ModelHandle<T>> {
4199 self.cx.upgrade_model_handle(handle)
4200 }
4201
4202 fn model_handle_is_upgradable<T: Entity>(&self, handle: &WeakModelHandle<T>) -> bool {
4203 self.cx.model_handle_is_upgradable(handle)
4204 }
4205
4206 fn upgrade_any_model_handle(&self, handle: &AnyWeakModelHandle) -> Option<AnyModelHandle> {
4207 self.cx.upgrade_any_model_handle(handle)
4208 }
4209}
4210
4211impl<V> UpgradeViewHandle for ViewContext<'_, V> {
4212 fn upgrade_view_handle<T: View>(&self, handle: &WeakViewHandle<T>) -> Option<ViewHandle<T>> {
4213 self.cx.upgrade_view_handle(handle)
4214 }
4215
4216 fn upgrade_any_view_handle(&self, handle: &AnyWeakViewHandle) -> Option<AnyViewHandle> {
4217 self.cx.upgrade_any_view_handle(handle)
4218 }
4219}
4220
4221impl<V: View> UpgradeViewHandle for RenderContext<'_, V> {
4222 fn upgrade_view_handle<T: View>(&self, handle: &WeakViewHandle<T>) -> Option<ViewHandle<T>> {
4223 self.cx.upgrade_view_handle(handle)
4224 }
4225
4226 fn upgrade_any_view_handle(&self, handle: &AnyWeakViewHandle) -> Option<AnyViewHandle> {
4227 self.cx.upgrade_any_view_handle(handle)
4228 }
4229}
4230
4231impl<V: View> UpdateModel for ViewContext<'_, V> {
4232 fn update_model<T: Entity, O>(
4233 &mut self,
4234 handle: &ModelHandle<T>,
4235 update: &mut dyn FnMut(&mut T, &mut ModelContext<T>) -> O,
4236 ) -> O {
4237 self.app.update_model(handle, update)
4238 }
4239}
4240
4241impl<V: View> ReadView for ViewContext<'_, V> {
4242 fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
4243 self.app.read_view(handle)
4244 }
4245}
4246
4247impl<V: View> UpdateView for ViewContext<'_, V> {
4248 fn update_view<T, S>(
4249 &mut self,
4250 handle: &ViewHandle<T>,
4251 update: &mut dyn FnMut(&mut T, &mut ViewContext<T>) -> S,
4252 ) -> S
4253 where
4254 T: View,
4255 {
4256 self.app.update_view(handle, update)
4257 }
4258}
4259
4260pub trait Handle<T> {
4261 type Weak: 'static;
4262 fn id(&self) -> usize;
4263 fn location(&self) -> EntityLocation;
4264 fn downgrade(&self) -> Self::Weak;
4265 fn upgrade_from(weak: &Self::Weak, cx: &AppContext) -> Option<Self>
4266 where
4267 Self: Sized;
4268}
4269
4270pub trait WeakHandle {
4271 fn id(&self) -> usize;
4272}
4273
4274#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
4275pub enum EntityLocation {
4276 Model(usize),
4277 View(usize, usize),
4278}
4279
4280pub struct ModelHandle<T: Entity> {
4281 model_id: usize,
4282 model_type: PhantomData<T>,
4283 ref_counts: Arc<Mutex<RefCounts>>,
4284
4285 #[cfg(any(test, feature = "test-support"))]
4286 handle_id: usize,
4287}
4288
4289impl<T: Entity> ModelHandle<T> {
4290 fn new(model_id: usize, ref_counts: &Arc<Mutex<RefCounts>>) -> Self {
4291 ref_counts.lock().inc_model(model_id);
4292
4293 #[cfg(any(test, feature = "test-support"))]
4294 let handle_id = ref_counts
4295 .lock()
4296 .leak_detector
4297 .lock()
4298 .handle_created(Some(type_name::<T>()), model_id);
4299
4300 Self {
4301 model_id,
4302 model_type: PhantomData,
4303 ref_counts: ref_counts.clone(),
4304
4305 #[cfg(any(test, feature = "test-support"))]
4306 handle_id,
4307 }
4308 }
4309
4310 pub fn downgrade(&self) -> WeakModelHandle<T> {
4311 WeakModelHandle::new(self.model_id)
4312 }
4313
4314 pub fn id(&self) -> usize {
4315 self.model_id
4316 }
4317
4318 pub fn read<'a, C: ReadModel>(&self, cx: &'a C) -> &'a T {
4319 cx.read_model(self)
4320 }
4321
4322 pub fn read_with<C, F, S>(&self, cx: &C, read: F) -> S
4323 where
4324 C: ReadModelWith,
4325 F: FnOnce(&T, &AppContext) -> S,
4326 {
4327 let mut read = Some(read);
4328 cx.read_model_with(self, &mut |model, cx| {
4329 let read = read.take().unwrap();
4330 read(model, cx)
4331 })
4332 }
4333
4334 pub fn update<C, F, S>(&self, cx: &mut C, update: F) -> S
4335 where
4336 C: UpdateModel,
4337 F: FnOnce(&mut T, &mut ModelContext<T>) -> S,
4338 {
4339 let mut update = Some(update);
4340 cx.update_model(self, &mut |model, cx| {
4341 let update = update.take().unwrap();
4342 update(model, cx)
4343 })
4344 }
4345
4346 #[cfg(any(test, feature = "test-support"))]
4347 pub fn next_notification(&self, cx: &TestAppContext) -> impl Future<Output = ()> {
4348 let (tx, mut rx) = futures::channel::mpsc::unbounded();
4349 let mut cx = cx.cx.borrow_mut();
4350 let subscription = cx.observe(self, move |_, _| {
4351 tx.unbounded_send(()).ok();
4352 });
4353
4354 let duration = if std::env::var("CI").is_ok() {
4355 Duration::from_secs(5)
4356 } else {
4357 Duration::from_secs(1)
4358 };
4359
4360 async move {
4361 let notification = crate::util::timeout(duration, rx.next())
4362 .await
4363 .expect("next notification timed out");
4364 drop(subscription);
4365 notification.expect("model dropped while test was waiting for its next notification")
4366 }
4367 }
4368
4369 #[cfg(any(test, feature = "test-support"))]
4370 pub fn next_event(&self, cx: &TestAppContext) -> impl Future<Output = T::Event>
4371 where
4372 T::Event: Clone,
4373 {
4374 let (tx, mut rx) = futures::channel::mpsc::unbounded();
4375 let mut cx = cx.cx.borrow_mut();
4376 let subscription = cx.subscribe(self, move |_, event, _| {
4377 tx.unbounded_send(event.clone()).ok();
4378 });
4379
4380 let duration = if std::env::var("CI").is_ok() {
4381 Duration::from_secs(5)
4382 } else {
4383 Duration::from_secs(1)
4384 };
4385
4386 cx.foreground.start_waiting();
4387 async move {
4388 let event = crate::util::timeout(duration, rx.next())
4389 .await
4390 .expect("next event timed out");
4391 drop(subscription);
4392 event.expect("model dropped while test was waiting for its next event")
4393 }
4394 }
4395
4396 #[cfg(any(test, feature = "test-support"))]
4397 pub fn condition(
4398 &self,
4399 cx: &TestAppContext,
4400 mut predicate: impl FnMut(&T, &AppContext) -> bool,
4401 ) -> impl Future<Output = ()> {
4402 let (tx, mut rx) = futures::channel::mpsc::unbounded();
4403
4404 let mut cx = cx.cx.borrow_mut();
4405 let subscriptions = (
4406 cx.observe(self, {
4407 let tx = tx.clone();
4408 move |_, _| {
4409 tx.unbounded_send(()).ok();
4410 }
4411 }),
4412 cx.subscribe(self, {
4413 move |_, _, _| {
4414 tx.unbounded_send(()).ok();
4415 }
4416 }),
4417 );
4418
4419 let cx = cx.weak_self.as_ref().unwrap().upgrade().unwrap();
4420 let handle = self.downgrade();
4421 let duration = if std::env::var("CI").is_ok() {
4422 Duration::from_secs(5)
4423 } else {
4424 Duration::from_secs(1)
4425 };
4426
4427 async move {
4428 crate::util::timeout(duration, async move {
4429 loop {
4430 {
4431 let cx = cx.borrow();
4432 let cx = cx.as_ref();
4433 if predicate(
4434 handle
4435 .upgrade(cx)
4436 .expect("model dropped with pending condition")
4437 .read(cx),
4438 cx,
4439 ) {
4440 break;
4441 }
4442 }
4443
4444 cx.borrow().foreground().start_waiting();
4445 rx.next()
4446 .await
4447 .expect("model dropped with pending condition");
4448 cx.borrow().foreground().finish_waiting();
4449 }
4450 })
4451 .await
4452 .expect("condition timed out");
4453 drop(subscriptions);
4454 }
4455 }
4456}
4457
4458impl<T: Entity> Clone for ModelHandle<T> {
4459 fn clone(&self) -> Self {
4460 Self::new(self.model_id, &self.ref_counts)
4461 }
4462}
4463
4464impl<T: Entity> PartialEq for ModelHandle<T> {
4465 fn eq(&self, other: &Self) -> bool {
4466 self.model_id == other.model_id
4467 }
4468}
4469
4470impl<T: Entity> Eq for ModelHandle<T> {}
4471
4472impl<T: Entity> PartialEq<WeakModelHandle<T>> for ModelHandle<T> {
4473 fn eq(&self, other: &WeakModelHandle<T>) -> bool {
4474 self.model_id == other.model_id
4475 }
4476}
4477
4478impl<T: Entity> Hash for ModelHandle<T> {
4479 fn hash<H: Hasher>(&self, state: &mut H) {
4480 self.model_id.hash(state);
4481 }
4482}
4483
4484impl<T: Entity> std::borrow::Borrow<usize> for ModelHandle<T> {
4485 fn borrow(&self) -> &usize {
4486 &self.model_id
4487 }
4488}
4489
4490impl<T: Entity> Debug for ModelHandle<T> {
4491 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4492 f.debug_tuple(&format!("ModelHandle<{}>", type_name::<T>()))
4493 .field(&self.model_id)
4494 .finish()
4495 }
4496}
4497
4498unsafe impl<T: Entity> Send for ModelHandle<T> {}
4499unsafe impl<T: Entity> Sync for ModelHandle<T> {}
4500
4501impl<T: Entity> Drop for ModelHandle<T> {
4502 fn drop(&mut self) {
4503 let mut ref_counts = self.ref_counts.lock();
4504 ref_counts.dec_model(self.model_id);
4505
4506 #[cfg(any(test, feature = "test-support"))]
4507 ref_counts
4508 .leak_detector
4509 .lock()
4510 .handle_dropped(self.model_id, self.handle_id);
4511 }
4512}
4513
4514impl<T: Entity> Handle<T> for ModelHandle<T> {
4515 type Weak = WeakModelHandle<T>;
4516
4517 fn id(&self) -> usize {
4518 self.model_id
4519 }
4520
4521 fn location(&self) -> EntityLocation {
4522 EntityLocation::Model(self.model_id)
4523 }
4524
4525 fn downgrade(&self) -> Self::Weak {
4526 self.downgrade()
4527 }
4528
4529 fn upgrade_from(weak: &Self::Weak, cx: &AppContext) -> Option<Self>
4530 where
4531 Self: Sized,
4532 {
4533 weak.upgrade(cx)
4534 }
4535}
4536
4537pub struct WeakModelHandle<T> {
4538 model_id: usize,
4539 model_type: PhantomData<T>,
4540}
4541
4542impl<T> WeakHandle for WeakModelHandle<T> {
4543 fn id(&self) -> usize {
4544 self.model_id
4545 }
4546}
4547
4548unsafe impl<T> Send for WeakModelHandle<T> {}
4549unsafe impl<T> Sync for WeakModelHandle<T> {}
4550
4551impl<T: Entity> WeakModelHandle<T> {
4552 fn new(model_id: usize) -> Self {
4553 Self {
4554 model_id,
4555 model_type: PhantomData,
4556 }
4557 }
4558
4559 pub fn id(&self) -> usize {
4560 self.model_id
4561 }
4562
4563 pub fn is_upgradable(&self, cx: &impl UpgradeModelHandle) -> bool {
4564 cx.model_handle_is_upgradable(self)
4565 }
4566
4567 pub fn upgrade(&self, cx: &impl UpgradeModelHandle) -> Option<ModelHandle<T>> {
4568 cx.upgrade_model_handle(self)
4569 }
4570}
4571
4572impl<T> Hash for WeakModelHandle<T> {
4573 fn hash<H: Hasher>(&self, state: &mut H) {
4574 self.model_id.hash(state)
4575 }
4576}
4577
4578impl<T> PartialEq for WeakModelHandle<T> {
4579 fn eq(&self, other: &Self) -> bool {
4580 self.model_id == other.model_id
4581 }
4582}
4583
4584impl<T> Eq for WeakModelHandle<T> {}
4585
4586impl<T> Clone for WeakModelHandle<T> {
4587 fn clone(&self) -> Self {
4588 Self {
4589 model_id: self.model_id,
4590 model_type: PhantomData,
4591 }
4592 }
4593}
4594
4595impl<T> Copy for WeakModelHandle<T> {}
4596
4597pub struct ViewHandle<T> {
4598 window_id: usize,
4599 view_id: usize,
4600 view_type: PhantomData<T>,
4601 ref_counts: Arc<Mutex<RefCounts>>,
4602 #[cfg(any(test, feature = "test-support"))]
4603 handle_id: usize,
4604}
4605
4606impl<T: View> ViewHandle<T> {
4607 fn new(window_id: usize, view_id: usize, ref_counts: &Arc<Mutex<RefCounts>>) -> Self {
4608 ref_counts.lock().inc_view(window_id, view_id);
4609 #[cfg(any(test, feature = "test-support"))]
4610 let handle_id = ref_counts
4611 .lock()
4612 .leak_detector
4613 .lock()
4614 .handle_created(Some(type_name::<T>()), view_id);
4615
4616 Self {
4617 window_id,
4618 view_id,
4619 view_type: PhantomData,
4620 ref_counts: ref_counts.clone(),
4621
4622 #[cfg(any(test, feature = "test-support"))]
4623 handle_id,
4624 }
4625 }
4626
4627 pub fn downgrade(&self) -> WeakViewHandle<T> {
4628 WeakViewHandle::new(self.window_id, self.view_id)
4629 }
4630
4631 pub fn window_id(&self) -> usize {
4632 self.window_id
4633 }
4634
4635 pub fn id(&self) -> usize {
4636 self.view_id
4637 }
4638
4639 pub fn read<'a, C: ReadView>(&self, cx: &'a C) -> &'a T {
4640 cx.read_view(self)
4641 }
4642
4643 pub fn read_with<C, F, S>(&self, cx: &C, read: F) -> S
4644 where
4645 C: ReadViewWith,
4646 F: FnOnce(&T, &AppContext) -> S,
4647 {
4648 let mut read = Some(read);
4649 cx.read_view_with(self, &mut |view, cx| {
4650 let read = read.take().unwrap();
4651 read(view, cx)
4652 })
4653 }
4654
4655 pub fn update<C, F, S>(&self, cx: &mut C, update: F) -> S
4656 where
4657 C: UpdateView,
4658 F: FnOnce(&mut T, &mut ViewContext<T>) -> S,
4659 {
4660 let mut update = Some(update);
4661 cx.update_view(self, &mut |view, cx| {
4662 let update = update.take().unwrap();
4663 update(view, cx)
4664 })
4665 }
4666
4667 pub fn defer<C, F>(&self, cx: &mut C, update: F)
4668 where
4669 C: AsMut<MutableAppContext>,
4670 F: 'static + FnOnce(&mut T, &mut ViewContext<T>),
4671 {
4672 let this = self.clone();
4673 cx.as_mut().defer(move |cx| {
4674 this.update(cx, |view, cx| update(view, cx));
4675 });
4676 }
4677
4678 pub fn is_focused(&self, cx: &AppContext) -> bool {
4679 cx.focused_view_id(self.window_id)
4680 .map_or(false, |focused_id| focused_id == self.view_id)
4681 }
4682
4683 #[cfg(any(test, feature = "test-support"))]
4684 pub fn next_notification(&self, cx: &TestAppContext) -> impl Future<Output = ()> {
4685 use postage::prelude::{Sink as _, Stream as _};
4686
4687 let (mut tx, mut rx) = postage::mpsc::channel(1);
4688 let mut cx = cx.cx.borrow_mut();
4689 let subscription = cx.observe(self, move |_, _| {
4690 tx.try_send(()).ok();
4691 });
4692
4693 let duration = if std::env::var("CI").is_ok() {
4694 Duration::from_secs(5)
4695 } else {
4696 Duration::from_secs(1)
4697 };
4698
4699 async move {
4700 let notification = crate::util::timeout(duration, rx.recv())
4701 .await
4702 .expect("next notification timed out");
4703 drop(subscription);
4704 notification.expect("model dropped while test was waiting for its next notification")
4705 }
4706 }
4707
4708 #[cfg(any(test, feature = "test-support"))]
4709 pub fn condition(
4710 &self,
4711 cx: &TestAppContext,
4712 mut predicate: impl FnMut(&T, &AppContext) -> bool,
4713 ) -> impl Future<Output = ()> {
4714 use postage::prelude::{Sink as _, Stream as _};
4715
4716 let (tx, mut rx) = postage::mpsc::channel(1024);
4717 let timeout_duration = cx.condition_duration();
4718
4719 let mut cx = cx.cx.borrow_mut();
4720 let subscriptions = self.update(&mut *cx, |_, cx| {
4721 (
4722 cx.observe(self, {
4723 let mut tx = tx.clone();
4724 move |_, _, _| {
4725 tx.blocking_send(()).ok();
4726 }
4727 }),
4728 cx.subscribe(self, {
4729 let mut tx = tx.clone();
4730 move |_, _, _, _| {
4731 tx.blocking_send(()).ok();
4732 }
4733 }),
4734 )
4735 });
4736
4737 let cx = cx.weak_self.as_ref().unwrap().upgrade().unwrap();
4738 let handle = self.downgrade();
4739
4740 async move {
4741 crate::util::timeout(timeout_duration, async move {
4742 loop {
4743 {
4744 let cx = cx.borrow();
4745 let cx = cx.as_ref();
4746 if predicate(
4747 handle
4748 .upgrade(cx)
4749 .expect("view dropped with pending condition")
4750 .read(cx),
4751 cx,
4752 ) {
4753 break;
4754 }
4755 }
4756
4757 cx.borrow().foreground().start_waiting();
4758 rx.recv()
4759 .await
4760 .expect("view dropped with pending condition");
4761 cx.borrow().foreground().finish_waiting();
4762 }
4763 })
4764 .await
4765 .expect("condition timed out");
4766 drop(subscriptions);
4767 }
4768 }
4769}
4770
4771impl<T: View> Clone for ViewHandle<T> {
4772 fn clone(&self) -> Self {
4773 ViewHandle::new(self.window_id, self.view_id, &self.ref_counts)
4774 }
4775}
4776
4777impl<T> PartialEq for ViewHandle<T> {
4778 fn eq(&self, other: &Self) -> bool {
4779 self.window_id == other.window_id && self.view_id == other.view_id
4780 }
4781}
4782
4783impl<T> PartialEq<WeakViewHandle<T>> for ViewHandle<T> {
4784 fn eq(&self, other: &WeakViewHandle<T>) -> bool {
4785 self.window_id == other.window_id && self.view_id == other.view_id
4786 }
4787}
4788
4789impl<T> PartialEq<ViewHandle<T>> for WeakViewHandle<T> {
4790 fn eq(&self, other: &ViewHandle<T>) -> bool {
4791 self.window_id == other.window_id && self.view_id == other.view_id
4792 }
4793}
4794
4795impl<T> Eq for ViewHandle<T> {}
4796
4797impl<T> Hash for ViewHandle<T> {
4798 fn hash<H: Hasher>(&self, state: &mut H) {
4799 self.window_id.hash(state);
4800 self.view_id.hash(state);
4801 }
4802}
4803
4804impl<T> Debug for ViewHandle<T> {
4805 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4806 f.debug_struct(&format!("ViewHandle<{}>", type_name::<T>()))
4807 .field("window_id", &self.window_id)
4808 .field("view_id", &self.view_id)
4809 .finish()
4810 }
4811}
4812
4813impl<T> Drop for ViewHandle<T> {
4814 fn drop(&mut self) {
4815 self.ref_counts
4816 .lock()
4817 .dec_view(self.window_id, self.view_id);
4818 #[cfg(any(test, feature = "test-support"))]
4819 self.ref_counts
4820 .lock()
4821 .leak_detector
4822 .lock()
4823 .handle_dropped(self.view_id, self.handle_id);
4824 }
4825}
4826
4827impl<T: View> Handle<T> for ViewHandle<T> {
4828 type Weak = WeakViewHandle<T>;
4829
4830 fn id(&self) -> usize {
4831 self.view_id
4832 }
4833
4834 fn location(&self) -> EntityLocation {
4835 EntityLocation::View(self.window_id, self.view_id)
4836 }
4837
4838 fn downgrade(&self) -> Self::Weak {
4839 self.downgrade()
4840 }
4841
4842 fn upgrade_from(weak: &Self::Weak, cx: &AppContext) -> Option<Self>
4843 where
4844 Self: Sized,
4845 {
4846 weak.upgrade(cx)
4847 }
4848}
4849
4850pub struct AnyViewHandle {
4851 window_id: usize,
4852 view_id: usize,
4853 view_type: TypeId,
4854 ref_counts: Arc<Mutex<RefCounts>>,
4855
4856 #[cfg(any(test, feature = "test-support"))]
4857 handle_id: usize,
4858}
4859
4860impl AnyViewHandle {
4861 fn new(
4862 window_id: usize,
4863 view_id: usize,
4864 view_type: TypeId,
4865 ref_counts: Arc<Mutex<RefCounts>>,
4866 ) -> Self {
4867 ref_counts.lock().inc_view(window_id, view_id);
4868
4869 #[cfg(any(test, feature = "test-support"))]
4870 let handle_id = ref_counts
4871 .lock()
4872 .leak_detector
4873 .lock()
4874 .handle_created(None, view_id);
4875
4876 Self {
4877 window_id,
4878 view_id,
4879 view_type,
4880 ref_counts,
4881 #[cfg(any(test, feature = "test-support"))]
4882 handle_id,
4883 }
4884 }
4885
4886 pub fn id(&self) -> usize {
4887 self.view_id
4888 }
4889
4890 pub fn is<T: 'static>(&self) -> bool {
4891 TypeId::of::<T>() == self.view_type
4892 }
4893
4894 pub fn is_focused(&self, cx: &AppContext) -> bool {
4895 cx.focused_view_id(self.window_id)
4896 .map_or(false, |focused_id| focused_id == self.view_id)
4897 }
4898
4899 pub fn downcast<T: View>(self) -> Option<ViewHandle<T>> {
4900 if self.is::<T>() {
4901 let result = Some(ViewHandle {
4902 window_id: self.window_id,
4903 view_id: self.view_id,
4904 ref_counts: self.ref_counts.clone(),
4905 view_type: PhantomData,
4906 #[cfg(any(test, feature = "test-support"))]
4907 handle_id: self.handle_id,
4908 });
4909 unsafe {
4910 Arc::decrement_strong_count(Arc::as_ptr(&self.ref_counts));
4911 }
4912 std::mem::forget(self);
4913 result
4914 } else {
4915 None
4916 }
4917 }
4918
4919 pub fn downgrade(&self) -> AnyWeakViewHandle {
4920 AnyWeakViewHandle {
4921 window_id: self.window_id,
4922 view_id: self.view_id,
4923 view_type: self.view_type,
4924 }
4925 }
4926
4927 pub fn view_type(&self) -> TypeId {
4928 self.view_type
4929 }
4930
4931 pub fn debug_json(&self, cx: &AppContext) -> serde_json::Value {
4932 cx.views
4933 .get(&(self.window_id, self.view_id))
4934 .map_or_else(|| serde_json::Value::Null, |view| view.debug_json(cx))
4935 }
4936}
4937
4938impl Clone for AnyViewHandle {
4939 fn clone(&self) -> Self {
4940 Self::new(
4941 self.window_id,
4942 self.view_id,
4943 self.view_type,
4944 self.ref_counts.clone(),
4945 )
4946 }
4947}
4948
4949impl From<&AnyViewHandle> for AnyViewHandle {
4950 fn from(handle: &AnyViewHandle) -> Self {
4951 handle.clone()
4952 }
4953}
4954
4955impl<T: View> From<&ViewHandle<T>> for AnyViewHandle {
4956 fn from(handle: &ViewHandle<T>) -> Self {
4957 Self::new(
4958 handle.window_id,
4959 handle.view_id,
4960 TypeId::of::<T>(),
4961 handle.ref_counts.clone(),
4962 )
4963 }
4964}
4965
4966impl<T: View> From<ViewHandle<T>> for AnyViewHandle {
4967 fn from(handle: ViewHandle<T>) -> Self {
4968 let any_handle = AnyViewHandle {
4969 window_id: handle.window_id,
4970 view_id: handle.view_id,
4971 view_type: TypeId::of::<T>(),
4972 ref_counts: handle.ref_counts.clone(),
4973 #[cfg(any(test, feature = "test-support"))]
4974 handle_id: handle.handle_id,
4975 };
4976
4977 unsafe {
4978 Arc::decrement_strong_count(Arc::as_ptr(&handle.ref_counts));
4979 }
4980 std::mem::forget(handle);
4981 any_handle
4982 }
4983}
4984
4985impl Drop for AnyViewHandle {
4986 fn drop(&mut self) {
4987 self.ref_counts
4988 .lock()
4989 .dec_view(self.window_id, self.view_id);
4990 #[cfg(any(test, feature = "test-support"))]
4991 self.ref_counts
4992 .lock()
4993 .leak_detector
4994 .lock()
4995 .handle_dropped(self.view_id, self.handle_id);
4996 }
4997}
4998
4999pub struct AnyModelHandle {
5000 model_id: usize,
5001 model_type: TypeId,
5002 ref_counts: Arc<Mutex<RefCounts>>,
5003
5004 #[cfg(any(test, feature = "test-support"))]
5005 handle_id: usize,
5006}
5007
5008impl AnyModelHandle {
5009 fn new(model_id: usize, model_type: TypeId, ref_counts: Arc<Mutex<RefCounts>>) -> Self {
5010 ref_counts.lock().inc_model(model_id);
5011
5012 #[cfg(any(test, feature = "test-support"))]
5013 let handle_id = ref_counts
5014 .lock()
5015 .leak_detector
5016 .lock()
5017 .handle_created(None, model_id);
5018
5019 Self {
5020 model_id,
5021 model_type,
5022 ref_counts,
5023
5024 #[cfg(any(test, feature = "test-support"))]
5025 handle_id,
5026 }
5027 }
5028
5029 pub fn downcast<T: Entity>(self) -> Option<ModelHandle<T>> {
5030 if self.is::<T>() {
5031 let result = Some(ModelHandle {
5032 model_id: self.model_id,
5033 model_type: PhantomData,
5034 ref_counts: self.ref_counts.clone(),
5035
5036 #[cfg(any(test, feature = "test-support"))]
5037 handle_id: self.handle_id,
5038 });
5039 unsafe {
5040 Arc::decrement_strong_count(Arc::as_ptr(&self.ref_counts));
5041 }
5042 std::mem::forget(self);
5043 result
5044 } else {
5045 None
5046 }
5047 }
5048
5049 pub fn downgrade(&self) -> AnyWeakModelHandle {
5050 AnyWeakModelHandle {
5051 model_id: self.model_id,
5052 model_type: self.model_type,
5053 }
5054 }
5055
5056 pub fn is<T: Entity>(&self) -> bool {
5057 self.model_type == TypeId::of::<T>()
5058 }
5059
5060 pub fn model_type(&self) -> TypeId {
5061 self.model_type
5062 }
5063}
5064
5065impl<T: Entity> From<ModelHandle<T>> for AnyModelHandle {
5066 fn from(handle: ModelHandle<T>) -> Self {
5067 Self::new(
5068 handle.model_id,
5069 TypeId::of::<T>(),
5070 handle.ref_counts.clone(),
5071 )
5072 }
5073}
5074
5075impl Clone for AnyModelHandle {
5076 fn clone(&self) -> Self {
5077 Self::new(self.model_id, self.model_type, self.ref_counts.clone())
5078 }
5079}
5080
5081impl Drop for AnyModelHandle {
5082 fn drop(&mut self) {
5083 let mut ref_counts = self.ref_counts.lock();
5084 ref_counts.dec_model(self.model_id);
5085
5086 #[cfg(any(test, feature = "test-support"))]
5087 ref_counts
5088 .leak_detector
5089 .lock()
5090 .handle_dropped(self.model_id, self.handle_id);
5091 }
5092}
5093
5094#[derive(Hash, PartialEq, Eq, Debug)]
5095pub struct AnyWeakModelHandle {
5096 model_id: usize,
5097 model_type: TypeId,
5098}
5099
5100impl AnyWeakModelHandle {
5101 pub fn upgrade(&self, cx: &impl UpgradeModelHandle) -> Option<AnyModelHandle> {
5102 cx.upgrade_any_model_handle(self)
5103 }
5104 pub fn model_type(&self) -> TypeId {
5105 self.model_type
5106 }
5107
5108 fn is<T: 'static>(&self) -> bool {
5109 TypeId::of::<T>() == self.model_type
5110 }
5111
5112 pub fn downcast<T: Entity>(&self) -> Option<WeakModelHandle<T>> {
5113 if self.is::<T>() {
5114 let result = Some(WeakModelHandle {
5115 model_id: self.model_id,
5116 model_type: PhantomData,
5117 });
5118
5119 result
5120 } else {
5121 None
5122 }
5123 }
5124}
5125
5126impl<T: Entity> From<WeakModelHandle<T>> for AnyWeakModelHandle {
5127 fn from(handle: WeakModelHandle<T>) -> Self {
5128 AnyWeakModelHandle {
5129 model_id: handle.model_id,
5130 model_type: TypeId::of::<T>(),
5131 }
5132 }
5133}
5134
5135#[derive(Debug)]
5136pub struct WeakViewHandle<T> {
5137 window_id: usize,
5138 view_id: usize,
5139 view_type: PhantomData<T>,
5140}
5141
5142impl<T> WeakHandle for WeakViewHandle<T> {
5143 fn id(&self) -> usize {
5144 self.view_id
5145 }
5146}
5147
5148impl<T: View> WeakViewHandle<T> {
5149 fn new(window_id: usize, view_id: usize) -> Self {
5150 Self {
5151 window_id,
5152 view_id,
5153 view_type: PhantomData,
5154 }
5155 }
5156
5157 pub fn id(&self) -> usize {
5158 self.view_id
5159 }
5160
5161 pub fn window_id(&self) -> usize {
5162 self.window_id
5163 }
5164
5165 pub fn upgrade(&self, cx: &impl UpgradeViewHandle) -> Option<ViewHandle<T>> {
5166 cx.upgrade_view_handle(self)
5167 }
5168}
5169
5170impl<T> Clone for WeakViewHandle<T> {
5171 fn clone(&self) -> Self {
5172 Self {
5173 window_id: self.window_id,
5174 view_id: self.view_id,
5175 view_type: PhantomData,
5176 }
5177 }
5178}
5179
5180impl<T> PartialEq for WeakViewHandle<T> {
5181 fn eq(&self, other: &Self) -> bool {
5182 self.window_id == other.window_id && self.view_id == other.view_id
5183 }
5184}
5185
5186impl<T> Eq for WeakViewHandle<T> {}
5187
5188impl<T> Hash for WeakViewHandle<T> {
5189 fn hash<H: Hasher>(&self, state: &mut H) {
5190 self.window_id.hash(state);
5191 self.view_id.hash(state);
5192 }
5193}
5194
5195pub struct AnyWeakViewHandle {
5196 window_id: usize,
5197 view_id: usize,
5198 view_type: TypeId,
5199}
5200
5201impl AnyWeakViewHandle {
5202 pub fn upgrade(&self, cx: &impl UpgradeViewHandle) -> Option<AnyViewHandle> {
5203 cx.upgrade_any_view_handle(self)
5204 }
5205}
5206
5207impl<T: View> From<WeakViewHandle<T>> for AnyWeakViewHandle {
5208 fn from(handle: WeakViewHandle<T>) -> Self {
5209 AnyWeakViewHandle {
5210 window_id: handle.window_id,
5211 view_id: handle.view_id,
5212 view_type: TypeId::of::<T>(),
5213 }
5214 }
5215}
5216
5217#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
5218pub struct ElementStateId {
5219 view_id: usize,
5220 element_id: usize,
5221 tag: TypeId,
5222}
5223
5224pub struct ElementStateHandle<T> {
5225 value_type: PhantomData<T>,
5226 id: ElementStateId,
5227 ref_counts: Weak<Mutex<RefCounts>>,
5228}
5229
5230impl<T: 'static> ElementStateHandle<T> {
5231 fn new(id: ElementStateId, frame_id: usize, ref_counts: &Arc<Mutex<RefCounts>>) -> Self {
5232 ref_counts.lock().inc_element_state(id, frame_id);
5233 Self {
5234 value_type: PhantomData,
5235 id,
5236 ref_counts: Arc::downgrade(ref_counts),
5237 }
5238 }
5239
5240 pub fn read<'a>(&self, cx: &'a AppContext) -> &'a T {
5241 cx.element_states
5242 .get(&self.id)
5243 .unwrap()
5244 .downcast_ref()
5245 .unwrap()
5246 }
5247
5248 pub fn update<C, R>(&self, cx: &mut C, f: impl FnOnce(&mut T, &mut C) -> R) -> R
5249 where
5250 C: DerefMut<Target = MutableAppContext>,
5251 {
5252 let mut element_state = cx.deref_mut().cx.element_states.remove(&self.id).unwrap();
5253 let result = f(element_state.downcast_mut().unwrap(), cx);
5254 cx.deref_mut()
5255 .cx
5256 .element_states
5257 .insert(self.id, element_state);
5258 result
5259 }
5260}
5261
5262impl<T> Drop for ElementStateHandle<T> {
5263 fn drop(&mut self) {
5264 if let Some(ref_counts) = self.ref_counts.upgrade() {
5265 ref_counts.lock().dec_element_state(self.id);
5266 }
5267 }
5268}
5269
5270#[must_use]
5271pub enum Subscription {
5272 Subscription {
5273 id: usize,
5274 entity_id: usize,
5275 subscriptions: Option<Weak<Mapping<usize, SubscriptionCallback>>>,
5276 },
5277 GlobalSubscription {
5278 id: usize,
5279 type_id: TypeId,
5280 subscriptions: Option<Weak<Mapping<TypeId, GlobalSubscriptionCallback>>>,
5281 },
5282 Observation {
5283 id: usize,
5284 entity_id: usize,
5285 observations: Option<Weak<Mapping<usize, ObservationCallback>>>,
5286 },
5287 GlobalObservation {
5288 id: usize,
5289 type_id: TypeId,
5290 observations: Option<Weak<Mapping<TypeId, GlobalObservationCallback>>>,
5291 },
5292 FocusObservation {
5293 id: usize,
5294 view_id: usize,
5295 observations: Option<Weak<Mapping<usize, FocusObservationCallback>>>,
5296 },
5297 WindowActivationObservation {
5298 id: usize,
5299 window_id: usize,
5300 observations: Option<Weak<Mapping<usize, WindowActivationCallback>>>,
5301 },
5302 WindowFullscreenObservation {
5303 id: usize,
5304 window_id: usize,
5305 observations: Option<Weak<Mapping<usize, WindowFullscreenCallback>>>,
5306 },
5307
5308 ReleaseObservation {
5309 id: usize,
5310 entity_id: usize,
5311 #[allow(clippy::type_complexity)]
5312 observations:
5313 Option<Weak<Mutex<HashMap<usize, BTreeMap<usize, ReleaseObservationCallback>>>>>,
5314 },
5315 ActionObservation {
5316 id: usize,
5317 observations: Option<Weak<Mutex<BTreeMap<usize, ActionObservationCallback>>>>,
5318 },
5319}
5320
5321impl Subscription {
5322 pub fn detach(&mut self) {
5323 match self {
5324 Subscription::Subscription { subscriptions, .. } => {
5325 subscriptions.take();
5326 }
5327 Subscription::GlobalSubscription { subscriptions, .. } => {
5328 subscriptions.take();
5329 }
5330 Subscription::Observation { observations, .. } => {
5331 observations.take();
5332 }
5333 Subscription::GlobalObservation { observations, .. } => {
5334 observations.take();
5335 }
5336 Subscription::ReleaseObservation { observations, .. } => {
5337 observations.take();
5338 }
5339 Subscription::FocusObservation { observations, .. } => {
5340 observations.take();
5341 }
5342 Subscription::ActionObservation { observations, .. } => {
5343 observations.take();
5344 }
5345 Subscription::WindowActivationObservation { observations, .. } => {
5346 observations.take();
5347 }
5348 Subscription::WindowFullscreenObservation { observations, .. } => {
5349 observations.take();
5350 }
5351 }
5352 }
5353}
5354
5355impl Drop for Subscription {
5356 fn drop(&mut self) {
5357 match self {
5358 Subscription::Subscription {
5359 id,
5360 entity_id,
5361 subscriptions,
5362 } => {
5363 if let Some(subscriptions) = subscriptions.as_ref().and_then(Weak::upgrade) {
5364 match subscriptions
5365 .lock()
5366 .entry(*entity_id)
5367 .or_default()
5368 .entry(*id)
5369 {
5370 btree_map::Entry::Vacant(entry) => {
5371 entry.insert(None);
5372 }
5373 btree_map::Entry::Occupied(entry) => {
5374 entry.remove();
5375 }
5376 }
5377 }
5378 }
5379 Subscription::GlobalSubscription {
5380 id,
5381 type_id,
5382 subscriptions,
5383 } => {
5384 if let Some(subscriptions) = subscriptions.as_ref().and_then(Weak::upgrade) {
5385 match subscriptions.lock().entry(*type_id).or_default().entry(*id) {
5386 btree_map::Entry::Vacant(entry) => {
5387 entry.insert(None);
5388 }
5389 btree_map::Entry::Occupied(entry) => {
5390 entry.remove();
5391 }
5392 }
5393 }
5394 }
5395 Subscription::Observation {
5396 id,
5397 entity_id,
5398 observations,
5399 } => {
5400 if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
5401 match observations
5402 .lock()
5403 .entry(*entity_id)
5404 .or_default()
5405 .entry(*id)
5406 {
5407 btree_map::Entry::Vacant(entry) => {
5408 entry.insert(None);
5409 }
5410 btree_map::Entry::Occupied(entry) => {
5411 entry.remove();
5412 }
5413 }
5414 }
5415 }
5416 Subscription::GlobalObservation {
5417 id,
5418 type_id,
5419 observations,
5420 } => {
5421 if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
5422 match observations.lock().entry(*type_id).or_default().entry(*id) {
5423 collections::btree_map::Entry::Vacant(entry) => {
5424 entry.insert(None);
5425 }
5426 collections::btree_map::Entry::Occupied(entry) => {
5427 entry.remove();
5428 }
5429 }
5430 }
5431 }
5432 Subscription::ReleaseObservation {
5433 id,
5434 entity_id,
5435 observations,
5436 } => {
5437 if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
5438 if let Some(observations) = observations.lock().get_mut(entity_id) {
5439 observations.remove(id);
5440 }
5441 }
5442 }
5443 Subscription::FocusObservation {
5444 id,
5445 view_id,
5446 observations,
5447 } => {
5448 if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
5449 match observations.lock().entry(*view_id).or_default().entry(*id) {
5450 btree_map::Entry::Vacant(entry) => {
5451 entry.insert(None);
5452 }
5453 btree_map::Entry::Occupied(entry) => {
5454 entry.remove();
5455 }
5456 }
5457 }
5458 }
5459 Subscription::ActionObservation { id, observations } => {
5460 if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
5461 observations.lock().remove(id);
5462 }
5463 }
5464 Subscription::WindowActivationObservation {
5465 id,
5466 window_id,
5467 observations,
5468 } => {
5469 if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
5470 match observations
5471 .lock()
5472 .entry(*window_id)
5473 .or_default()
5474 .entry(*id)
5475 {
5476 btree_map::Entry::Vacant(entry) => {
5477 entry.insert(None);
5478 }
5479 btree_map::Entry::Occupied(entry) => {
5480 entry.remove();
5481 }
5482 }
5483 }
5484 }
5485 Subscription::WindowFullscreenObservation {
5486 id,
5487 window_id,
5488 observations,
5489 } => {
5490 if let Some(observations) = observations.as_ref().and_then(Weak::upgrade) {
5491 match observations
5492 .lock()
5493 .entry(*window_id)
5494 .or_default()
5495 .entry(*id)
5496 {
5497 btree_map::Entry::Vacant(entry) => {
5498 entry.insert(None);
5499 }
5500 btree_map::Entry::Occupied(entry) => {
5501 entry.remove();
5502 }
5503 }
5504 }
5505 }
5506 }
5507 }
5508}
5509
5510lazy_static! {
5511 static ref LEAK_BACKTRACE: bool =
5512 std::env::var("LEAK_BACKTRACE").map_or(false, |b| !b.is_empty());
5513}
5514
5515#[cfg(any(test, feature = "test-support"))]
5516#[derive(Default)]
5517pub struct LeakDetector {
5518 next_handle_id: usize,
5519 #[allow(clippy::type_complexity)]
5520 handle_backtraces: HashMap<
5521 usize,
5522 (
5523 Option<&'static str>,
5524 HashMap<usize, Option<backtrace::Backtrace>>,
5525 ),
5526 >,
5527}
5528
5529#[cfg(any(test, feature = "test-support"))]
5530impl LeakDetector {
5531 fn handle_created(&mut self, type_name: Option<&'static str>, entity_id: usize) -> usize {
5532 let handle_id = post_inc(&mut self.next_handle_id);
5533 let entry = self.handle_backtraces.entry(entity_id).or_default();
5534 let backtrace = if *LEAK_BACKTRACE {
5535 Some(backtrace::Backtrace::new_unresolved())
5536 } else {
5537 None
5538 };
5539 if let Some(type_name) = type_name {
5540 entry.0.get_or_insert(type_name);
5541 }
5542 entry.1.insert(handle_id, backtrace);
5543 handle_id
5544 }
5545
5546 fn handle_dropped(&mut self, entity_id: usize, handle_id: usize) {
5547 if let Some((_, backtraces)) = self.handle_backtraces.get_mut(&entity_id) {
5548 assert!(backtraces.remove(&handle_id).is_some());
5549 if backtraces.is_empty() {
5550 self.handle_backtraces.remove(&entity_id);
5551 }
5552 }
5553 }
5554
5555 pub fn assert_dropped(&mut self, entity_id: usize) {
5556 if let Some((type_name, backtraces)) = self.handle_backtraces.get_mut(&entity_id) {
5557 for trace in backtraces.values_mut().flatten() {
5558 trace.resolve();
5559 eprintln!("{:?}", crate::util::CwdBacktrace(trace));
5560 }
5561
5562 let hint = if *LEAK_BACKTRACE {
5563 ""
5564 } else {
5565 " – set LEAK_BACKTRACE=1 for more information"
5566 };
5567
5568 panic!(
5569 "{} handles to {} {} still exist{}",
5570 backtraces.len(),
5571 type_name.unwrap_or("entity"),
5572 entity_id,
5573 hint
5574 );
5575 }
5576 }
5577
5578 pub fn detect(&mut self) {
5579 let mut found_leaks = false;
5580 for (id, (type_name, backtraces)) in self.handle_backtraces.iter_mut() {
5581 eprintln!(
5582 "leaked {} handles to {} {}",
5583 backtraces.len(),
5584 type_name.unwrap_or("entity"),
5585 id
5586 );
5587 for trace in backtraces.values_mut().flatten() {
5588 trace.resolve();
5589 eprintln!("{:?}", crate::util::CwdBacktrace(trace));
5590 }
5591 found_leaks = true;
5592 }
5593
5594 let hint = if *LEAK_BACKTRACE {
5595 ""
5596 } else {
5597 " – set LEAK_BACKTRACE=1 for more information"
5598 };
5599 assert!(!found_leaks, "detected leaked handles{}", hint);
5600 }
5601}
5602
5603#[derive(Default)]
5604struct RefCounts {
5605 entity_counts: HashMap<usize, usize>,
5606 element_state_counts: HashMap<ElementStateId, ElementStateRefCount>,
5607 dropped_models: HashSet<usize>,
5608 dropped_views: HashSet<(usize, usize)>,
5609 dropped_element_states: HashSet<ElementStateId>,
5610
5611 #[cfg(any(test, feature = "test-support"))]
5612 leak_detector: Arc<Mutex<LeakDetector>>,
5613}
5614
5615struct ElementStateRefCount {
5616 ref_count: usize,
5617 frame_id: usize,
5618}
5619
5620impl RefCounts {
5621 fn inc_model(&mut self, model_id: usize) {
5622 match self.entity_counts.entry(model_id) {
5623 Entry::Occupied(mut entry) => {
5624 *entry.get_mut() += 1;
5625 }
5626 Entry::Vacant(entry) => {
5627 entry.insert(1);
5628 self.dropped_models.remove(&model_id);
5629 }
5630 }
5631 }
5632
5633 fn inc_view(&mut self, window_id: usize, view_id: usize) {
5634 match self.entity_counts.entry(view_id) {
5635 Entry::Occupied(mut entry) => *entry.get_mut() += 1,
5636 Entry::Vacant(entry) => {
5637 entry.insert(1);
5638 self.dropped_views.remove(&(window_id, view_id));
5639 }
5640 }
5641 }
5642
5643 fn inc_element_state(&mut self, id: ElementStateId, frame_id: usize) {
5644 match self.element_state_counts.entry(id) {
5645 Entry::Occupied(mut entry) => {
5646 let entry = entry.get_mut();
5647 if entry.frame_id == frame_id || entry.ref_count >= 2 {
5648 panic!("used the same element state more than once in the same frame");
5649 }
5650 entry.ref_count += 1;
5651 entry.frame_id = frame_id;
5652 }
5653 Entry::Vacant(entry) => {
5654 entry.insert(ElementStateRefCount {
5655 ref_count: 1,
5656 frame_id,
5657 });
5658 self.dropped_element_states.remove(&id);
5659 }
5660 }
5661 }
5662
5663 fn dec_model(&mut self, model_id: usize) {
5664 let count = self.entity_counts.get_mut(&model_id).unwrap();
5665 *count -= 1;
5666 if *count == 0 {
5667 self.entity_counts.remove(&model_id);
5668 self.dropped_models.insert(model_id);
5669 }
5670 }
5671
5672 fn dec_view(&mut self, window_id: usize, view_id: usize) {
5673 let count = self.entity_counts.get_mut(&view_id).unwrap();
5674 *count -= 1;
5675 if *count == 0 {
5676 self.entity_counts.remove(&view_id);
5677 self.dropped_views.insert((window_id, view_id));
5678 }
5679 }
5680
5681 fn dec_element_state(&mut self, id: ElementStateId) {
5682 let entry = self.element_state_counts.get_mut(&id).unwrap();
5683 entry.ref_count -= 1;
5684 if entry.ref_count == 0 {
5685 self.element_state_counts.remove(&id);
5686 self.dropped_element_states.insert(id);
5687 }
5688 }
5689
5690 fn is_entity_alive(&self, entity_id: usize) -> bool {
5691 self.entity_counts.contains_key(&entity_id)
5692 }
5693
5694 fn take_dropped(
5695 &mut self,
5696 ) -> (
5697 HashSet<usize>,
5698 HashSet<(usize, usize)>,
5699 HashSet<ElementStateId>,
5700 ) {
5701 (
5702 std::mem::take(&mut self.dropped_models),
5703 std::mem::take(&mut self.dropped_views),
5704 std::mem::take(&mut self.dropped_element_states),
5705 )
5706 }
5707}
5708
5709#[cfg(test)]
5710mod tests {
5711 use super::*;
5712 use crate::{actions, elements::*, impl_actions, MouseButton, MouseButtonEvent};
5713 use serde::Deserialize;
5714 use smol::future::poll_once;
5715 use std::{
5716 cell::Cell,
5717 sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
5718 };
5719
5720 #[crate::test(self)]
5721 fn test_model_handles(cx: &mut MutableAppContext) {
5722 struct Model {
5723 other: Option<ModelHandle<Model>>,
5724 events: Vec<String>,
5725 }
5726
5727 impl Entity for Model {
5728 type Event = usize;
5729 }
5730
5731 impl Model {
5732 fn new(other: Option<ModelHandle<Self>>, cx: &mut ModelContext<Self>) -> Self {
5733 if let Some(other) = other.as_ref() {
5734 cx.observe(other, |me, _, _| {
5735 me.events.push("notified".into());
5736 })
5737 .detach();
5738 cx.subscribe(other, |me, _, event, _| {
5739 me.events.push(format!("observed event {}", event));
5740 })
5741 .detach();
5742 }
5743
5744 Self {
5745 other,
5746 events: Vec::new(),
5747 }
5748 }
5749 }
5750
5751 let handle_1 = cx.add_model(|cx| Model::new(None, cx));
5752 let handle_2 = cx.add_model(|cx| Model::new(Some(handle_1.clone()), cx));
5753 assert_eq!(cx.cx.models.len(), 2);
5754
5755 handle_1.update(cx, |model, cx| {
5756 model.events.push("updated".into());
5757 cx.emit(1);
5758 cx.notify();
5759 cx.emit(2);
5760 });
5761 assert_eq!(handle_1.read(cx).events, vec!["updated".to_string()]);
5762 assert_eq!(
5763 handle_2.read(cx).events,
5764 vec![
5765 "observed event 1".to_string(),
5766 "notified".to_string(),
5767 "observed event 2".to_string(),
5768 ]
5769 );
5770
5771 handle_2.update(cx, |model, _| {
5772 drop(handle_1);
5773 model.other.take();
5774 });
5775
5776 assert_eq!(cx.cx.models.len(), 1);
5777 assert!(cx.subscriptions.is_empty());
5778 assert!(cx.observations.is_empty());
5779 }
5780
5781 #[crate::test(self)]
5782 fn test_model_events(cx: &mut MutableAppContext) {
5783 #[derive(Default)]
5784 struct Model {
5785 events: Vec<usize>,
5786 }
5787
5788 impl Entity for Model {
5789 type Event = usize;
5790 }
5791
5792 let handle_1 = cx.add_model(|_| Model::default());
5793 let handle_2 = cx.add_model(|_| Model::default());
5794
5795 handle_1.update(cx, |_, cx| {
5796 cx.subscribe(&handle_2, move |model: &mut Model, emitter, event, cx| {
5797 model.events.push(*event);
5798
5799 cx.subscribe(&emitter, |model, _, event, _| {
5800 model.events.push(*event * 2);
5801 })
5802 .detach();
5803 })
5804 .detach();
5805 });
5806
5807 handle_2.update(cx, |_, c| c.emit(7));
5808 assert_eq!(handle_1.read(cx).events, vec![7]);
5809
5810 handle_2.update(cx, |_, c| c.emit(5));
5811 assert_eq!(handle_1.read(cx).events, vec![7, 5, 10]);
5812 }
5813
5814 #[crate::test(self)]
5815 fn test_model_emit_before_subscribe_in_same_update_cycle(cx: &mut MutableAppContext) {
5816 #[derive(Default)]
5817 struct Model;
5818
5819 impl Entity for Model {
5820 type Event = ();
5821 }
5822
5823 let events = Rc::new(RefCell::new(Vec::new()));
5824 cx.add_model(|cx| {
5825 drop(cx.subscribe(&cx.handle(), {
5826 let events = events.clone();
5827 move |_, _, _, _| events.borrow_mut().push("dropped before flush")
5828 }));
5829 cx.subscribe(&cx.handle(), {
5830 let events = events.clone();
5831 move |_, _, _, _| events.borrow_mut().push("before emit")
5832 })
5833 .detach();
5834 cx.emit(());
5835 cx.subscribe(&cx.handle(), {
5836 let events = events.clone();
5837 move |_, _, _, _| events.borrow_mut().push("after emit")
5838 })
5839 .detach();
5840 Model
5841 });
5842 assert_eq!(*events.borrow(), ["before emit"]);
5843 }
5844
5845 #[crate::test(self)]
5846 fn test_observe_and_notify_from_model(cx: &mut MutableAppContext) {
5847 #[derive(Default)]
5848 struct Model {
5849 count: usize,
5850 events: Vec<usize>,
5851 }
5852
5853 impl Entity for Model {
5854 type Event = ();
5855 }
5856
5857 let handle_1 = cx.add_model(|_| Model::default());
5858 let handle_2 = cx.add_model(|_| Model::default());
5859
5860 handle_1.update(cx, |_, c| {
5861 c.observe(&handle_2, move |model, observed, c| {
5862 model.events.push(observed.read(c).count);
5863 c.observe(&observed, |model, observed, c| {
5864 model.events.push(observed.read(c).count * 2);
5865 })
5866 .detach();
5867 })
5868 .detach();
5869 });
5870
5871 handle_2.update(cx, |model, c| {
5872 model.count = 7;
5873 c.notify()
5874 });
5875 assert_eq!(handle_1.read(cx).events, vec![7]);
5876
5877 handle_2.update(cx, |model, c| {
5878 model.count = 5;
5879 c.notify()
5880 });
5881 assert_eq!(handle_1.read(cx).events, vec![7, 5, 10])
5882 }
5883
5884 #[crate::test(self)]
5885 fn test_model_notify_before_observe_in_same_update_cycle(cx: &mut MutableAppContext) {
5886 #[derive(Default)]
5887 struct Model;
5888
5889 impl Entity for Model {
5890 type Event = ();
5891 }
5892
5893 let events = Rc::new(RefCell::new(Vec::new()));
5894 cx.add_model(|cx| {
5895 drop(cx.observe(&cx.handle(), {
5896 let events = events.clone();
5897 move |_, _, _| events.borrow_mut().push("dropped before flush")
5898 }));
5899 cx.observe(&cx.handle(), {
5900 let events = events.clone();
5901 move |_, _, _| events.borrow_mut().push("before notify")
5902 })
5903 .detach();
5904 cx.notify();
5905 cx.observe(&cx.handle(), {
5906 let events = events.clone();
5907 move |_, _, _| events.borrow_mut().push("after notify")
5908 })
5909 .detach();
5910 Model
5911 });
5912 assert_eq!(*events.borrow(), ["before notify"]);
5913 }
5914
5915 #[crate::test(self)]
5916 fn test_defer_and_after_window_update(cx: &mut MutableAppContext) {
5917 struct View {
5918 render_count: usize,
5919 }
5920
5921 impl Entity for View {
5922 type Event = usize;
5923 }
5924
5925 impl super::View for View {
5926 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
5927 post_inc(&mut self.render_count);
5928 Empty::new().boxed()
5929 }
5930
5931 fn ui_name() -> &'static str {
5932 "View"
5933 }
5934 }
5935
5936 let (_, view) = cx.add_window(Default::default(), |_| View { render_count: 0 });
5937 let called_defer = Rc::new(AtomicBool::new(false));
5938 let called_after_window_update = Rc::new(AtomicBool::new(false));
5939
5940 view.update(cx, |this, cx| {
5941 assert_eq!(this.render_count, 1);
5942 cx.defer({
5943 let called_defer = called_defer.clone();
5944 move |this, _| {
5945 assert_eq!(this.render_count, 1);
5946 called_defer.store(true, SeqCst);
5947 }
5948 });
5949 cx.after_window_update({
5950 let called_after_window_update = called_after_window_update.clone();
5951 move |this, cx| {
5952 assert_eq!(this.render_count, 2);
5953 called_after_window_update.store(true, SeqCst);
5954 cx.notify();
5955 }
5956 });
5957 assert!(!called_defer.load(SeqCst));
5958 assert!(!called_after_window_update.load(SeqCst));
5959 cx.notify();
5960 });
5961
5962 assert!(called_defer.load(SeqCst));
5963 assert!(called_after_window_update.load(SeqCst));
5964 assert_eq!(view.read(cx).render_count, 3);
5965 }
5966
5967 #[crate::test(self)]
5968 fn test_view_handles(cx: &mut MutableAppContext) {
5969 struct View {
5970 other: Option<ViewHandle<View>>,
5971 events: Vec<String>,
5972 }
5973
5974 impl Entity for View {
5975 type Event = usize;
5976 }
5977
5978 impl super::View for View {
5979 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
5980 Empty::new().boxed()
5981 }
5982
5983 fn ui_name() -> &'static str {
5984 "View"
5985 }
5986 }
5987
5988 impl View {
5989 fn new(other: Option<ViewHandle<View>>, cx: &mut ViewContext<Self>) -> Self {
5990 if let Some(other) = other.as_ref() {
5991 cx.subscribe(other, |me, _, event, _| {
5992 me.events.push(format!("observed event {}", event));
5993 })
5994 .detach();
5995 }
5996 Self {
5997 other,
5998 events: Vec::new(),
5999 }
6000 }
6001 }
6002
6003 let (_, root_view) = cx.add_window(Default::default(), |cx| View::new(None, cx));
6004 let handle_1 = cx.add_view(&root_view, |cx| View::new(None, cx));
6005 let handle_2 = cx.add_view(&root_view, |cx| View::new(Some(handle_1.clone()), cx));
6006 assert_eq!(cx.cx.views.len(), 3);
6007
6008 handle_1.update(cx, |view, cx| {
6009 view.events.push("updated".into());
6010 cx.emit(1);
6011 cx.emit(2);
6012 });
6013 assert_eq!(handle_1.read(cx).events, vec!["updated".to_string()]);
6014 assert_eq!(
6015 handle_2.read(cx).events,
6016 vec![
6017 "observed event 1".to_string(),
6018 "observed event 2".to_string(),
6019 ]
6020 );
6021
6022 handle_2.update(cx, |view, _| {
6023 drop(handle_1);
6024 view.other.take();
6025 });
6026
6027 assert_eq!(cx.cx.views.len(), 2);
6028 assert!(cx.subscriptions.is_empty());
6029 assert!(cx.observations.is_empty());
6030 }
6031
6032 #[crate::test(self)]
6033 fn test_add_window(cx: &mut MutableAppContext) {
6034 struct View {
6035 mouse_down_count: Arc<AtomicUsize>,
6036 }
6037
6038 impl Entity for View {
6039 type Event = ();
6040 }
6041
6042 impl super::View for View {
6043 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6044 let mouse_down_count = self.mouse_down_count.clone();
6045 EventHandler::new(Empty::new().boxed())
6046 .on_mouse_down(move |_| {
6047 mouse_down_count.fetch_add(1, SeqCst);
6048 true
6049 })
6050 .boxed()
6051 }
6052
6053 fn ui_name() -> &'static str {
6054 "View"
6055 }
6056 }
6057
6058 let mouse_down_count = Arc::new(AtomicUsize::new(0));
6059 let (window_id, _) = cx.add_window(Default::default(), |_| View {
6060 mouse_down_count: mouse_down_count.clone(),
6061 });
6062 let presenter = cx.presenters_and_platform_windows[&window_id].0.clone();
6063 // Ensure window's root element is in a valid lifecycle state.
6064 presenter.borrow_mut().dispatch_event(
6065 Event::MouseDown(MouseButtonEvent {
6066 position: Default::default(),
6067 button: MouseButton::Left,
6068 ctrl: false,
6069 alt: false,
6070 shift: false,
6071 cmd: false,
6072 click_count: 1,
6073 }),
6074 false,
6075 cx,
6076 );
6077 assert_eq!(mouse_down_count.load(SeqCst), 1);
6078 }
6079
6080 #[crate::test(self)]
6081 fn test_entity_release_hooks(cx: &mut MutableAppContext) {
6082 struct Model {
6083 released: Rc<Cell<bool>>,
6084 }
6085
6086 struct View {
6087 released: Rc<Cell<bool>>,
6088 }
6089
6090 impl Entity for Model {
6091 type Event = ();
6092
6093 fn release(&mut self, _: &mut MutableAppContext) {
6094 self.released.set(true);
6095 }
6096 }
6097
6098 impl Entity for View {
6099 type Event = ();
6100
6101 fn release(&mut self, _: &mut MutableAppContext) {
6102 self.released.set(true);
6103 }
6104 }
6105
6106 impl super::View for View {
6107 fn ui_name() -> &'static str {
6108 "View"
6109 }
6110
6111 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6112 Empty::new().boxed()
6113 }
6114 }
6115
6116 let model_released = Rc::new(Cell::new(false));
6117 let model_release_observed = Rc::new(Cell::new(false));
6118 let view_released = Rc::new(Cell::new(false));
6119 let view_release_observed = Rc::new(Cell::new(false));
6120
6121 let model = cx.add_model(|_| Model {
6122 released: model_released.clone(),
6123 });
6124 let (window_id, view) = cx.add_window(Default::default(), |_| View {
6125 released: view_released.clone(),
6126 });
6127 assert!(!model_released.get());
6128 assert!(!view_released.get());
6129
6130 cx.observe_release(&model, {
6131 let model_release_observed = model_release_observed.clone();
6132 move |_, _| model_release_observed.set(true)
6133 })
6134 .detach();
6135 cx.observe_release(&view, {
6136 let view_release_observed = view_release_observed.clone();
6137 move |_, _| view_release_observed.set(true)
6138 })
6139 .detach();
6140
6141 cx.update(move |_| {
6142 drop(model);
6143 });
6144 assert!(model_released.get());
6145 assert!(model_release_observed.get());
6146
6147 drop(view);
6148 cx.remove_window(window_id);
6149 assert!(view_released.get());
6150 assert!(view_release_observed.get());
6151 }
6152
6153 #[crate::test(self)]
6154 fn test_view_events(cx: &mut MutableAppContext) {
6155 #[derive(Default)]
6156 struct View {
6157 events: Vec<usize>,
6158 }
6159
6160 impl Entity for View {
6161 type Event = usize;
6162 }
6163
6164 impl super::View for View {
6165 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6166 Empty::new().boxed()
6167 }
6168
6169 fn ui_name() -> &'static str {
6170 "View"
6171 }
6172 }
6173
6174 struct Model;
6175
6176 impl Entity for Model {
6177 type Event = usize;
6178 }
6179
6180 let (_, handle_1) = cx.add_window(Default::default(), |_| View::default());
6181 let handle_2 = cx.add_view(&handle_1, |_| View::default());
6182 let handle_3 = cx.add_model(|_| Model);
6183
6184 handle_1.update(cx, |_, cx| {
6185 cx.subscribe(&handle_2, move |me, emitter, event, cx| {
6186 me.events.push(*event);
6187
6188 cx.subscribe(&emitter, |me, _, event, _| {
6189 me.events.push(*event * 2);
6190 })
6191 .detach();
6192 })
6193 .detach();
6194
6195 cx.subscribe(&handle_3, |me, _, event, _| {
6196 me.events.push(*event);
6197 })
6198 .detach();
6199 });
6200
6201 handle_2.update(cx, |_, c| c.emit(7));
6202 assert_eq!(handle_1.read(cx).events, vec![7]);
6203
6204 handle_2.update(cx, |_, c| c.emit(5));
6205 assert_eq!(handle_1.read(cx).events, vec![7, 5, 10]);
6206
6207 handle_3.update(cx, |_, c| c.emit(9));
6208 assert_eq!(handle_1.read(cx).events, vec![7, 5, 10, 9]);
6209 }
6210
6211 #[crate::test(self)]
6212 fn test_global_events(cx: &mut MutableAppContext) {
6213 #[derive(Clone, Debug, Eq, PartialEq)]
6214 struct GlobalEvent(u64);
6215
6216 let events = Rc::new(RefCell::new(Vec::new()));
6217 let first_subscription;
6218 let second_subscription;
6219
6220 {
6221 let events = events.clone();
6222 first_subscription = cx.subscribe_global(move |e: &GlobalEvent, _| {
6223 events.borrow_mut().push(("First", e.clone()));
6224 });
6225 }
6226
6227 {
6228 let events = events.clone();
6229 second_subscription = cx.subscribe_global(move |e: &GlobalEvent, _| {
6230 events.borrow_mut().push(("Second", e.clone()));
6231 });
6232 }
6233
6234 cx.update(|cx| {
6235 cx.emit_global(GlobalEvent(1));
6236 cx.emit_global(GlobalEvent(2));
6237 });
6238
6239 drop(first_subscription);
6240
6241 cx.update(|cx| {
6242 cx.emit_global(GlobalEvent(3));
6243 });
6244
6245 drop(second_subscription);
6246
6247 cx.update(|cx| {
6248 cx.emit_global(GlobalEvent(4));
6249 });
6250
6251 assert_eq!(
6252 &*events.borrow(),
6253 &[
6254 ("First", GlobalEvent(1)),
6255 ("Second", GlobalEvent(1)),
6256 ("First", GlobalEvent(2)),
6257 ("Second", GlobalEvent(2)),
6258 ("Second", GlobalEvent(3)),
6259 ]
6260 );
6261 }
6262
6263 #[crate::test(self)]
6264 fn test_global_events_emitted_before_subscription_in_same_update_cycle(
6265 cx: &mut MutableAppContext,
6266 ) {
6267 let events = Rc::new(RefCell::new(Vec::new()));
6268 cx.update(|cx| {
6269 {
6270 let events = events.clone();
6271 drop(cx.subscribe_global(move |_: &(), _| {
6272 events.borrow_mut().push("dropped before emit");
6273 }));
6274 }
6275
6276 {
6277 let events = events.clone();
6278 cx.subscribe_global(move |_: &(), _| {
6279 events.borrow_mut().push("before emit");
6280 })
6281 .detach();
6282 }
6283
6284 cx.emit_global(());
6285
6286 {
6287 let events = events.clone();
6288 cx.subscribe_global(move |_: &(), _| {
6289 events.borrow_mut().push("after emit");
6290 })
6291 .detach();
6292 }
6293 });
6294
6295 assert_eq!(*events.borrow(), ["before emit"]);
6296 }
6297
6298 #[crate::test(self)]
6299 fn test_global_nested_events(cx: &mut MutableAppContext) {
6300 #[derive(Clone, Debug, Eq, PartialEq)]
6301 struct GlobalEvent(u64);
6302
6303 let events = Rc::new(RefCell::new(Vec::new()));
6304
6305 {
6306 let events = events.clone();
6307 cx.subscribe_global(move |e: &GlobalEvent, cx| {
6308 events.borrow_mut().push(("Outer", e.clone()));
6309
6310 if e.0 == 1 {
6311 let events = events.clone();
6312 cx.subscribe_global(move |e: &GlobalEvent, _| {
6313 events.borrow_mut().push(("Inner", e.clone()));
6314 })
6315 .detach();
6316 }
6317 })
6318 .detach();
6319 }
6320
6321 cx.update(|cx| {
6322 cx.emit_global(GlobalEvent(1));
6323 cx.emit_global(GlobalEvent(2));
6324 cx.emit_global(GlobalEvent(3));
6325 });
6326 cx.update(|cx| {
6327 cx.emit_global(GlobalEvent(4));
6328 });
6329
6330 assert_eq!(
6331 &*events.borrow(),
6332 &[
6333 ("Outer", GlobalEvent(1)),
6334 ("Outer", GlobalEvent(2)),
6335 ("Outer", GlobalEvent(3)),
6336 ("Outer", GlobalEvent(4)),
6337 ("Inner", GlobalEvent(4)),
6338 ]
6339 );
6340 }
6341
6342 #[crate::test(self)]
6343 fn test_global(cx: &mut MutableAppContext) {
6344 type Global = usize;
6345
6346 let observation_count = Rc::new(RefCell::new(0));
6347 let subscription = cx.observe_global::<Global, _>({
6348 let observation_count = observation_count.clone();
6349 move |_| {
6350 *observation_count.borrow_mut() += 1;
6351 }
6352 });
6353
6354 assert!(!cx.has_global::<Global>());
6355 assert_eq!(cx.default_global::<Global>(), &0);
6356 assert_eq!(*observation_count.borrow(), 1);
6357 assert!(cx.has_global::<Global>());
6358 assert_eq!(
6359 cx.update_global::<Global, _, _>(|global, _| {
6360 *global = 1;
6361 "Update Result"
6362 }),
6363 "Update Result"
6364 );
6365 assert_eq!(*observation_count.borrow(), 2);
6366 assert_eq!(cx.global::<Global>(), &1);
6367
6368 drop(subscription);
6369 cx.update_global::<Global, _, _>(|global, _| {
6370 *global = 2;
6371 });
6372 assert_eq!(*observation_count.borrow(), 2);
6373
6374 type OtherGlobal = f32;
6375
6376 let observation_count = Rc::new(RefCell::new(0));
6377 cx.observe_global::<OtherGlobal, _>({
6378 let observation_count = observation_count.clone();
6379 move |_| {
6380 *observation_count.borrow_mut() += 1;
6381 }
6382 })
6383 .detach();
6384
6385 assert_eq!(
6386 cx.update_default_global::<OtherGlobal, _, _>(|global, _| {
6387 assert_eq!(global, &0.0);
6388 *global = 2.0;
6389 "Default update result"
6390 }),
6391 "Default update result"
6392 );
6393 assert_eq!(cx.global::<OtherGlobal>(), &2.0);
6394 assert_eq!(*observation_count.borrow(), 1);
6395 }
6396
6397 #[crate::test(self)]
6398 fn test_dropping_subscribers(cx: &mut MutableAppContext) {
6399 struct View;
6400
6401 impl Entity for View {
6402 type Event = ();
6403 }
6404
6405 impl super::View for View {
6406 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6407 Empty::new().boxed()
6408 }
6409
6410 fn ui_name() -> &'static str {
6411 "View"
6412 }
6413 }
6414
6415 struct Model;
6416
6417 impl Entity for Model {
6418 type Event = ();
6419 }
6420
6421 let (_, root_view) = cx.add_window(Default::default(), |_| View);
6422 let observing_view = cx.add_view(&root_view, |_| View);
6423 let emitting_view = cx.add_view(&root_view, |_| View);
6424 let observing_model = cx.add_model(|_| Model);
6425 let observed_model = cx.add_model(|_| Model);
6426
6427 observing_view.update(cx, |_, cx| {
6428 cx.subscribe(&emitting_view, |_, _, _, _| {}).detach();
6429 cx.subscribe(&observed_model, |_, _, _, _| {}).detach();
6430 });
6431 observing_model.update(cx, |_, cx| {
6432 cx.subscribe(&observed_model, |_, _, _, _| {}).detach();
6433 });
6434
6435 cx.update(|_| {
6436 drop(observing_view);
6437 drop(observing_model);
6438 });
6439
6440 emitting_view.update(cx, |_, cx| cx.emit(()));
6441 observed_model.update(cx, |_, cx| cx.emit(()));
6442 }
6443
6444 #[crate::test(self)]
6445 fn test_view_emit_before_subscribe_in_same_update_cycle(cx: &mut MutableAppContext) {
6446 #[derive(Default)]
6447 struct TestView;
6448
6449 impl Entity for TestView {
6450 type Event = ();
6451 }
6452
6453 impl View for TestView {
6454 fn ui_name() -> &'static str {
6455 "TestView"
6456 }
6457
6458 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6459 Empty::new().boxed()
6460 }
6461 }
6462
6463 let events = Rc::new(RefCell::new(Vec::new()));
6464 cx.add_window(Default::default(), |cx| {
6465 drop(cx.subscribe(&cx.handle(), {
6466 let events = events.clone();
6467 move |_, _, _, _| events.borrow_mut().push("dropped before flush")
6468 }));
6469 cx.subscribe(&cx.handle(), {
6470 let events = events.clone();
6471 move |_, _, _, _| events.borrow_mut().push("before emit")
6472 })
6473 .detach();
6474 cx.emit(());
6475 cx.subscribe(&cx.handle(), {
6476 let events = events.clone();
6477 move |_, _, _, _| events.borrow_mut().push("after emit")
6478 })
6479 .detach();
6480 TestView
6481 });
6482 assert_eq!(*events.borrow(), ["before emit"]);
6483 }
6484
6485 #[crate::test(self)]
6486 fn test_observe_and_notify_from_view(cx: &mut MutableAppContext) {
6487 #[derive(Default)]
6488 struct View {
6489 events: Vec<usize>,
6490 }
6491
6492 impl Entity for View {
6493 type Event = usize;
6494 }
6495
6496 impl super::View for View {
6497 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6498 Empty::new().boxed()
6499 }
6500
6501 fn ui_name() -> &'static str {
6502 "View"
6503 }
6504 }
6505
6506 #[derive(Default)]
6507 struct Model {
6508 count: usize,
6509 }
6510
6511 impl Entity for Model {
6512 type Event = ();
6513 }
6514
6515 let (_, view) = cx.add_window(Default::default(), |_| View::default());
6516 let model = cx.add_model(|_| Model::default());
6517
6518 view.update(cx, |_, c| {
6519 c.observe(&model, |me, observed, c| {
6520 me.events.push(observed.read(c).count)
6521 })
6522 .detach();
6523 });
6524
6525 model.update(cx, |model, c| {
6526 model.count = 11;
6527 c.notify();
6528 });
6529 assert_eq!(view.read(cx).events, vec![11]);
6530 }
6531
6532 #[crate::test(self)]
6533 fn test_view_notify_before_observe_in_same_update_cycle(cx: &mut MutableAppContext) {
6534 #[derive(Default)]
6535 struct TestView;
6536
6537 impl Entity for TestView {
6538 type Event = ();
6539 }
6540
6541 impl View for TestView {
6542 fn ui_name() -> &'static str {
6543 "TestView"
6544 }
6545
6546 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6547 Empty::new().boxed()
6548 }
6549 }
6550
6551 let events = Rc::new(RefCell::new(Vec::new()));
6552 cx.add_window(Default::default(), |cx| {
6553 drop(cx.observe(&cx.handle(), {
6554 let events = events.clone();
6555 move |_, _, _| events.borrow_mut().push("dropped before flush")
6556 }));
6557 cx.observe(&cx.handle(), {
6558 let events = events.clone();
6559 move |_, _, _| events.borrow_mut().push("before notify")
6560 })
6561 .detach();
6562 cx.notify();
6563 cx.observe(&cx.handle(), {
6564 let events = events.clone();
6565 move |_, _, _| events.borrow_mut().push("after notify")
6566 })
6567 .detach();
6568 TestView
6569 });
6570 assert_eq!(*events.borrow(), ["before notify"]);
6571 }
6572
6573 #[crate::test(self)]
6574 fn test_dropping_observers(cx: &mut MutableAppContext) {
6575 struct View;
6576
6577 impl Entity for View {
6578 type Event = ();
6579 }
6580
6581 impl super::View for View {
6582 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6583 Empty::new().boxed()
6584 }
6585
6586 fn ui_name() -> &'static str {
6587 "View"
6588 }
6589 }
6590
6591 struct Model;
6592
6593 impl Entity for Model {
6594 type Event = ();
6595 }
6596
6597 let (_, root_view) = cx.add_window(Default::default(), |_| View);
6598 let observing_view = cx.add_view(root_view, |_| View);
6599 let observing_model = cx.add_model(|_| Model);
6600 let observed_model = cx.add_model(|_| Model);
6601
6602 observing_view.update(cx, |_, cx| {
6603 cx.observe(&observed_model, |_, _, _| {}).detach();
6604 });
6605 observing_model.update(cx, |_, cx| {
6606 cx.observe(&observed_model, |_, _, _| {}).detach();
6607 });
6608
6609 cx.update(|_| {
6610 drop(observing_view);
6611 drop(observing_model);
6612 });
6613
6614 observed_model.update(cx, |_, cx| cx.notify());
6615 }
6616
6617 #[crate::test(self)]
6618 fn test_dropping_subscriptions_during_callback(cx: &mut MutableAppContext) {
6619 struct Model;
6620
6621 impl Entity for Model {
6622 type Event = u64;
6623 }
6624
6625 // Events
6626 let observing_model = cx.add_model(|_| Model);
6627 let observed_model = cx.add_model(|_| Model);
6628
6629 let events = Rc::new(RefCell::new(Vec::new()));
6630
6631 observing_model.update(cx, |_, cx| {
6632 let events = events.clone();
6633 let subscription = Rc::new(RefCell::new(None));
6634 *subscription.borrow_mut() = Some(cx.subscribe(&observed_model, {
6635 let subscription = subscription.clone();
6636 move |_, _, e, _| {
6637 subscription.borrow_mut().take();
6638 events.borrow_mut().push(*e);
6639 }
6640 }));
6641 });
6642
6643 observed_model.update(cx, |_, cx| {
6644 cx.emit(1);
6645 cx.emit(2);
6646 });
6647
6648 assert_eq!(*events.borrow(), [1]);
6649
6650 // Global Events
6651 #[derive(Clone, Debug, Eq, PartialEq)]
6652 struct GlobalEvent(u64);
6653
6654 let events = Rc::new(RefCell::new(Vec::new()));
6655
6656 {
6657 let events = events.clone();
6658 let subscription = Rc::new(RefCell::new(None));
6659 *subscription.borrow_mut() = Some(cx.subscribe_global({
6660 let subscription = subscription.clone();
6661 move |e: &GlobalEvent, _| {
6662 subscription.borrow_mut().take();
6663 events.borrow_mut().push(e.clone());
6664 }
6665 }));
6666 }
6667
6668 cx.update(|cx| {
6669 cx.emit_global(GlobalEvent(1));
6670 cx.emit_global(GlobalEvent(2));
6671 });
6672
6673 assert_eq!(*events.borrow(), [GlobalEvent(1)]);
6674
6675 // Model Observation
6676 let observing_model = cx.add_model(|_| Model);
6677 let observed_model = cx.add_model(|_| Model);
6678
6679 let observation_count = Rc::new(RefCell::new(0));
6680
6681 observing_model.update(cx, |_, cx| {
6682 let observation_count = observation_count.clone();
6683 let subscription = Rc::new(RefCell::new(None));
6684 *subscription.borrow_mut() = Some(cx.observe(&observed_model, {
6685 let subscription = subscription.clone();
6686 move |_, _, _| {
6687 subscription.borrow_mut().take();
6688 *observation_count.borrow_mut() += 1;
6689 }
6690 }));
6691 });
6692
6693 observed_model.update(cx, |_, cx| {
6694 cx.notify();
6695 });
6696
6697 observed_model.update(cx, |_, cx| {
6698 cx.notify();
6699 });
6700
6701 assert_eq!(*observation_count.borrow(), 1);
6702
6703 // View Observation
6704 struct View;
6705
6706 impl Entity for View {
6707 type Event = ();
6708 }
6709
6710 impl super::View for View {
6711 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6712 Empty::new().boxed()
6713 }
6714
6715 fn ui_name() -> &'static str {
6716 "View"
6717 }
6718 }
6719
6720 let (_, root_view) = cx.add_window(Default::default(), |_| View);
6721 let observing_view = cx.add_view(&root_view, |_| View);
6722 let observed_view = cx.add_view(&root_view, |_| View);
6723
6724 let observation_count = Rc::new(RefCell::new(0));
6725 observing_view.update(cx, |_, cx| {
6726 let observation_count = observation_count.clone();
6727 let subscription = Rc::new(RefCell::new(None));
6728 *subscription.borrow_mut() = Some(cx.observe(&observed_view, {
6729 let subscription = subscription.clone();
6730 move |_, _, _| {
6731 subscription.borrow_mut().take();
6732 *observation_count.borrow_mut() += 1;
6733 }
6734 }));
6735 });
6736
6737 observed_view.update(cx, |_, cx| {
6738 cx.notify();
6739 });
6740
6741 observed_view.update(cx, |_, cx| {
6742 cx.notify();
6743 });
6744
6745 assert_eq!(*observation_count.borrow(), 1);
6746
6747 // Global Observation
6748 let observation_count = Rc::new(RefCell::new(0));
6749 let subscription = Rc::new(RefCell::new(None));
6750 *subscription.borrow_mut() = Some(cx.observe_global::<(), _>({
6751 let observation_count = observation_count.clone();
6752 let subscription = subscription.clone();
6753 move |_| {
6754 subscription.borrow_mut().take();
6755 *observation_count.borrow_mut() += 1;
6756 }
6757 }));
6758
6759 cx.default_global::<()>();
6760 cx.set_global(());
6761 assert_eq!(*observation_count.borrow(), 1);
6762 }
6763
6764 #[crate::test(self)]
6765 fn test_focus(cx: &mut MutableAppContext) {
6766 struct View {
6767 name: String,
6768 events: Arc<Mutex<Vec<String>>>,
6769 }
6770
6771 impl Entity for View {
6772 type Event = ();
6773 }
6774
6775 impl super::View for View {
6776 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6777 Empty::new().boxed()
6778 }
6779
6780 fn ui_name() -> &'static str {
6781 "View"
6782 }
6783
6784 fn on_focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
6785 if cx.handle().id() == focused.id() {
6786 self.events.lock().push(format!("{} focused", &self.name));
6787 }
6788 }
6789
6790 fn on_focus_out(&mut self, blurred: AnyViewHandle, cx: &mut ViewContext<Self>) {
6791 if cx.handle().id() == blurred.id() {
6792 self.events.lock().push(format!("{} blurred", &self.name));
6793 }
6794 }
6795 }
6796
6797 let view_events: Arc<Mutex<Vec<String>>> = Default::default();
6798 let (_, view_1) = cx.add_window(Default::default(), |_| View {
6799 events: view_events.clone(),
6800 name: "view 1".to_string(),
6801 });
6802 let view_2 = cx.add_view(&view_1, |_| View {
6803 events: view_events.clone(),
6804 name: "view 2".to_string(),
6805 });
6806
6807 let observed_events: Arc<Mutex<Vec<String>>> = Default::default();
6808 view_1.update(cx, |_, cx| {
6809 cx.observe_focus(&view_2, {
6810 let observed_events = observed_events.clone();
6811 move |this, view, focused, cx| {
6812 let label = if focused { "focus" } else { "blur" };
6813 observed_events.lock().push(format!(
6814 "{} observed {}'s {}",
6815 this.name,
6816 view.read(cx).name,
6817 label
6818 ))
6819 }
6820 })
6821 .detach();
6822 });
6823 view_2.update(cx, |_, cx| {
6824 cx.observe_focus(&view_1, {
6825 let observed_events = observed_events.clone();
6826 move |this, view, focused, cx| {
6827 let label = if focused { "focus" } else { "blur" };
6828 observed_events.lock().push(format!(
6829 "{} observed {}'s {}",
6830 this.name,
6831 view.read(cx).name,
6832 label
6833 ))
6834 }
6835 })
6836 .detach();
6837 });
6838 assert_eq!(mem::take(&mut *view_events.lock()), ["view 1 focused"]);
6839 assert_eq!(mem::take(&mut *observed_events.lock()), Vec::<&str>::new());
6840
6841 view_1.update(cx, |_, cx| {
6842 // Ensure only the latest focus is honored.
6843 cx.focus(&view_2);
6844 cx.focus(&view_1);
6845 cx.focus(&view_2);
6846 });
6847 assert_eq!(
6848 mem::take(&mut *view_events.lock()),
6849 ["view 1 blurred", "view 2 focused"],
6850 );
6851 assert_eq!(
6852 mem::take(&mut *observed_events.lock()),
6853 [
6854 "view 2 observed view 1's blur",
6855 "view 1 observed view 2's focus"
6856 ]
6857 );
6858
6859 view_1.update(cx, |_, cx| cx.focus(&view_1));
6860 assert_eq!(
6861 mem::take(&mut *view_events.lock()),
6862 ["view 2 blurred", "view 1 focused"],
6863 );
6864 assert_eq!(
6865 mem::take(&mut *observed_events.lock()),
6866 [
6867 "view 1 observed view 2's blur",
6868 "view 2 observed view 1's focus"
6869 ]
6870 );
6871
6872 view_1.update(cx, |_, cx| cx.focus(&view_2));
6873 assert_eq!(
6874 mem::take(&mut *view_events.lock()),
6875 ["view 1 blurred", "view 2 focused"],
6876 );
6877 assert_eq!(
6878 mem::take(&mut *observed_events.lock()),
6879 [
6880 "view 2 observed view 1's blur",
6881 "view 1 observed view 2's focus"
6882 ]
6883 );
6884
6885 view_1.update(cx, |_, _| drop(view_2));
6886 assert_eq!(mem::take(&mut *view_events.lock()), ["view 1 focused"]);
6887 assert_eq!(mem::take(&mut *observed_events.lock()), Vec::<&str>::new());
6888 }
6889
6890 #[crate::test(self)]
6891 fn test_deserialize_actions(cx: &mut MutableAppContext) {
6892 #[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
6893 pub struct ComplexAction {
6894 arg: String,
6895 count: usize,
6896 }
6897
6898 actions!(test::something, [SimpleAction]);
6899 impl_actions!(test::something, [ComplexAction]);
6900
6901 cx.add_global_action(move |_: &SimpleAction, _: &mut MutableAppContext| {});
6902 cx.add_global_action(move |_: &ComplexAction, _: &mut MutableAppContext| {});
6903
6904 let action1 = cx
6905 .deserialize_action(
6906 "test::something::ComplexAction",
6907 Some(r#"{"arg": "a", "count": 5}"#),
6908 )
6909 .unwrap();
6910 let action2 = cx
6911 .deserialize_action("test::something::SimpleAction", None)
6912 .unwrap();
6913 assert_eq!(
6914 action1.as_any().downcast_ref::<ComplexAction>().unwrap(),
6915 &ComplexAction {
6916 arg: "a".to_string(),
6917 count: 5,
6918 }
6919 );
6920 assert_eq!(
6921 action2.as_any().downcast_ref::<SimpleAction>().unwrap(),
6922 &SimpleAction
6923 );
6924 }
6925
6926 #[crate::test(self)]
6927 fn test_dispatch_action(cx: &mut MutableAppContext) {
6928 struct ViewA {
6929 id: usize,
6930 }
6931
6932 impl Entity for ViewA {
6933 type Event = ();
6934 }
6935
6936 impl View for ViewA {
6937 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6938 Empty::new().boxed()
6939 }
6940
6941 fn ui_name() -> &'static str {
6942 "View"
6943 }
6944 }
6945
6946 struct ViewB {
6947 id: usize,
6948 }
6949
6950 impl Entity for ViewB {
6951 type Event = ();
6952 }
6953
6954 impl View for ViewB {
6955 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
6956 Empty::new().boxed()
6957 }
6958
6959 fn ui_name() -> &'static str {
6960 "View"
6961 }
6962 }
6963
6964 #[derive(Clone, Default, Deserialize, PartialEq)]
6965 pub struct Action(pub String);
6966
6967 impl_actions!(test, [Action]);
6968
6969 let actions = Rc::new(RefCell::new(Vec::new()));
6970
6971 cx.add_global_action({
6972 let actions = actions.clone();
6973 move |_: &Action, _: &mut MutableAppContext| {
6974 actions.borrow_mut().push("global".to_string());
6975 }
6976 });
6977
6978 cx.add_action({
6979 let actions = actions.clone();
6980 move |view: &mut ViewA, action: &Action, cx| {
6981 assert_eq!(action.0, "bar");
6982 cx.propagate_action();
6983 actions.borrow_mut().push(format!("{} a", view.id));
6984 }
6985 });
6986
6987 cx.add_action({
6988 let actions = actions.clone();
6989 move |view: &mut ViewA, _: &Action, cx| {
6990 if view.id != 1 {
6991 cx.add_view(|cx| {
6992 cx.propagate_action(); // Still works on a nested ViewContext
6993 ViewB { id: 5 }
6994 });
6995 }
6996 actions.borrow_mut().push(format!("{} b", view.id));
6997 }
6998 });
6999
7000 cx.add_action({
7001 let actions = actions.clone();
7002 move |view: &mut ViewB, _: &Action, cx| {
7003 cx.propagate_action();
7004 actions.borrow_mut().push(format!("{} c", view.id));
7005 }
7006 });
7007
7008 cx.add_action({
7009 let actions = actions.clone();
7010 move |view: &mut ViewB, _: &Action, cx| {
7011 cx.propagate_action();
7012 actions.borrow_mut().push(format!("{} d", view.id));
7013 }
7014 });
7015
7016 cx.capture_action({
7017 let actions = actions.clone();
7018 move |view: &mut ViewA, _: &Action, cx| {
7019 cx.propagate_action();
7020 actions.borrow_mut().push(format!("{} capture", view.id));
7021 }
7022 });
7023
7024 let observed_actions = Rc::new(RefCell::new(Vec::new()));
7025 cx.observe_actions({
7026 let observed_actions = observed_actions.clone();
7027 move |action_id, _| observed_actions.borrow_mut().push(action_id)
7028 })
7029 .detach();
7030
7031 let (window_id, view_1) = cx.add_window(Default::default(), |_| ViewA { id: 1 });
7032 let view_2 = cx.add_view(&view_1, |_| ViewB { id: 2 });
7033 let view_3 = cx.add_view(&view_2, |_| ViewA { id: 3 });
7034 let view_4 = cx.add_view(&view_3, |_| ViewB { id: 4 });
7035
7036 cx.handle_dispatch_action_from_effect(
7037 window_id,
7038 Some(view_4.id()),
7039 &Action("bar".to_string()),
7040 );
7041
7042 assert_eq!(
7043 *actions.borrow(),
7044 vec![
7045 "1 capture",
7046 "3 capture",
7047 "4 d",
7048 "4 c",
7049 "3 b",
7050 "3 a",
7051 "2 d",
7052 "2 c",
7053 "1 b"
7054 ]
7055 );
7056 assert_eq!(*observed_actions.borrow(), [Action::default().id()]);
7057
7058 // Remove view_1, which doesn't propagate the action
7059
7060 let (window_id, view_2) = cx.add_window(Default::default(), |_| ViewB { id: 2 });
7061 let view_3 = cx.add_view(&view_2, |_| ViewA { id: 3 });
7062 let view_4 = cx.add_view(&view_3, |_| ViewB { id: 4 });
7063
7064 actions.borrow_mut().clear();
7065 cx.handle_dispatch_action_from_effect(
7066 window_id,
7067 Some(view_4.id()),
7068 &Action("bar".to_string()),
7069 );
7070
7071 assert_eq!(
7072 *actions.borrow(),
7073 vec![
7074 "3 capture",
7075 "4 d",
7076 "4 c",
7077 "3 b",
7078 "3 a",
7079 "2 d",
7080 "2 c",
7081 "global"
7082 ]
7083 );
7084 assert_eq!(
7085 *observed_actions.borrow(),
7086 [Action::default().id(), Action::default().id()]
7087 );
7088 }
7089
7090 #[crate::test(self)]
7091 fn test_dispatch_keystroke(cx: &mut MutableAppContext) {
7092 #[derive(Clone, Deserialize, PartialEq)]
7093 pub struct Action(String);
7094
7095 impl_actions!(test, [Action]);
7096
7097 struct View {
7098 id: usize,
7099 keymap_context: keymap::Context,
7100 }
7101
7102 impl Entity for View {
7103 type Event = ();
7104 }
7105
7106 impl super::View for View {
7107 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
7108 Empty::new().boxed()
7109 }
7110
7111 fn ui_name() -> &'static str {
7112 "View"
7113 }
7114
7115 fn keymap_context(&self, _: &AppContext) -> keymap::Context {
7116 self.keymap_context.clone()
7117 }
7118 }
7119
7120 impl View {
7121 fn new(id: usize) -> Self {
7122 View {
7123 id,
7124 keymap_context: keymap::Context::default(),
7125 }
7126 }
7127 }
7128
7129 let mut view_1 = View::new(1);
7130 let mut view_2 = View::new(2);
7131 let mut view_3 = View::new(3);
7132 view_1.keymap_context.set.insert("a".into());
7133 view_2.keymap_context.set.insert("a".into());
7134 view_2.keymap_context.set.insert("b".into());
7135 view_3.keymap_context.set.insert("a".into());
7136 view_3.keymap_context.set.insert("b".into());
7137 view_3.keymap_context.set.insert("c".into());
7138
7139 let (window_id, view_1) = cx.add_window(Default::default(), |_| view_1);
7140 let view_2 = cx.add_view(&view_1, |_| view_2);
7141 let _view_3 = cx.add_view(&view_2, |cx| {
7142 cx.focus_self();
7143 view_3
7144 });
7145
7146 // This keymap's only binding dispatches an action on view 2 because that view will have
7147 // "a" and "b" in its context, but not "c".
7148 cx.add_bindings(vec![keymap::Binding::new(
7149 "a",
7150 Action("a".to_string()),
7151 Some("a && b && !c"),
7152 )]);
7153
7154 cx.add_bindings(vec![keymap::Binding::new(
7155 "b",
7156 Action("b".to_string()),
7157 None,
7158 )]);
7159
7160 let actions = Rc::new(RefCell::new(Vec::new()));
7161 cx.add_action({
7162 let actions = actions.clone();
7163 move |view: &mut View, action: &Action, cx| {
7164 if action.0 == "a" {
7165 actions.borrow_mut().push(format!("{} a", view.id));
7166 } else {
7167 actions
7168 .borrow_mut()
7169 .push(format!("{} {}", view.id, action.0));
7170 cx.propagate_action();
7171 }
7172 }
7173 });
7174
7175 cx.add_global_action({
7176 let actions = actions.clone();
7177 move |action: &Action, _| {
7178 actions.borrow_mut().push(format!("global {}", action.0));
7179 }
7180 });
7181
7182 cx.dispatch_keystroke(window_id, &Keystroke::parse("a").unwrap());
7183
7184 assert_eq!(&*actions.borrow(), &["2 a"]);
7185
7186 actions.borrow_mut().clear();
7187
7188 cx.dispatch_keystroke(window_id, &Keystroke::parse("b").unwrap());
7189
7190 assert_eq!(&*actions.borrow(), &["3 b", "2 b", "1 b", "global b"]);
7191 }
7192
7193 #[crate::test(self)]
7194 async fn test_model_condition(cx: &mut TestAppContext) {
7195 struct Counter(usize);
7196
7197 impl super::Entity for Counter {
7198 type Event = ();
7199 }
7200
7201 impl Counter {
7202 fn inc(&mut self, cx: &mut ModelContext<Self>) {
7203 self.0 += 1;
7204 cx.notify();
7205 }
7206 }
7207
7208 let model = cx.add_model(|_| Counter(0));
7209
7210 let condition1 = model.condition(cx, |model, _| model.0 == 2);
7211 let condition2 = model.condition(cx, |model, _| model.0 == 3);
7212 smol::pin!(condition1, condition2);
7213
7214 model.update(cx, |model, cx| model.inc(cx));
7215 assert_eq!(poll_once(&mut condition1).await, None);
7216 assert_eq!(poll_once(&mut condition2).await, None);
7217
7218 model.update(cx, |model, cx| model.inc(cx));
7219 assert_eq!(poll_once(&mut condition1).await, Some(()));
7220 assert_eq!(poll_once(&mut condition2).await, None);
7221
7222 model.update(cx, |model, cx| model.inc(cx));
7223 assert_eq!(poll_once(&mut condition2).await, Some(()));
7224
7225 model.update(cx, |_, cx| cx.notify());
7226 }
7227
7228 #[crate::test(self)]
7229 #[should_panic]
7230 async fn test_model_condition_timeout(cx: &mut TestAppContext) {
7231 struct Model;
7232
7233 impl super::Entity for Model {
7234 type Event = ();
7235 }
7236
7237 let model = cx.add_model(|_| Model);
7238 model.condition(cx, |_, _| false).await;
7239 }
7240
7241 #[crate::test(self)]
7242 #[should_panic(expected = "model dropped with pending condition")]
7243 async fn test_model_condition_panic_on_drop(cx: &mut TestAppContext) {
7244 struct Model;
7245
7246 impl super::Entity for Model {
7247 type Event = ();
7248 }
7249
7250 let model = cx.add_model(|_| Model);
7251 let condition = model.condition(cx, |_, _| false);
7252 cx.update(|_| drop(model));
7253 condition.await;
7254 }
7255
7256 #[crate::test(self)]
7257 async fn test_view_condition(cx: &mut TestAppContext) {
7258 struct Counter(usize);
7259
7260 impl super::Entity for Counter {
7261 type Event = ();
7262 }
7263
7264 impl super::View for Counter {
7265 fn ui_name() -> &'static str {
7266 "test view"
7267 }
7268
7269 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
7270 Empty::new().boxed()
7271 }
7272 }
7273
7274 impl Counter {
7275 fn inc(&mut self, cx: &mut ViewContext<Self>) {
7276 self.0 += 1;
7277 cx.notify();
7278 }
7279 }
7280
7281 let (_, view) = cx.add_window(|_| Counter(0));
7282
7283 let condition1 = view.condition(cx, |view, _| view.0 == 2);
7284 let condition2 = view.condition(cx, |view, _| view.0 == 3);
7285 smol::pin!(condition1, condition2);
7286
7287 view.update(cx, |view, cx| view.inc(cx));
7288 assert_eq!(poll_once(&mut condition1).await, None);
7289 assert_eq!(poll_once(&mut condition2).await, None);
7290
7291 view.update(cx, |view, cx| view.inc(cx));
7292 assert_eq!(poll_once(&mut condition1).await, Some(()));
7293 assert_eq!(poll_once(&mut condition2).await, None);
7294
7295 view.update(cx, |view, cx| view.inc(cx));
7296 assert_eq!(poll_once(&mut condition2).await, Some(()));
7297 view.update(cx, |_, cx| cx.notify());
7298 }
7299
7300 #[crate::test(self)]
7301 #[should_panic]
7302 async fn test_view_condition_timeout(cx: &mut TestAppContext) {
7303 struct View;
7304
7305 impl super::Entity for View {
7306 type Event = ();
7307 }
7308
7309 impl super::View for View {
7310 fn ui_name() -> &'static str {
7311 "test view"
7312 }
7313
7314 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
7315 Empty::new().boxed()
7316 }
7317 }
7318
7319 let (_, view) = cx.add_window(|_| View);
7320 view.condition(cx, |_, _| false).await;
7321 }
7322
7323 #[crate::test(self)]
7324 #[should_panic(expected = "view dropped with pending condition")]
7325 async fn test_view_condition_panic_on_drop(cx: &mut TestAppContext) {
7326 struct View;
7327
7328 impl super::Entity for View {
7329 type Event = ();
7330 }
7331
7332 impl super::View for View {
7333 fn ui_name() -> &'static str {
7334 "test view"
7335 }
7336
7337 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
7338 Empty::new().boxed()
7339 }
7340 }
7341
7342 let (_, root_view) = cx.add_window(|_| View);
7343 let view = cx.add_view(&root_view, |_| View);
7344
7345 let condition = view.condition(cx, |_, _| false);
7346 cx.update(|_| drop(view));
7347 condition.await;
7348 }
7349
7350 #[crate::test(self)]
7351 fn test_refresh_windows(cx: &mut MutableAppContext) {
7352 struct View(usize);
7353
7354 impl super::Entity for View {
7355 type Event = ();
7356 }
7357
7358 impl super::View for View {
7359 fn ui_name() -> &'static str {
7360 "test view"
7361 }
7362
7363 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
7364 Empty::new().named(format!("render count: {}", post_inc(&mut self.0)))
7365 }
7366 }
7367
7368 let (window_id, root_view) = cx.add_window(Default::default(), |_| View(0));
7369 let presenter = cx.presenters_and_platform_windows[&window_id].0.clone();
7370
7371 assert_eq!(
7372 presenter.borrow().rendered_views[&root_view.id()].name(),
7373 Some("render count: 0")
7374 );
7375
7376 let view = cx.add_view(&root_view, |cx| {
7377 cx.refresh_windows();
7378 View(0)
7379 });
7380
7381 assert_eq!(
7382 presenter.borrow().rendered_views[&root_view.id()].name(),
7383 Some("render count: 1")
7384 );
7385 assert_eq!(
7386 presenter.borrow().rendered_views[&view.id()].name(),
7387 Some("render count: 0")
7388 );
7389
7390 cx.update(|cx| cx.refresh_windows());
7391 assert_eq!(
7392 presenter.borrow().rendered_views[&root_view.id()].name(),
7393 Some("render count: 2")
7394 );
7395 assert_eq!(
7396 presenter.borrow().rendered_views[&view.id()].name(),
7397 Some("render count: 1")
7398 );
7399
7400 cx.update(|cx| {
7401 cx.refresh_windows();
7402 drop(view);
7403 });
7404 assert_eq!(
7405 presenter.borrow().rendered_views[&root_view.id()].name(),
7406 Some("render count: 3")
7407 );
7408 assert_eq!(presenter.borrow().rendered_views.len(), 1);
7409 }
7410
7411 #[crate::test(self)]
7412 async fn test_window_activation(cx: &mut TestAppContext) {
7413 struct View(&'static str);
7414
7415 impl super::Entity for View {
7416 type Event = ();
7417 }
7418
7419 impl super::View for View {
7420 fn ui_name() -> &'static str {
7421 "test view"
7422 }
7423
7424 fn render(&mut self, _: &mut RenderContext<Self>) -> ElementBox {
7425 Empty::new().boxed()
7426 }
7427 }
7428
7429 let events = Rc::new(RefCell::new(Vec::new()));
7430 let (window_1, _) = cx.add_window(|cx: &mut ViewContext<View>| {
7431 cx.observe_window_activation({
7432 let events = events.clone();
7433 move |this, active, _| events.borrow_mut().push((this.0, active))
7434 })
7435 .detach();
7436 View("window 1")
7437 });
7438 assert_eq!(mem::take(&mut *events.borrow_mut()), [("window 1", true)]);
7439
7440 let (window_2, _) = cx.add_window(|cx: &mut ViewContext<View>| {
7441 cx.observe_window_activation({
7442 let events = events.clone();
7443 move |this, active, _| events.borrow_mut().push((this.0, active))
7444 })
7445 .detach();
7446 View("window 2")
7447 });
7448 assert_eq!(
7449 mem::take(&mut *events.borrow_mut()),
7450 [("window 1", false), ("window 2", true)]
7451 );
7452
7453 let (window_3, _) = cx.add_window(|cx: &mut ViewContext<View>| {
7454 cx.observe_window_activation({
7455 let events = events.clone();
7456 move |this, active, _| events.borrow_mut().push((this.0, active))
7457 })
7458 .detach();
7459 View("window 3")
7460 });
7461 assert_eq!(
7462 mem::take(&mut *events.borrow_mut()),
7463 [("window 2", false), ("window 3", true)]
7464 );
7465
7466 cx.simulate_window_activation(Some(window_2));
7467 assert_eq!(
7468 mem::take(&mut *events.borrow_mut()),
7469 [("window 3", false), ("window 2", true)]
7470 );
7471
7472 cx.simulate_window_activation(Some(window_1));
7473 assert_eq!(
7474 mem::take(&mut *events.borrow_mut()),
7475 [("window 2", false), ("window 1", true)]
7476 );
7477
7478 cx.simulate_window_activation(Some(window_3));
7479 assert_eq!(
7480 mem::take(&mut *events.borrow_mut()),
7481 [("window 1", false), ("window 3", true)]
7482 );
7483
7484 cx.simulate_window_activation(Some(window_3));
7485 assert_eq!(mem::take(&mut *events.borrow_mut()), []);
7486 }
7487}