1use super::*;
5
6use crate::accessibility::AccessNodeBuilder;
7
8impl WidgetTree {
9 pub fn attach_tooltip(
12 &mut self,
13 anchor_id: WidgetId,
14 content_id: WidgetId,
15 delay: std::time::Duration,
16 ) {
17 self.attach_tooltip_inner(
18 anchor_id,
19 content_id,
20 delay,
21 None,
22 None,
23 crate::overlay::TooltipPlacement::Below,
24 );
25 }
26
27 pub fn attach_tooltip_with_placement(
32 &mut self,
33 anchor_id: WidgetId,
34 content_id: WidgetId,
35 delay: std::time::Duration,
36 placement: crate::overlay::TooltipPlacement,
37 ) {
38 self.attach_tooltip_inner(anchor_id, content_id, delay, None, None, placement);
39 }
40
41 pub fn attach_tooltip_with_sticky(
53 &mut self,
54 anchor_id: WidgetId,
55 content_id: WidgetId,
56 delay: std::time::Duration,
57 sticky_after: Option<std::time::Duration>,
58 ) {
59 self.attach_tooltip_inner(
60 anchor_id,
61 content_id,
62 delay,
63 sticky_after,
64 None,
65 crate::overlay::TooltipPlacement::Below,
66 );
67 }
68
69 pub fn attach_tooltip_with_sticky_sink(
75 &mut self,
76 anchor_id: WidgetId,
77 content_id: WidgetId,
78 delay: std::time::Duration,
79 sticky_after: Option<std::time::Duration>,
80 shown_at_sink: std::rc::Rc<std::cell::Cell<Option<std::time::Instant>>>,
81 ) {
82 self.attach_tooltip_inner(
83 anchor_id,
84 content_id,
85 delay,
86 sticky_after,
87 Some(shown_at_sink),
88 crate::overlay::TooltipPlacement::Below,
89 );
90 }
91
92 pub fn attach_tooltip_with_sticky_sink_placement(
97 &mut self,
98 anchor_id: WidgetId,
99 content_id: WidgetId,
100 delay: std::time::Duration,
101 sticky_after: Option<std::time::Duration>,
102 shown_at_sink: std::rc::Rc<std::cell::Cell<Option<std::time::Instant>>>,
103 placement: crate::overlay::TooltipPlacement,
104 ) {
105 self.attach_tooltip_inner(
106 anchor_id,
107 content_id,
108 delay,
109 sticky_after,
110 Some(shown_at_sink),
111 placement,
112 );
113 }
114
115 fn retire_tooltips_for_anchor(&mut self, anchor_id: WidgetId, keep_content_id: WidgetId) {
130 let stale: Vec<(WidgetId, Option<crate::overlay::OverlayId>)> = self
131 .tooltips
132 .iter()
133 .filter(|entry| entry.anchor_id == anchor_id && entry.content_id != keep_content_id)
134 .map(|entry| (entry.content_id, entry.overlay_id))
135 .collect();
136 if stale.is_empty() {
137 return;
138 }
139 self.tooltips
140 .retain(|entry| entry.anchor_id != anchor_id || entry.content_id == keep_content_id);
141 for (content_id, overlay_id) in stale {
142 if let Some(overlay_id) = overlay_id {
146 self.dismiss_overlay(overlay_id);
147 }
148 self.destroy_subtree(content_id);
149 }
150 }
151
152 pub(super) fn retire_tooltips_of_destroyed_anchor(&mut self, anchor_id: WidgetId) {
159 let stale: Vec<(WidgetId, Option<crate::overlay::OverlayId>)> = self
160 .tooltips
161 .iter()
162 .filter(|entry| entry.anchor_id == anchor_id)
163 .map(|entry| (entry.content_id, entry.overlay_id))
164 .collect();
165 if stale.is_empty() {
166 return;
167 }
168 self.tooltips.retain(|entry| entry.anchor_id != anchor_id);
169 for (content_id, overlay_id) in stale {
170 if let Some(overlay_id) = overlay_id {
171 self.dismiss_overlay(overlay_id);
172 }
173 self.destroy_subtree(content_id);
174 }
175 }
176
177 fn attach_tooltip_inner(
178 &mut self,
179 anchor_id: WidgetId,
180 content_id: WidgetId,
181 delay: std::time::Duration,
182 sticky_after: Option<std::time::Duration>,
183 shown_at_sink: Option<std::rc::Rc<std::cell::Cell<Option<std::time::Instant>>>>,
184 placement: crate::overlay::TooltipPlacement,
185 ) {
186 self.retire_tooltips_for_anchor(anchor_id, content_id);
187 if let Some(entry) = self
190 .tooltips
191 .iter_mut()
192 .find(|entry| entry.anchor_id == anchor_id && entry.content_id == content_id)
193 {
194 entry.delay = delay;
195 entry.sticky_after = sticky_after;
196 entry.placement = placement;
197 if shown_at_sink.is_some() {
198 entry.shown_at_sink = shown_at_sink;
199 }
200 return;
201 }
202 self.arena.set_dormant(content_id);
203 self.tooltips.push(TooltipEntry {
204 anchor_id,
205 content_id,
206 description_owner_id: anchor_id,
210 delay,
211 hover_start: None,
212 real_hover_start: None,
213 hover_origin: None,
214 overlay_id: None,
215 sticky_after,
216 is_sticky: false,
217 shown_at_sim: None,
218 shown_at_real: None,
219 shown_at_sink,
220 promoted_by_focus: false,
221 dwell_promotes: false,
222 armed_by_focus: false,
223 armed_by_hold: false,
224 suppressed_until_focus_leaves: false,
225 placement,
226 });
227 }
228
229 pub(crate) fn set_tooltip_description_owner(
248 &mut self,
249 anchor_id: WidgetId,
250 owner_id: WidgetId,
251 ) {
252 if let Some(entry) = self
253 .tooltips
254 .iter_mut()
255 .find(|entry| entry.anchor_id == anchor_id)
256 {
257 entry.description_owner_id = owner_id;
258 }
259 }
260
261 fn tooltip_overlay_placement(
268 placement: crate::overlay::TooltipPlacement,
269 ) -> crate::overlay::OverlayPlacement {
270 match placement {
271 crate::overlay::TooltipPlacement::Below => {
272 crate::overlay::OverlayPlacement::NearAnchor {
273 offset: teksilo_canvas::Vec2::new(0.0, 8.0),
274 }
275 }
276 crate::overlay::TooltipPlacement::Side => {
277 crate::overlay::OverlayPlacement::TrailingEdge
278 }
279 }
280 }
281
282 pub(super) fn process_tooltips(&mut self) {
283 let sim_now = self.sim_clock;
284 let session_active = self.tooltip_session_active_sim(sim_now);
285 self.process_tooltips_impl(
286 |entry| {
287 entry
288 .hover_start
289 .map(|start| sim_now.saturating_duration_since(start))
290 },
291 session_active,
292 true,
293 );
294 }
295
296 pub(super) fn process_tooltips_real(&mut self) {
297 let real_now = std::time::Instant::now();
298 let session_active = self.tooltip_session_active_real(real_now);
299 self.process_tooltips_impl(
300 |entry| {
301 entry
302 .real_hover_start
303 .map(|start| real_now.saturating_duration_since(start))
304 },
305 session_active,
306 false,
307 );
308 }
309
310 fn any_tooltip_in_session(&self) -> bool {
319 self.tooltips
320 .iter()
321 .any(|e| e.overlay_id.is_some() && !e.is_sticky)
322 }
323
324 fn tooltip_session_active_sim(&self, now: std::time::Instant) -> bool {
326 self.any_tooltip_in_session()
327 || self
328 .tooltip_session_until_sim
329 .is_some_and(|until| now < until)
330 }
331
332 fn tooltip_session_active_real(&self, now: std::time::Instant) -> bool {
334 self.any_tooltip_in_session()
335 || self
336 .tooltip_session_until_real
337 .is_some_and(|until| now < until)
338 }
339
340 fn effective_tooltip_delay(
354 &self,
355 entry_delay: std::time::Duration,
356 session_active: bool,
357 ) -> std::time::Duration {
358 if !session_active {
359 return entry_delay;
360 }
361 let motion = &self.theme.motion;
362 let base = motion.tooltip_delay.as_secs_f64();
363 if base <= 0.0 {
364 return entry_delay.min(motion.tooltip_reshow_delay);
367 }
368 let ratio = motion.tooltip_reshow_delay.as_secs_f64() / base;
369 entry_delay.mul_f64(ratio).min(entry_delay)
371 }
372
373 fn process_tooltips_impl(
374 &mut self,
375 elapsed_fn: impl Fn(&TooltipEntry) -> Option<std::time::Duration>,
376 session_active: bool,
377 use_sim_clock: bool,
378 ) {
379 let dismissed_indices: Vec<usize> = self
385 .tooltips
386 .iter()
387 .enumerate()
388 .filter_map(|(i, e)| match e.overlay_id {
389 Some(oid) if !self.overlay_manager.stack.iter().any(|o| o.id == oid) => Some(i),
390 _ => None,
391 })
392 .collect();
393 let any_dismissed = !dismissed_indices.is_empty();
394 for i in dismissed_indices {
395 let e = &mut self.tooltips[i];
396 e.overlay_id = None;
397 e.is_sticky = false;
398 e.promoted_by_focus = false;
399 e.armed_by_hold = false;
400 e.shown_at_sim = None;
401 e.shown_at_real = None;
402 e.hover_origin = None;
403 if let Some(sink) = e.shown_at_sink.as_ref() {
404 sink.set(None);
405 }
406 }
407 if any_dismissed {
410 let grace = super::TOOLTIP_SESSION_GRACE;
411 if use_sim_clock {
412 self.tooltip_session_until_sim = Some(self.sim_clock + grace);
413 } else {
414 self.tooltip_session_until_real = Some(std::time::Instant::now() + grace);
415 }
416 }
417
418 let session_active = session_active
423 || self.any_tooltip_in_session()
424 || if use_sim_clock {
425 self.tooltip_session_active_sim(self.sim_clock)
426 } else {
427 self.tooltip_session_active_real(std::time::Instant::now())
428 };
429
430 let mut to_show = Vec::new();
431 let pending: Vec<usize> = self
434 .tooltips
435 .iter()
436 .enumerate()
437 .filter(|(_, entry)| entry.overlay_id.is_none())
438 .filter(|(_, entry)| self.arena.is_active(entry.anchor_id))
439 .filter_map(|(i, entry)| {
440 let delay = self.effective_tooltip_delay(entry.delay, session_active);
441 let elapsed = elapsed_fn(entry)?;
442 (elapsed >= delay).then_some(i)
443 })
444 .collect();
445 for index in pending {
446 let content_id = self.tooltips[index].content_id;
451 self.materialize_deferred(content_id);
452 let body_id = self.tooltip_content_node(content_id);
463 if !self
464 .arena
465 .get(body_id)
466 .is_none_or(|node| node.widget.tooltip_has_content())
467 {
468 let entry = &mut self.tooltips[index];
469 entry.hover_start = None;
470 entry.real_hover_start = None;
471 entry.hover_origin = None;
472 continue;
473 }
474 let entry = &mut self.tooltips[index];
475 to_show.push((
476 entry.anchor_id,
477 entry.content_id,
478 entry.placement,
479 entry.armed_by_focus,
480 entry.armed_by_hold,
481 ));
482 entry.hover_start = None;
483 entry.real_hover_start = None;
484 entry.hover_origin = None;
485 }
486 let sim_now = self.sim_clock;
487 let real_now = std::time::Instant::now();
488 let fade_duration = if self.prefers_reduced_motion || session_active {
495 None
496 } else {
497 Some(self.theme.motion.duration_fast)
498 };
499 for (anchor_id, content_id, placement, by_focus, by_hold) in to_show {
500 self.arena.activate(content_id);
501 let dismiss = if by_focus || by_hold {
510 crate::overlay::DismissBehavior::EscapeOrClickOutside
511 } else {
512 crate::overlay::DismissBehavior::PointerLeave {
513 delay: std::time::Duration::from_millis(100),
514 }
515 };
516 let mut request = crate::overlay::OverlayRequest::new(
517 content_id,
518 anchor_id,
519 Self::tooltip_overlay_placement(placement),
520 dismiss,
521 );
522 request.fade_duration = fade_duration;
523 let oid = if by_hold {
524 self.show_overlay_for(request, super::touch_route::TOUCH_TOOLTIP_DISMISS)
525 } else {
526 self.show_overlay(request)
527 };
528 if by_focus && let Some(focused) = self.focused {
529 self.record_top_focus_restore(focused);
530 }
531 if let Some(entry) = self
532 .tooltips
533 .iter_mut()
534 .find(|e| e.content_id == content_id)
535 {
536 entry.overlay_id = Some(oid);
537 entry.shown_at_sim = Some(sim_now);
538 entry.shown_at_real = Some(real_now);
539 entry.promoted_by_focus = by_focus;
540 entry.dwell_promotes = !by_focus;
543 if let Some(sink) = entry.shown_at_sink.as_ref() {
544 sink.set((!by_focus).then_some(real_now));
545 }
546 }
547 }
548
549 let mut to_mark_paint: Vec<WidgetId> = Vec::new();
563 let mut to_promote: Vec<WidgetId> = Vec::new();
564 for entry in &self.tooltips {
565 let Some(sticky_after) = entry.sticky_after else {
566 continue;
567 };
568 if entry.overlay_id.is_none() || entry.is_sticky || !entry.dwell_promotes {
569 continue;
570 }
571 let elapsed = entry
572 .shown_at_real
573 .map(|t| real_now.saturating_duration_since(t));
574 let elapsed = match elapsed {
575 Some(e) => e,
576 None => continue,
577 };
578 to_mark_paint.push(entry.content_id);
582 if elapsed >= sticky_after {
583 to_promote.push(entry.content_id);
584 }
585 }
586 for id in to_mark_paint {
587 self.arena.mark_subtree_needs_paint(id);
588 }
589 for content_id in to_promote {
590 self.promote_tooltip_to_sticky(content_id);
591 }
592 }
593
594 pub(super) fn process_delayed_overlays(&mut self) {
595 let sim_now = self.sim_clock;
596 let mut noop = crate::window::NoopWindowOps;
597 self.process_delayed_overlays_impl(
598 |p| sim_now.saturating_duration_since(p.sim_requested_at),
599 &mut noop,
600 );
601 }
602
603 pub(super) fn process_delayed_overlays_real(&mut self, ops: &mut dyn crate::window::WindowOps) {
604 let real_now = std::time::Instant::now();
605 self.process_delayed_overlays_impl(
606 |p| real_now.saturating_duration_since(p.real_requested_at),
607 &mut *ops,
608 );
609 }
610
611 fn process_delayed_overlays_impl(
612 &mut self,
613 elapsed_fn: impl Fn(&PendingDelayedOverlay) -> std::time::Duration,
614 ops: &mut dyn crate::window::WindowOps,
615 ) {
616 let mut ready_indices = Vec::new();
617 for (index, pending) in self.pending_delayed_overlays.iter().enumerate() {
618 if elapsed_fn(pending) >= pending.delay {
619 ready_indices.push(index);
620 }
621 }
622
623 let mut ready = Vec::new();
624 for &index in ready_indices.iter().rev() {
625 ready.push(self.pending_delayed_overlays.remove(index));
626 }
627 ready.reverse();
628
629 let any_shown = !ready.is_empty();
630 for pending in ready {
631 let content_id = pending.request.content_id;
632 if pending.replace_siblings {
639 let anchor = pending.request.anchor;
640 self.dismiss_child_overlays_for_source(anchor, Some(content_id), &mut *ops);
641 }
642 self.arena.activate(content_id);
643 let current_focus = self.focused;
644 self.overlay_manager.show(pending.request);
645 if let Some(focus_id) = current_focus {
646 self.record_top_focus_restore(focus_id);
647 }
648 self.arena.mark_needs_paint(content_id);
649 if let Some(focus_target) = pending.focus_target
653 && self.arena.is_active(focus_target)
654 {
655 let target = self.exact_focus_target(focus_target);
656 self.focus_ops(target, &mut *ops);
657 }
658 }
659 if any_shown {
660 self.a11y_dirty = true;
661 }
662 }
663
664 pub(super) fn overlay_ancestor_for_widget(
665 &self,
666 widget_id: WidgetId,
667 ) -> Option<crate::overlay::OverlayId> {
668 self.overlay_manager
669 .stack
670 .iter()
671 .rev()
672 .find(|overlay| self.is_descendant_of(widget_id, overlay.content_id))
673 .map(|overlay| overlay.id)
674 }
675
676 pub(super) fn modal_overlay_for_widget(
677 &self,
678 widget_id: WidgetId,
679 ) -> Option<crate::overlay::OverlayId> {
680 let mut current = self.overlay_ancestor_for_widget(widget_id);
681
682 while let Some(overlay_id) = current {
683 let overlay = self.overlay_manager.overlay(overlay_id)?;
684 if overlay.placement.is_modal() {
685 return Some(overlay_id);
686 }
687 current = overlay.parent_overlay;
688 }
689
690 None
691 }
692
693 pub fn is_behind_modal(&self, widget_id: WidgetId) -> bool {
721 let Some(modal) = self.overlay_manager.topmost_modal() else {
722 return false;
723 };
724 let stack = &self.overlay_manager.stack;
725 let Some(at) = stack.iter().position(|overlay| overlay.id == modal.id) else {
726 return false;
727 };
728 let (below, above) = stack.split_at(at);
729 let in_modal = |id: WidgetId| {
730 above
731 .iter()
732 .any(|overlay| self.is_descendant_of(id, overlay.content_id))
733 };
734 !(in_modal(widget_id)
735 || below.iter().any(|overlay| {
736 self.is_descendant_of(widget_id, overlay.content_id) && in_modal(overlay.anchor)
737 }))
738 }
739
740 fn menu_ancestor_for_widget(&self, widget_id: WidgetId) -> Option<WidgetId> {
741 let mut current = Some(widget_id);
742 while let Some(id) = current {
743 if let Some(node) = self.arena.get(id) {
744 let mut builder = AccessNodeBuilder::new();
745 node.widget.accessibility(&mut builder);
746 if builder.role() == accesskit::Role::Menu {
747 return Some(id);
748 }
749 }
750 current = self.arena.parent(id);
751 }
752 None
753 }
754
755 pub(super) fn dismiss_child_overlays_for_source(
756 &mut self,
757 source_widget: WidgetId,
758 preserve_content: Option<WidgetId>,
759 ops: &mut dyn crate::window::WindowOps,
760 ) {
761 if let Some(parent_overlay) = self.overlay_ancestor_for_widget(source_widget) {
762 let preserve_overlay = preserve_content
763 .and_then(|content_id| self.overlay_manager.find_by_content(content_id));
764 let mark = self.dismissal_mark();
765 let (dismissed, focus_restore) = self
766 .overlay_manager
767 .dismiss_descendants_of(parent_overlay, preserve_overlay);
768 self.dormant_dismissed_content(&dismissed, &mut *ops);
769 self.return_focus_after_dismissal(focus_restore, mark, &mut *ops);
770 return;
771 }
772
773 let Some(menu_root) = self.menu_ancestor_for_widget(source_widget) else {
774 return;
775 };
776 let preserve_overlay = preserve_content
777 .and_then(|content_id| self.overlay_manager.find_by_content(content_id));
778 let overlay_ids: Vec<crate::overlay::OverlayId> = self
779 .overlay_manager
780 .stack
781 .iter()
782 .filter(|overlay| {
783 overlay.parent_overlay.is_none()
784 && self.is_descendant_of(overlay.anchor, menu_root)
785 && !preserve_overlay.is_some_and(|keep| {
786 overlay.id == keep
787 || self.overlay_manager.is_descendant_of(overlay.id, keep)
788 })
789 })
790 .map(|overlay| overlay.id)
791 .collect();
792
793 for overlay_id in overlay_ids {
794 let mark = self.dismissal_mark();
795 let (dismissed, focus_restore) =
796 self.overlay_manager.dismiss_with_focus_restore(overlay_id);
797 self.dormant_dismissed_content(&dismissed, &mut *ops);
798 self.return_focus_after_dismissal(focus_restore, mark, &mut *ops);
799 }
800 }
801
802 pub(super) fn dismiss_self_overlay_chain_for_source(
814 &mut self,
815 source_widget: WidgetId,
816 ops: &mut dyn crate::window::WindowOps,
817 ) {
818 let Some(start) = self.overlay_ancestor_for_widget(source_widget) else {
819 return;
820 };
821
822 let mut topmost_to_dismiss: Option<crate::overlay::OverlayId> = None;
823 let mut current = Some(start);
824 while let Some(overlay_id) = current {
825 let Some(overlay) = self.overlay_manager.overlay(overlay_id) else {
826 break;
827 };
828 if self.overlay_is_host_surface(overlay_id) {
829 break;
830 }
831 topmost_to_dismiss = Some(overlay_id);
832 current = overlay.parent_overlay;
833 }
834
835 if let Some(target) = topmost_to_dismiss {
836 let mark = self.dismissal_mark();
837 let (dismissed, focus_restore) =
838 self.overlay_manager.dismiss_with_focus_restore(target);
839 self.dormant_dismissed_content(&dismissed, &mut *ops);
840 self.return_focus_after_dismissal(focus_restore, mark, &mut *ops);
841 }
842 }
843
844 fn overlay_is_anchor_positioned(placement: &crate::overlay::OverlayPlacement) -> bool {
861 use crate::overlay::OverlayPlacement as P;
862 match placement {
863 P::Below
864 | P::Above
865 | P::TrailingEdge
866 | P::AtPointer(_)
867 | P::AtPointerAvoiding { .. }
868 | P::NearAnchor { .. }
869 | P::BelowPreferred => true,
870 P::Centered
876 | P::TopCenter { .. }
877 | P::BottomCenter
878 | P::ViewportCorner { .. }
879 | P::FullViewport
880 | P::AboveSelection { .. }
881 | P::BelowSelection { .. } => false,
882 }
883 }
884
885 fn overlay_follows_focus_out(&self, overlay_id: crate::overlay::OverlayId) -> bool {
925 let Some(overlay) = self.overlay_manager.overlay(overlay_id) else {
926 return false;
927 };
928 if !Self::overlay_is_anchor_positioned(&overlay.placement) {
929 return false;
930 }
931 if overlay.is_dismissing() {
932 return false;
933 }
934 if overlay.inert {
935 return false;
936 }
937 !self
938 .tooltips
939 .iter()
940 .any(|entry| entry.content_id == overlay.content_id)
941 }
942
943 fn overlay_orbit_for_widget(&self, widget_id: WidgetId) -> Option<crate::overlay::OverlayId> {
966 self.overlay_manager
967 .stack
968 .iter()
969 .rev()
970 .find(|overlay| {
971 self.is_descendant_of(widget_id, overlay.content_id)
972 || (self.overlay_follows_focus_out(overlay.id)
973 && self.is_descendant_of(widget_id, overlay.anchor))
974 })
975 .map(|overlay| overlay.id)
976 }
977
978 pub(super) fn dismiss_overlays_left_by_focus(
1005 &mut self,
1006 old: Option<WidgetId>,
1007 new_focus: Option<WidgetId>,
1008 ops: &mut dyn crate::window::WindowOps,
1009 ) {
1010 let Some(old) = old else {
1011 return;
1012 };
1013 let Some(old_overlay) = self.overlay_orbit_for_widget(old) else {
1014 return;
1015 };
1016 let new_overlay = new_focus.and_then(|id| self.overlay_ancestor_for_widget(id));
1024
1025 if let Some(new_overlay) = new_overlay
1028 && (new_overlay == old_overlay
1029 || self
1030 .overlay_manager
1031 .is_descendant_of(new_overlay, old_overlay))
1032 {
1033 return;
1034 }
1035
1036 if !self.overlay_follows_focus_out(old_overlay) {
1037 return;
1038 }
1039
1040 let mut topmost = old_overlay;
1041 let mut current = self
1042 .overlay_manager
1043 .overlay(old_overlay)
1044 .and_then(|overlay| overlay.parent_overlay);
1045 while let Some(overlay_id) = current {
1046 if Some(overlay_id) == new_overlay {
1050 break;
1051 }
1052 if self.overlay_is_host_surface(overlay_id) {
1055 break;
1056 }
1057 if !self.overlay_follows_focus_out(overlay_id) {
1058 break;
1059 }
1060 topmost = overlay_id;
1061 current = self
1062 .overlay_manager
1063 .overlay(overlay_id)
1064 .and_then(|overlay| overlay.parent_overlay);
1065 }
1066
1067 let dismissed = self.overlay_manager.dismiss(topmost);
1068 self.dormant_dismissed_content(&dismissed, &mut *ops);
1069 }
1070
1071 pub(super) fn dismiss_all_overlays_except_hosts(
1085 &mut self,
1086 ops: &mut dyn crate::window::WindowOps,
1087 ) {
1088 let to_dismiss: Vec<crate::overlay::OverlayId> = self
1089 .overlay_manager
1090 .stack
1091 .iter()
1092 .map(|overlay| overlay.id)
1093 .filter(|&id| !self.overlay_is_host_surface(id))
1094 .collect();
1095
1096 let mark = self.dismissal_mark();
1104 let mut restore = None;
1105 for overlay_id in to_dismiss {
1106 let (dismissed, focus_restore) =
1107 self.overlay_manager.dismiss_with_focus_restore(overlay_id);
1108 self.dormant_dismissed_content(&dismissed, &mut *ops);
1109 restore = restore.or(focus_restore);
1110 }
1111 if mark.focused_before().is_some() && self.focus_left_nowhere() {
1114 self.return_focus_after_dismissal(restore, mark, &mut *ops);
1115 }
1116 }
1117
1118 pub(super) fn overlay_is_host_surface(&self, overlay_id: crate::overlay::OverlayId) -> bool {
1124 let Some(overlay) = self.overlay_manager.overlay(overlay_id) else {
1125 return false;
1126 };
1127 if overlay.placement.is_modal() {
1136 return true;
1137 }
1138 let Some(node) = self.arena.get(overlay.content_id) else {
1139 return false;
1140 };
1141 let role = node
1149 .access_overrides
1150 .as_ref()
1151 .and_then(|o| o.role)
1152 .unwrap_or_else(|| {
1153 let mut builder = AccessNodeBuilder::new();
1154 node.widget.accessibility(&mut builder);
1155 builder.role()
1156 });
1157 matches!(
1158 role,
1159 accesskit::Role::Tooltip
1160 | accesskit::Role::Dialog
1161 | accesskit::Role::AlertDialog
1162 | accesskit::Role::MenuBar
1163 )
1164 }
1165
1166 pub(super) fn dismiss_modal_for_source(
1167 &mut self,
1168 source_widget: WidgetId,
1169 ops: &mut dyn crate::window::WindowOps,
1170 ) -> bool {
1171 let Some(modal_overlay) = self.modal_overlay_for_widget(source_widget) else {
1172 return false;
1173 };
1174
1175 let mark = self.dismissal_mark();
1176 let (dismissed, focus_restore) = self
1177 .overlay_manager
1178 .dismiss_with_focus_restore(modal_overlay);
1179 self.dormant_dismissed_content(&dismissed, &mut *ops);
1180 self.return_focus_after_dismissal(focus_restore, mark, &mut *ops);
1181 true
1182 }
1183
1184 pub fn is_descendant_of(&self, widget_id: WidgetId, ancestor: WidgetId) -> bool {
1185 if widget_id == ancestor {
1186 return true;
1187 }
1188 let mut current = self.arena.parent(widget_id);
1189 while let Some(parent_id) = current {
1190 if parent_id == ancestor {
1191 return true;
1192 }
1193 current = self.arena.parent(parent_id);
1194 }
1195 false
1196 }
1197
1198 fn is_overlay_content_root(&self, widget_id: WidgetId) -> bool {
1205 self.overlay_manager.find_by_content(widget_id).is_some()
1206 }
1207
1208 pub(super) fn tooltip_focus_enter(&mut self, widget_id: WidgetId) {
1236 type ToShow = (WidgetId, WidgetId, crate::overlay::TooltipPlacement);
1259 let mut direct: Vec<ToShow> = Vec::new();
1260 let mut reverse: Vec<ToShow> = Vec::new();
1261 for e in &self.tooltips {
1262 if e.sticky_after.is_none() || e.overlay_id.is_some() || e.suppressed_until_focus_leaves
1263 {
1264 continue;
1265 }
1266 if self.is_descendant_of(widget_id, e.anchor_id) {
1267 direct.push((e.anchor_id, e.content_id, e.placement));
1268 } else if self.is_descendant_of(e.anchor_id, widget_id) {
1269 reverse.push((e.anchor_id, e.content_id, e.placement));
1270 }
1271 }
1272 let mut to_show = direct;
1273 if reverse.len() == 1 && !self.is_overlay_content_root(widget_id) {
1277 to_show.extend(reverse);
1278 }
1279
1280 let sim_now = self.sim_clock;
1289 let real_now = std::time::Instant::now();
1290 for (_anchor_id, content_id, _placement) in to_show {
1291 if let Some(entry) = self
1292 .tooltips
1293 .iter_mut()
1294 .find(|e| e.content_id == content_id)
1295 {
1296 entry.hover_start = Some(sim_now);
1297 entry.real_hover_start = Some(real_now);
1298 entry.hover_origin = None;
1299 entry.armed_by_focus = true;
1300 entry.armed_by_hold = false;
1301 }
1302 }
1303 }
1304
1305 pub(super) fn show_highlight_tooltip(
1315 &mut self,
1316 item_id: WidgetId,
1317 ops: &mut dyn crate::window::WindowOps,
1318 ) {
1319 self.clear_highlight_tooltip(&mut *ops);
1322
1323 let found = self.tooltips.iter().find_map(|e| {
1327 if e.overlay_id.is_none() && self.is_descendant_of(e.anchor_id, item_id) {
1328 Some((e.anchor_id, e.content_id, e.placement))
1329 } else {
1330 None
1331 }
1332 });
1333 let Some((anchor_id, content_id, placement)) = found else {
1334 return;
1335 };
1336
1337 let parent_overlay = self.overlay_ancestor_for_widget(item_id);
1338 self.arena.activate(content_id);
1339 let fade_duration = if self.prefers_reduced_motion {
1340 None
1341 } else {
1342 Some(self.theme.motion.duration_fast)
1343 };
1344 let mut request = crate::overlay::OverlayRequest::new(
1345 content_id,
1346 anchor_id,
1347 Self::tooltip_overlay_placement(placement),
1348 crate::overlay::DismissBehavior::Manual,
1349 );
1350 request.parent_overlay = parent_overlay;
1351 request.fade_duration = fade_duration;
1352 let oid = self.show_overlay(request);
1353 let real_now = std::time::Instant::now();
1354 let sim_now = self.sim_clock;
1355 if let Some(entry) = self
1356 .tooltips
1357 .iter_mut()
1358 .find(|e| e.content_id == content_id)
1359 {
1360 entry.overlay_id = Some(oid);
1361 entry.shown_at_sim = Some(sim_now);
1362 entry.shown_at_real = Some(real_now);
1363 if let Some(sink) = entry.shown_at_sink.as_ref() {
1364 sink.set(Some(real_now));
1365 }
1366 }
1367 self.highlight_tooltip = Some((oid, content_id));
1368 }
1369
1370 pub(super) fn clear_highlight_tooltip(&mut self, ops: &mut dyn crate::window::WindowOps) {
1375 let Some((oid, content_id)) = self.highlight_tooltip.take() else {
1376 return;
1377 };
1378 if self.overlay_manager.stack.iter().any(|o| o.id == oid) {
1379 let dismissed = self.overlay_manager.dismiss(oid);
1380 self.dormant_dismissed_content(&dismissed, &mut *ops);
1381 }
1382 if let Some(entry) = self
1383 .tooltips
1384 .iter_mut()
1385 .find(|e| e.content_id == content_id)
1386 {
1387 entry.overlay_id = None;
1388 entry.shown_at_sim = None;
1389 entry.shown_at_real = None;
1390 if let Some(sink) = entry.shown_at_sink.as_ref() {
1391 sink.set(None);
1392 }
1393 }
1394 }
1395
1396 pub(super) fn tooltip_focus_leave_outside(
1407 &mut self,
1408 new_focus: Option<WidgetId>,
1409 ops: &mut dyn crate::window::WindowOps,
1410 ) {
1411 let to_dismiss: Vec<crate::overlay::OverlayId> = self
1412 .tooltips
1413 .iter()
1414 .filter(|e| e.promoted_by_focus && e.overlay_id.is_some())
1415 .filter(|e| {
1416 let in_scope = new_focus
1417 .map(|nf| {
1418 self.is_descendant_of(nf, e.anchor_id)
1423 || self.is_descendant_of(e.anchor_id, nf)
1424 || self.is_descendant_of(nf, e.content_id)
1425 })
1426 .unwrap_or(false);
1427 !in_scope
1428 })
1429 .filter_map(|e| e.overlay_id)
1430 .collect();
1431
1432 for oid in to_dismiss {
1433 let dismissed = self.overlay_manager.dismiss(oid);
1434 self.dormant_dismissed_content(&dismissed, &mut *ops);
1435 }
1436
1437 for e in &mut self.tooltips {
1440 if e.armed_by_focus && e.overlay_id.is_none() {
1441 e.hover_start = None;
1442 e.real_hover_start = None;
1443 e.armed_by_focus = false;
1444 }
1445 }
1446
1447 let served: Vec<usize> = self
1451 .tooltips
1452 .iter()
1453 .enumerate()
1454 .filter(|(_, e)| e.suppressed_until_focus_leaves)
1455 .filter(|(_, e)| {
1456 let still_inside = new_focus
1457 .map(|nf| {
1458 self.is_descendant_of(nf, e.anchor_id)
1459 || self.is_descendant_of(nf, e.content_id)
1460 })
1461 .unwrap_or(false);
1462 !still_inside
1463 })
1464 .map(|(i, _)| i)
1465 .collect();
1466 for i in served {
1467 self.tooltips[i].suppressed_until_focus_leaves = false;
1468 }
1469 }
1470
1471 fn tooltip_hover_targets_anchor(&self, widget_id: WidgetId, anchor_id: WidgetId) -> bool {
1491 if !self.is_descendant_of(widget_id, anchor_id) {
1492 return false;
1493 }
1494 if let Some(overlay_id) = self.overlay_ancestor_for_widget(widget_id)
1495 && let Some(content_id) = self
1496 .overlay_manager
1497 .overlay(overlay_id)
1498 .map(|o| o.content_id)
1499 && !self.is_descendant_of(anchor_id, content_id)
1500 {
1501 return false;
1502 }
1503 true
1504 }
1505
1506 pub(super) fn tooltip_index_for(&self, widget_id: WidgetId) -> Option<usize> {
1524 self.tooltips
1525 .iter()
1526 .enumerate()
1527 .filter(|(_, entry)| self.tooltip_hover_targets_anchor(widget_id, entry.anchor_id))
1528 .filter_map(|(index, entry)| {
1529 self.ancestor_distance(widget_id, entry.anchor_id)
1530 .map(|depth| (depth, index))
1531 })
1532 .min()
1533 .map(|(_, index)| index)
1534 }
1535
1536 pub(super) fn tooltip_pointer_enter(&mut self, widget_id: WidgetId) {
1537 let Some(index) = self.tooltip_index_for(widget_id) else {
1538 return;
1539 };
1540 if self.tooltips[index].overlay_id.is_some() {
1544 let entry = &mut self.tooltips[index];
1545 if entry.promoted_by_focus && !entry.is_sticky && !entry.dwell_promotes {
1546 let real_now = std::time::Instant::now();
1547 entry.dwell_promotes = true;
1548 entry.shown_at_sim = Some(self.sim_clock);
1549 entry.shown_at_real = Some(real_now);
1550 if let Some(sink) = entry.shown_at_sink.as_ref() {
1551 sink.set(Some(real_now));
1552 }
1553 }
1554 return;
1555 }
1556 self.tooltips[index].hover_start = Some(self.sim_clock);
1557 self.tooltips[index].real_hover_start = Some(std::time::Instant::now());
1558 self.tooltips[index].hover_origin = self.hover_owner_position();
1559 self.tooltips[index].armed_by_focus = false;
1560 self.tooltips[index].armed_by_hold = false;
1561 self.arena.mark_needs_paint(self.tooltips[index].anchor_id);
1562 }
1563
1564 fn ancestor_distance(&self, widget_id: WidgetId, ancestor: WidgetId) -> Option<usize> {
1567 let mut current = widget_id;
1568 let mut depth = 0usize;
1569 loop {
1570 if current == ancestor {
1571 return Some(depth);
1572 }
1573 current = self.arena.parent(current)?;
1574 depth += 1;
1575 }
1576 }
1577
1578 pub(super) fn tooltip_pointer_press(&mut self, at: Option<teksilo_canvas::Point>) {
1593 if at.is_some() {
1596 self.tooltip_dwell_held = true;
1597 }
1598 let mut to_dismiss = Vec::new();
1599 let candidates: Vec<(usize, Option<crate::overlay::OverlayId>)> = self
1600 .tooltips
1601 .iter()
1602 .enumerate()
1603 .map(|(i, e)| (i, if e.is_sticky { None } else { e.overlay_id }))
1604 .collect();
1605 for (index, overlay_id) in candidates {
1606 let body = self.tooltip_content_node(self.tooltips[index].content_id);
1613 let takes_hits = !self
1614 .arena
1615 .get(body)
1616 .is_some_and(|node| node.hit_transparent);
1617 let inside = match (overlay_id, at) {
1618 (Some(oid), Some(pos)) => {
1619 takes_hits
1620 && self
1621 .overlay_content_bounds(oid)
1622 .is_some_and(|rect| rect.contains(pos))
1623 }
1624 _ => false,
1625 };
1626 if inside {
1627 continue;
1628 }
1629 let entry = &mut self.tooltips[index];
1630 entry.hover_start = None;
1631 entry.real_hover_start = None;
1632 entry.hover_origin = None;
1633 if let Some(oid) = overlay_id {
1634 to_dismiss.push(oid);
1635 }
1636 }
1637 for overlay_id in to_dismiss {
1638 self.dismiss_overlay(overlay_id);
1639 }
1640 }
1641
1642 pub(super) fn tooltip_escape_pressed(&mut self) {
1664 self.tooltip_pointer_press(None);
1667 }
1668
1669 pub(super) fn inert_overlays_escape_pressed(&mut self, ops: &mut dyn crate::window::WindowOps) {
1680 let dismissed = self.overlay_manager.dismiss_inert_on_escape();
1681 if !dismissed.is_empty() {
1682 self.dormant_dismissed_content(&dismissed, &mut *ops);
1683 self.a11y_dirty = true;
1684 }
1685 }
1686
1687 pub(super) fn tooltip_window_deactivated(&mut self) {
1694 self.tooltip_pointer_press(None);
1697 }
1698
1699 pub(crate) fn tooltip_cancel_pending_dwell(&mut self) {
1707 for entry in &mut self.tooltips {
1708 if entry.overlay_id.is_none() {
1709 entry.hover_start = None;
1710 entry.real_hover_start = None;
1711 entry.hover_origin = None;
1712 }
1713 }
1714 }
1715
1716 pub(super) fn tooltip_pointer_moved(
1720 &mut self,
1721 widget_id: WidgetId,
1722 position: teksilo_canvas::Point,
1723 ) {
1724 let matching: Vec<usize> = self
1725 .tooltips
1726 .iter()
1727 .enumerate()
1728 .filter(|(_, entry)| {
1729 entry.overlay_id.is_none()
1730 && entry.hover_start.is_some()
1731 && !entry.armed_by_focus
1732 && self.tooltip_hover_targets_anchor(widget_id, entry.anchor_id)
1733 })
1734 .map(|(index, _)| index)
1735 .collect();
1736 if matching.is_empty() {
1737 return;
1738 }
1739 let now = self.sim_clock;
1740 let real_now = std::time::Instant::now();
1741 let slop = super::TOOLTIP_STATIONARY_SLOP;
1742 let slop_sq = slop * slop;
1743 for index in matching {
1744 let origin = match self.tooltips[index].hover_origin {
1745 Some(o) => o,
1746 None => {
1747 self.tooltips[index].hover_origin = Some(position);
1751 continue;
1752 }
1753 };
1754 let dx = position.x - origin.x;
1755 let dy = position.y - origin.y;
1756 if dx * dx + dy * dy <= slop_sq {
1757 continue;
1758 }
1759 self.tooltips[index].hover_start = Some(now);
1761 self.tooltips[index].real_hover_start = Some(real_now);
1762 self.tooltips[index].hover_origin = Some(position);
1763 }
1764 }
1765
1766 pub fn promote_tooltip_to_sticky(&mut self, content_id: WidgetId) {
1784 let Some(entry) = self
1785 .tooltips
1786 .iter_mut()
1787 .find(|entry| entry.content_id == content_id)
1788 else {
1789 return;
1790 };
1791 if entry.is_sticky {
1792 return;
1793 }
1794 entry.is_sticky = true;
1795 let overlay_id = entry.overlay_id;
1796 if let Some(overlay_id) = overlay_id {
1797 self.overlay_manager.set_dismiss(
1798 overlay_id,
1799 crate::overlay::DismissBehavior::EscapeOrClickOutside,
1800 );
1801 }
1802 }
1803
1804 pub(super) fn tooltip_pointer_leave(
1805 &mut self,
1806 widget_id: WidgetId,
1807 _ops: &mut dyn crate::window::WindowOps,
1808 ) {
1809 let matching: Vec<usize> = self
1810 .tooltips
1811 .iter()
1812 .enumerate()
1813 .filter(|(_, entry)| self.is_descendant_of(widget_id, entry.anchor_id))
1814 .map(|(index, _)| index)
1815 .collect();
1816 for index in matching {
1817 let entry = &mut self.tooltips[index];
1821 if entry.promoted_by_focus && !entry.is_sticky && entry.dwell_promotes {
1822 entry.dwell_promotes = false;
1823 if let Some(sink) = entry.shown_at_sink.as_ref() {
1824 sink.set(None);
1825 }
1826 }
1827 self.tooltips[index].hover_start = None;
1830 self.tooltips[index].real_hover_start = None;
1831 self.tooltips[index].hover_origin = None;
1832 }
1844 }
1845
1846 pub fn next_timer_deadline(&self) -> Option<std::time::Instant> {
1852 self.next_timer_deadline_source().map(|(at, _)| at)
1853 }
1854
1855 #[doc(hidden)]
1863 pub fn next_timer_deadline_source(&self) -> Option<(std::time::Instant, &'static str)> {
1864 let now = std::time::Instant::now();
1865 let session_active = self.tooltip_session_active_real(now);
1866 let tooltip_deadline = self
1867 .tooltips
1868 .iter()
1869 .filter(|entry| entry.overlay_id.is_none())
1870 .filter_map(|entry| {
1871 let start = entry.real_hover_start?;
1872 let delay = self.effective_tooltip_delay(entry.delay, session_active);
1873 Some(start + delay)
1874 })
1875 .min();
1876
1877 let ref_time = self.last_frame_time.unwrap_or_else(std::time::Instant::now);
1898 let dwell_tooltip_deadline = self
1899 .tooltips
1900 .iter()
1901 .filter_map(|entry| {
1902 let sticky_after = entry.sticky_after?;
1903 let shown_at = entry.shown_at_real?;
1904 if entry.overlay_id.is_none() || entry.is_sticky || !entry.dwell_promotes {
1905 return None;
1906 }
1907 let dwell_step = sticky_after / super::TOOLTIP_DWELL_STEPS;
1908 if dwell_step.is_zero() {
1909 return None;
1910 }
1911 let elapsed = ref_time.saturating_duration_since(shown_at);
1912 if elapsed >= sticky_after {
1913 return None;
1914 }
1915 let steps_passed = (elapsed.as_millis() / dwell_step.as_millis()) as u32;
1918 let next_step_at = shown_at + dwell_step * (steps_passed + 1);
1919 Some(next_step_at.min(shown_at + sticky_after))
1920 })
1921 .min();
1922 let delayed_overlay_deadline = self
1923 .pending_delayed_overlays
1924 .iter()
1925 .map(|pending| pending.real_requested_at + pending.delay)
1926 .min();
1927 let auto_dismiss_deadline = self.overlay_manager.next_auto_dismiss_deadline();
1928 let pointer_leave_deadline = self.overlay_manager.next_pointer_leave_deadline();
1935 let fade_dismiss_deadline = self.overlay_manager.next_fade_dismiss_deadline();
1942 let animation_deadline = self
1943 .animation_scheduler
1944 .next_deadline(&self.arena, self.paint_epoch);
1945 let animated_quad_deadline = self
1950 .animated_quads
1951 .next_deadline(&self.arena, self.paint_epoch);
1952 let gesture_deadline = self.next_input_deadline();
1958 let wake_at_deadline = self.pending_wake_at.get();
1959 let frame_tick_deadline = self.frame_tick_deadline();
1965
1966 [
1967 (tooltip_deadline, "tooltip"),
1968 (dwell_tooltip_deadline, "tooltip_dwell"),
1969 (delayed_overlay_deadline, "delayed_overlay"),
1970 (auto_dismiss_deadline, "overlay_auto_dismiss"),
1971 (pointer_leave_deadline, "overlay_pointer_leave"),
1972 (fade_dismiss_deadline, "overlay_fade"),
1973 (animation_deadline, "animation"),
1974 (animated_quad_deadline, "animated_quad"),
1975 (gesture_deadline, "gesture"),
1976 (wake_at_deadline, "wake_at"),
1977 (frame_tick_deadline, "frame_tick"),
1978 ]
1979 .into_iter()
1980 .filter_map(|(at, source)| Some((at?, source)))
1981 .min_by_key(|&(at, _)| at)
1982 }
1983
1984 pub fn next_unpainted_deadline(&self) -> Option<std::time::Instant> {
1996 let animation_deadline = self
1997 .animation_scheduler
1998 .next_deadline(&self.arena, self.paint_epoch);
1999 [
2000 self.pending_wake_at.get(),
2001 animation_deadline,
2002 self.frame_tick_deadline(),
2003 ]
2004 .into_iter()
2005 .flatten()
2006 .min()
2007 }
2008
2009 pub fn overlay_manager(&self) -> &crate::overlay::OverlayManager {
2010 &self.overlay_manager
2011 }
2012
2013 pub fn overlay_manager_mut(&mut self) -> &mut crate::overlay::OverlayManager {
2018 &mut self.overlay_manager
2019 }
2020
2021 pub fn active_overlays(&self) -> Vec<crate::overlay::OverlayId> {
2022 self.overlay_manager.active_ids()
2023 }
2024
2025 pub fn overlay_content_bounds(
2041 &self,
2042 id: crate::overlay::OverlayId,
2043 ) -> Option<teksilo_canvas::Rect> {
2044 self.overlay_manager
2045 .stack
2046 .iter()
2047 .find(|o| o.id == id)
2048 .map(|o| o.bounds)
2049 }
2050
2051 pub fn show_overlay(
2052 &mut self,
2053 request: crate::overlay::OverlayRequest,
2054 ) -> crate::overlay::OverlayId {
2055 let fade_duration = request.fade_duration;
2056 let content_id = request.content_id;
2057 let is_modal = request.placement.is_modal();
2058 let id = self.overlay_manager.show(request);
2059 self.cancel_pointers_for_modal(is_modal);
2060 self.a11y_dirty = true;
2068 if let Some(duration) = fade_duration {
2069 self.attach_overlay_fade(id, content_id, duration);
2070 }
2071 id
2072 }
2073
2074 pub fn show_overlay_in_band(
2084 &mut self,
2085 request: crate::overlay::OverlayRequest,
2086 band: crate::overlay::OverlayBand,
2087 ) -> crate::overlay::OverlayId {
2088 let fade_duration = request.fade_duration;
2089 let content_id = request.content_id;
2090 let is_modal = request.placement.is_modal();
2091 let id = self.overlay_manager.show_in_band(request, band);
2092 self.cancel_pointers_for_modal(is_modal);
2093 self.a11y_dirty = true;
2094 if let Some(duration) = fade_duration {
2095 self.attach_overlay_fade(id, content_id, duration);
2096 }
2097 id
2098 }
2099
2100 pub fn show_overlay_from_source(
2103 &mut self,
2104 source_widget: WidgetId,
2105 mut request: crate::overlay::OverlayRequest,
2106 ) -> crate::overlay::OverlayId {
2107 if request.parent_overlay.is_none() {
2108 request.parent_overlay = self.overlay_ancestor_for_widget(source_widget);
2109 }
2110 if let Some(existing) = self.overlay_manager.find_by_content(request.content_id) {
2111 return existing;
2112 }
2113
2114 let fade_duration = request.fade_duration;
2115 let content_id = request.content_id;
2116 let is_modal = request.placement.is_modal();
2117 let current_focus = self.focused;
2118 let id = self.overlay_manager.show(request);
2119 self.cancel_pointers_for_modal(is_modal);
2120 self.a11y_dirty = true;
2121 if let Some(focus_id) = current_focus {
2122 self.record_top_focus_restore(focus_id);
2123 }
2124 if let Some(duration) = fade_duration {
2125 self.attach_overlay_fade(id, content_id, duration);
2126 }
2127 id
2128 }
2129
2130 pub fn show_overlay_for(
2131 &mut self,
2132 request: crate::overlay::OverlayRequest,
2133 duration: std::time::Duration,
2134 ) -> crate::overlay::OverlayId {
2135 let fade_duration = request.fade_duration;
2136 let content_id = request.content_id;
2137 let is_modal = request.placement.is_modal();
2138 let id = self.overlay_manager.show_for(request, duration);
2139 self.cancel_pointers_for_modal(is_modal);
2140 self.overlay_manager.set_shown_at_sim(id, self.sim_clock);
2141 self.a11y_dirty = true;
2142 if let Some(fade) = fade_duration {
2143 self.attach_overlay_fade(id, content_id, fade);
2144 }
2145 id
2146 }
2147
2148 fn attach_overlay_fade(
2156 &mut self,
2157 overlay_id: crate::overlay::OverlayId,
2158 content_id: WidgetId,
2159 duration: std::time::Duration,
2160 ) {
2161 let opacity = crate::signal::Signal::<f32>::new_animated(0.0);
2162 self.register_animated_signal(&opacity, content_id);
2163 self.set_opacity(content_id, opacity.clone());
2164 if self.prefers_reduced_motion() {
2168 opacity.set(1.0);
2169 self.overlay_manager
2170 .attach_fade(overlay_id, opacity, std::time::Duration::ZERO);
2171 return;
2172 }
2173 let _ = opacity.try_animate_with_options(crate::animation::AnimationRequest {
2174 target: 1.0,
2175 duration,
2176 easing: teksilo_tokens::Easing::EaseOut,
2177 frame_interval: None,
2178 looping: false,
2179 epsilon: 0.0,
2180 max_duration: None,
2181 });
2182 self.overlay_manager
2183 .attach_fade(overlay_id, opacity, duration);
2184 }
2185
2186 pub fn dismiss_overlay(&mut self, id: crate::overlay::OverlayId) {
2191 let mut noop = crate::window::NoopWindowOps;
2192 self.dismiss_overlay_with_ops(id, &mut noop);
2193 }
2194
2195 #[doc(hidden)]
2201 pub fn dismiss_all_overlays_with_ops(
2202 &mut self,
2203 reason: crate::overlay::DismissReason,
2204 ops: &mut dyn crate::window::WindowOps,
2205 ) {
2206 let mark = self.dismissal_mark();
2207 let dismissed = self.overlay_manager.dismiss_all_because(reason);
2208 self.dormant_dismissed_content(&dismissed, &mut *ops);
2209 self.return_focus_after_dismissal(None, mark, &mut *ops);
2210 }
2211
2212 pub fn dismiss_overlay_with_ops(
2215 &mut self,
2216 id: crate::overlay::OverlayId,
2217 ops: &mut dyn crate::window::WindowOps,
2218 ) {
2219 let mark = self.dismissal_mark();
2220 let dismissed = self.overlay_manager.dismiss(id);
2221 self.dormant_dismissed_content(&dismissed, &mut *ops);
2222 self.return_focus_after_dismissal(None, mark, &mut *ops);
2223 }
2224
2225 fn cancel_pointers_for_modal(&mut self, is_modal: bool) {
2236 if !is_modal {
2237 return;
2238 }
2239 let mut noop = crate::window::NoopWindowOps;
2240 self.cancel_all_pointers(crate::pointer::CancelReason::ModalOpened, &mut noop);
2241 }
2242
2243 pub(super) fn run_pending_dismiss_callbacks(&mut self, ops: &mut dyn crate::window::WindowOps) {
2253 if self.draining_dismiss.replace(true) {
2258 return;
2259 }
2260 for _ in 0..8 {
2264 let pending = self.overlay_manager.take_pending_dismiss();
2265 if pending.is_empty() {
2266 break;
2267 }
2268 for (cb, reason) in pending {
2269 self.run_with_event_context(&mut *ops, |ctx| cb(reason, ctx));
2270 }
2271 }
2272 self.draining_dismiss.set(false);
2273 }
2274
2275 pub(super) fn dormant_dismissed_content(
2276 &mut self,
2277 content_ids: &[WidgetId],
2278 ops: &mut dyn crate::window::WindowOps,
2279 ) {
2280 self.run_pending_dismiss_callbacks(&mut *ops);
2284 let mut any_tooltip_dismissed = false;
2290 for &id in content_ids {
2291 if let Some(entry) = self.tooltips.iter_mut().find(|e| e.content_id == id) {
2292 entry.suppressed_until_focus_leaves = entry.promoted_by_focus;
2299 entry.overlay_id = None;
2300 entry.is_sticky = false;
2301 entry.hover_start = None;
2302 entry.real_hover_start = None;
2303 entry.hover_origin = None;
2304 entry.shown_at_sim = None;
2305 entry.shown_at_real = None;
2306 entry.promoted_by_focus = false;
2307 entry.armed_by_focus = false;
2308 entry.armed_by_hold = false;
2309 if let Some(sink) = entry.shown_at_sink.as_ref() {
2310 sink.set(None);
2311 }
2312 any_tooltip_dismissed = true;
2313 }
2314 }
2315 if any_tooltip_dismissed {
2316 let grace = super::TOOLTIP_SESSION_GRACE;
2317 self.tooltip_session_until_sim = Some(self.sim_clock + grace);
2318 self.tooltip_session_until_real = Some(std::time::Instant::now() + grace);
2319 }
2320 for &id in content_ids {
2321 let focused_in_subtree = self
2322 .focused
2323 .filter(|focused| self.is_descendant_of(*focused, id));
2324 let hovered_in_subtree = self
2325 .hovered_id()
2326 .filter(|hovered| self.is_descendant_of(*hovered, id));
2327
2328 if let Some(focused) = focused_in_subtree {
2329 self.dispatch_to_widget(focused, &WidgetEvent::FocusLost, &mut *ops);
2330 if self
2331 .focused
2332 .is_some_and(|current| self.is_descendant_of(current, id))
2333 {
2334 let old = self.focused;
2335 self.set_focused(None);
2336 self.focus_origin = None;
2337 self.update_focus_within_signals(old, None);
2338 self.update_view_focus_signals(old, None);
2339 }
2340 }
2341
2342 self.cancel_pointers_in_subtree(
2348 id,
2349 crate::pointer::CancelReason::OverlayDismissed,
2350 &mut *ops,
2351 );
2352 let _parked = self.arena.set_dormant(id);
2353
2354 if hovered_in_subtree.is_some() {
2355 let old = self.hovered_id();
2356 self.set_hovered(None);
2357 self.update_hover_within_signals(old, None);
2358 }
2359 }
2360 if !content_ids.is_empty() {
2361 self.cached_frame = None;
2362 self.a11y_dirty = true;
2363 self.flush_activation_signals();
2367 }
2368 }
2369
2370 pub fn is_visible(&self, id: WidgetId) -> bool {
2371 self.arena.is_active(id)
2372 }
2373}
2374
2375#[cfg(test)]
2376mod tests {
2377 use super::*;
2378 use crate::test_widgets::FillWidget;
2379 use crate::test_widgets::StackWidget;
2380
2381 #[test]
2384 fn the_next_timer_deadline_is_named_for_its_timer() {
2385 let mut tree = WidgetTree::new();
2386 tree.add(FillWidget::new());
2387 tree.layout(SizeProposal::exact(100.0, 50.0));
2388 assert_eq!(tree.next_timer_deadline_source(), None, "an idle tree");
2389
2390 let blink = std::time::Instant::now() + std::time::Duration::from_millis(500);
2391 tree.request_wake_at(blink);
2392 assert_eq!(tree.next_timer_deadline_source(), Some((blink, "wake_at")));
2393 assert_eq!(tree.next_timer_deadline(), Some(blink));
2394
2395 tree.request_frame();
2396 let (at, source) = tree.next_timer_deadline_source().expect("a frame is due");
2397 assert_eq!(source, "frame_tick", "the frame is due before the blink");
2398 assert!(at < blink);
2399 }
2400
2401 #[test]
2402 fn is_visible_reflects_dormancy() {
2403 let mut tree = WidgetTree::new();
2404 let widget = tree.add(FillWidget::new());
2405 tree.layout(SizeProposal::exact(100.0, 50.0));
2406
2407 assert!(tree.is_visible(widget));
2408 tree.set_dormant(widget);
2409 assert!(!tree.is_visible(widget));
2410 tree.activate(widget);
2411 assert!(tree.is_visible(widget));
2412 }
2413
2414 #[test]
2415 fn frame_tick_deadline_caps_per_frame_effects_at_60hz() {
2416 let mut tree = WidgetTree::new();
2417 assert!(tree.frame_tick_deadline().is_none());
2419
2420 tree.request_frame();
2423 let t0 = std::time::Instant::now();
2425 tree.last_frame_time = Some(t0);
2426
2427 let deadline = tree
2428 .frame_tick_deadline()
2429 .expect("an armed per-frame effect must publish a deadline");
2430 let interval = deadline.saturating_duration_since(t0);
2431 assert!(
2434 interval >= std::time::Duration::from_micros(16_000)
2435 && interval <= std::time::Duration::from_micros(17_500),
2436 "per-frame effects must pace at ~60 Hz (got {interval:?})"
2437 );
2438
2439 assert_eq!(
2442 tree.next_timer_deadline(),
2443 Some(deadline),
2444 "frame-tick deadline must be surfaced by next_timer_deadline"
2445 );
2446 }
2447
2448 #[test]
2449 fn throttled_subscriber_stretches_deadline_but_per_frame_wins_min() {
2450 use crate::test_widgets::{FillWidget, StackWidget};
2451 let mut tree = WidgetTree::new();
2452 let w = tree.add(FillWidget::new());
2453 let w2 = tree.add(FillWidget::new());
2454 tree.add(StackWidget::new().child(w).child(w2));
2455 let _throttled =
2457 tree.subscribe_frame_tick_throttled(w, std::time::Duration::from_millis(1500));
2458 tree.layout(SizeProposal::exact(200.0, 100.0));
2462 let _ = tree.render();
2463 assert!(
2464 !tree.frame_tick_requested.get(),
2465 "precondition: nothing but the subscriber wants this frame"
2466 );
2467 let t0 = tree.last_frame_time.expect("a frame has run");
2468
2469 let d = tree.frame_tick_deadline().expect("armed");
2471 let dt = d.saturating_duration_since(t0);
2472 assert!(
2473 dt >= std::time::Duration::from_millis(1490)
2474 && dt <= std::time::Duration::from_millis(1510),
2475 "a lone throttled subscriber must pace at its interval (~1.5 s), got {dt:?}"
2476 );
2477
2478 let _per_frame = tree.subscribe_frame_tick(w2);
2483 let d2 = tree.frame_tick_deadline().expect("armed");
2484 let dt2 = d2.saturating_duration_since(t0);
2485 assert!(
2486 dt2 <= std::time::Duration::from_millis(20),
2487 "a per-frame subscriber must pull the shared deadline to 60 Hz, got {dt2:?}"
2488 );
2489 }
2490
2491 #[test]
2497 fn a_raw_frame_request_is_not_paced_by_a_throttled_subscriber() {
2498 use crate::test_widgets::FillWidget;
2499 const NORMAL_FRAME: std::time::Duration = std::time::Duration::from_micros(17_500);
2500 const CLOCK: std::time::Duration = std::time::Duration::from_secs(60);
2501 fn frame(tree: &mut WidgetTree) {
2502 tree.layout(SizeProposal::exact(200.0, 100.0));
2503 let _ = tree.render();
2504 }
2505 fn wait(tree: &WidgetTree) -> std::time::Duration {
2506 let deadline = tree.frame_tick_deadline().expect("armed");
2507 deadline.saturating_duration_since(tree.last_frame_time.expect("a frame has run"))
2508 }
2509
2510 let mut tree = WidgetTree::new();
2511 let clock = tree.add(FillWidget::new());
2512 let _tick = tree.subscribe_frame_tick_throttled(clock, CLOCK);
2513 frame(&mut tree);
2514 assert!(
2515 wait(&tree) >= CLOCK - NORMAL_FRAME,
2516 "precondition: the painted clock paces the loop at its own interval"
2517 );
2518
2519 for request in [
2522 (|tree: &WidgetTree| tree.request_frame()) as fn(&WidgetTree),
2523 |tree: &WidgetTree| tree.frame_request_handle().set(true),
2524 ] {
2525 request(&tree);
2526 assert!(
2527 wait(&tree) <= NORMAL_FRAME,
2528 "a requested frame must not wait on the clock (waited {:?})",
2529 wait(&tree)
2530 );
2531 assert_eq!(tree.next_timer_deadline(), tree.frame_tick_deadline());
2532
2533 frame(&mut tree);
2534 assert!(
2535 wait(&tree) >= CLOCK - NORMAL_FRAME,
2536 "once the request is served the clock paces alone again, rather than the loop \
2537 free-running at 60 Hz (waited {:?})",
2538 wait(&tree)
2539 );
2540 }
2541 }
2542
2543 #[test]
2552 fn the_subscriber_arm_is_spent_by_its_tick_and_ends_with_its_owner() {
2553 use crate::test_widgets::StackWidget;
2554 fn frame(tree: &mut WidgetTree) {
2555 tree.layout(SizeProposal::exact(200.0, 100.0));
2556 let _ = tree.render();
2557 }
2558
2559 let mut tree = WidgetTree::new();
2560 let owner = tree.add(FillWidget::new());
2561 let sibling = tree.add(FillWidget::new());
2562 tree.add(StackWidget::new().child(owner).child(sibling));
2563 let ticks = std::rc::Rc::new(std::cell::Cell::new(0_u32));
2564 let _count = tree.frame_tick().observe({
2565 let ticks = ticks.clone();
2566 move |_| ticks.set(ticks.get() + 1)
2567 });
2568 let _sub = tree.subscribe_frame_tick(owner);
2569
2570 frame(&mut tree);
2571 assert!(
2572 tree.frame_requested(),
2573 "a render that painted the subscriber arms the next tick"
2574 );
2575 assert!(
2576 !tree.frame_tick_requested.get(),
2577 "precondition: armed by the subscribers' flag, not by a raw request"
2578 );
2579
2580 let before = ticks.get();
2582 tree.layout(SizeProposal::exact(200.0, 100.0));
2583 assert_eq!(
2584 ticks.get(),
2585 before + 1,
2586 "the armed tick fires on the next layout"
2587 );
2588 assert!(
2589 !tree.frame_requested(),
2590 "the layout that fired the tick has spent the arm"
2591 );
2592 let _ = tree.render();
2593 assert!(
2594 tree.frame_requested(),
2595 "the owner painted again and re-armed"
2596 );
2597
2598 let before = ticks.get();
2600 tree.advance_time(std::time::Duration::from_millis(16));
2601 assert_eq!(ticks.get(), before + 1, "advance_time fires an armed tick");
2602 assert!(
2603 !tree.frame_requested(),
2604 "advance_time spends the arm as layout does"
2605 );
2606 tree.resume_real_time();
2607
2608 frame(&mut tree);
2611 tree.set_dormant(owner);
2612 assert!(
2613 tree.frame_tick_deadline().is_some(),
2614 "the tick armed before the owner was parked is still due"
2615 );
2616 let before = ticks.get();
2617 frame(&mut tree);
2618 assert_eq!(ticks.get(), before + 1);
2619 assert!(
2620 !tree.frame_requested(),
2621 "a parked subscriber must not re-arm the tick"
2622 );
2623 assert_eq!(
2624 tree.next_timer_deadline(),
2625 None,
2626 "with its only subscriber parked the loop sleeps"
2627 );
2628 }
2629
2630 #[test]
2631 fn show_and_dismiss_overlay() {
2632 let mut tree = WidgetTree::new();
2633 let anchor = tree.add(FillWidget::new());
2634 let content = tree.add(FillWidget::new().label("Overlay"));
2635 tree.layout(SizeProposal::exact(200.0, 100.0));
2636
2637 assert!(tree.active_overlays().is_empty());
2638
2639 let id = tree.show_overlay(crate::overlay::OverlayRequest::new(
2640 content,
2641 anchor,
2642 crate::overlay::OverlayPlacement::Below,
2643 crate::overlay::DismissBehavior::Manual,
2644 ));
2645
2646 assert_eq!(tree.active_overlays().len(), 1);
2647
2648 tree.dismiss_overlay(id);
2649 assert!(tree.active_overlays().is_empty());
2650 assert!(!tree.is_visible(content));
2651 }
2652
2653 #[test]
2658 fn modal_centered_overlay_is_a_host_surface() {
2659 let mut tree = WidgetTree::new();
2660 let anchor = tree.add(FillWidget::new());
2661 let modal_content = tree.add(FillWidget::new().label("Modal"));
2662 let dropdown_content = tree.add(FillWidget::new().label("Dropdown"));
2663 tree.layout(SizeProposal::exact(200.0, 100.0));
2664
2665 let modal = tree.show_overlay(crate::overlay::OverlayRequest::new(
2666 modal_content,
2667 anchor,
2668 crate::overlay::OverlayPlacement::Centered,
2669 crate::overlay::DismissBehavior::EscapeOrClickOutside,
2670 ));
2671 let dropdown = tree.show_overlay(
2672 crate::overlay::OverlayRequest::new(
2673 dropdown_content,
2674 anchor,
2675 crate::overlay::OverlayPlacement::Below,
2676 crate::overlay::DismissBehavior::EscapeOrClickOutside,
2677 )
2678 .parent_overlay(modal),
2679 );
2680
2681 assert!(
2682 tree.overlay_is_host_surface(modal),
2683 "a Centered modal overlay must be treated as a host surface"
2684 );
2685 assert!(
2686 !tree.overlay_is_host_surface(dropdown),
2687 "a plain dropdown overlay is not a host surface"
2688 );
2689 }
2690
2691 fn overlay_over_a_field(tree: &mut WidgetTree) -> (WidgetId, WidgetId, WidgetId) {
2693 let field = tree.add(FillWidget::new().focusable());
2694 let inside = tree.add(FillWidget::new().focusable());
2695 let content = tree.add(StackWidget::new().child(inside));
2696 tree.layout(SizeProposal::exact(200.0, 100.0));
2697 tree.focus(field);
2698 tree.show_overlay_from_source(
2699 field,
2700 crate::overlay::OverlayRequest::new(
2701 content,
2702 field,
2703 crate::overlay::OverlayPlacement::Below,
2704 crate::overlay::DismissBehavior::EscapeOrClickOutside,
2705 ),
2706 );
2707 tree.layout(SizeProposal::exact(200.0, 100.0));
2708 (field, content, inside)
2709 }
2710
2711 fn dismiss_all_except_hosts(tree: &mut WidgetTree) {
2712 tree.run_with_event_context(&mut crate::window::NoopWindowOps, |ctx| {
2713 ctx.dismiss_all_except_hosts();
2714 });
2715 }
2716
2717 #[test]
2723 fn dismissing_all_except_hosts_gives_back_the_focus_it_took_away() {
2724 let mut tree = WidgetTree::new();
2725 let (field, content, inside) = overlay_over_a_field(&mut tree);
2726 let nested = tree.add(FillWidget::new().focusable());
2727 tree.layout(SizeProposal::exact(200.0, 100.0));
2728 tree.focus(inside);
2729 tree.show_overlay_from_source(
2730 inside,
2731 crate::overlay::OverlayRequest::new(
2732 nested,
2733 inside,
2734 crate::overlay::OverlayPlacement::Below,
2735 crate::overlay::DismissBehavior::EscapeOrClickOutside,
2736 ),
2737 );
2738 tree.focus(nested);
2739 assert!(tree.is_active(content), "precondition");
2740 dismiss_all_except_hosts(&mut tree);
2741 assert!(tree.active_overlays().is_empty());
2742 assert_eq!(tree.focused(), Some(field));
2743 }
2744
2745 #[test]
2750 fn dismissing_all_except_hosts_gives_focus_back_as_the_lowest_overlay_found_it() {
2751 let mut tree = WidgetTree::new();
2752 let first_field = tree.add(FillWidget::new().focusable());
2753 let second_field = tree.add(FillWidget::new().focusable());
2754 let open_over = |tree: &mut WidgetTree, field: WidgetId| {
2755 let inside = tree.add(FillWidget::new().focusable());
2756 let content = tree.add(StackWidget::new().child(inside));
2757 tree.layout(SizeProposal::exact(200.0, 100.0));
2758 tree.focus(field);
2759 tree.show_overlay_from_source(
2761 field,
2762 crate::overlay::OverlayRequest::new(
2763 content,
2764 field,
2765 crate::overlay::OverlayPlacement::BottomCenter,
2766 crate::overlay::DismissBehavior::Manual,
2767 ),
2768 );
2769 tree.layout(SizeProposal::exact(200.0, 100.0));
2770 inside
2771 };
2772 open_over(&mut tree, first_field);
2773 let second_inside = open_over(&mut tree, second_field);
2774 tree.focus(second_inside);
2775 assert_eq!(tree.active_overlays().len(), 2, "two overlays, unrelated");
2776 dismiss_all_except_hosts(&mut tree);
2777 assert!(tree.active_overlays().is_empty());
2778 assert_eq!(
2779 tree.focused(),
2780 Some(first_field),
2781 "the lowest overlay's focus, not the top one's"
2782 );
2783 }
2784
2785 #[test]
2787 fn dismissing_all_except_hosts_leaves_focus_outside_them_alone() {
2788 let mut tree = WidgetTree::new();
2789 let (_field, _content, _inside) = overlay_over_a_field(&mut tree);
2790 let other = tree.add(FillWidget::new().focusable());
2791 tree.layout(SizeProposal::exact(200.0, 100.0));
2792 tree.focus(other);
2793 dismiss_all_except_hosts(&mut tree);
2794 assert_eq!(tree.focused(), Some(other));
2795 }
2796
2797 #[test]
2798 fn escape_dismisses_topmost_overlay() {
2799 let mut tree = WidgetTree::new();
2800 let anchor = tree.add(FillWidget::new().focusable());
2801 let content = tree.add(FillWidget::new());
2802 tree.layout(SizeProposal::exact(200.0, 100.0));
2803 tree.focus(anchor);
2804
2805 tree.show_overlay(crate::overlay::OverlayRequest::new(
2806 content,
2807 anchor,
2808 crate::overlay::OverlayPlacement::Below,
2809 crate::overlay::DismissBehavior::EscapeOrClickOutside,
2810 ));
2811
2812 assert_eq!(tree.active_overlays().len(), 1);
2813
2814 tree.press_key(Key::Escape, Modifiers::NONE);
2815 assert!(tree.active_overlays().is_empty());
2816 assert!(!tree.is_visible(content));
2817 }
2818
2819 fn show_dialog_with_escape_preview(
2823 tree: &mut WidgetTree,
2824 takes: bool,
2825 seen: std::rc::Rc<std::cell::Cell<u32>>,
2826 ) -> (WidgetId, WidgetId) {
2827 let anchor = tree.add(FillWidget::new().focusable());
2828 let field = tree.add(FillWidget::new().focusable());
2829 let row = tree.add(crate::widget_builder::WidgetBuilder::on_key_preview(
2830 StackWidget::new().child(field),
2831 move |event, _ctx| {
2832 if let WidgetEvent::KeyDown {
2833 key: Key::Escape, ..
2834 } = event
2835 {
2836 seen.set(seen.get() + 1);
2837 if takes {
2838 return EventResponse::Handled;
2839 }
2840 }
2841 EventResponse::Ignored
2842 },
2843 ));
2844 let content = tree.add(StackWidget::new().child(row));
2845 tree.layout(SizeProposal::exact(200.0, 100.0));
2846 tree.focus(anchor);
2847 tree.show_overlay(crate::overlay::OverlayRequest::new(
2848 content,
2849 anchor,
2850 crate::overlay::OverlayPlacement::Below,
2851 crate::overlay::DismissBehavior::EscapeKey,
2852 ));
2853 tree.focus(field);
2854 (content, field)
2855 }
2856
2857 #[test]
2860 fn escape_taken_inside_an_overlay_keeps_it_open() {
2861 let mut tree = WidgetTree::new();
2862 let seen = std::rc::Rc::new(std::cell::Cell::new(0));
2863 let (content, _) = show_dialog_with_escape_preview(&mut tree, true, seen.clone());
2864
2865 tree.press_key(Key::Escape, Modifiers::NONE);
2866 assert_eq!(
2867 seen.get(),
2868 1,
2869 "the handler inside the dialog heard Escape once"
2870 );
2871 assert_eq!(tree.active_overlays().len(), 1, "the dialog stays open");
2872 assert!(tree.is_visible(content));
2873 }
2874
2875 #[test]
2878 fn escape_declined_inside_an_overlay_closes_it_once() {
2879 let mut tree = WidgetTree::new();
2880 let seen = std::rc::Rc::new(std::cell::Cell::new(0));
2881 let (content, _) = show_dialog_with_escape_preview(&mut tree, false, seen.clone());
2882
2883 tree.press_key(Key::Escape, Modifiers::NONE);
2884 assert_eq!(seen.get(), 1, "heard once, not again after the dismissal");
2885 assert!(tree.active_overlays().is_empty());
2886 assert!(!tree.is_visible(content));
2887 }
2888
2889 #[test]
2893 fn escape_closes_a_popup_over_the_focus_before_its_dialog_handler() {
2894 let mut tree = WidgetTree::new();
2895 let seen = std::rc::Rc::new(std::cell::Cell::new(0));
2896 let (dialog, field) = show_dialog_with_escape_preview(&mut tree, true, seen.clone());
2897 let popup = tree.add(FillWidget::new());
2898 tree.layout(SizeProposal::exact(200.0, 100.0));
2899 tree.show_overlay(crate::overlay::OverlayRequest::new(
2900 popup,
2901 field,
2902 crate::overlay::OverlayPlacement::Below,
2903 crate::overlay::DismissBehavior::EscapeOrClickOutside,
2904 ));
2905 tree.focus(field);
2906
2907 tree.press_key(Key::Escape, Modifiers::NONE);
2908 assert_eq!(
2909 seen.get(),
2910 0,
2911 "the popup took Escape before the row was asked"
2912 );
2913 assert!(!tree.is_visible(popup));
2914 assert!(tree.is_visible(dialog));
2915 }
2916
2917 fn show_two_nested_overlays(tree: &mut WidgetTree) -> (WidgetId, WidgetId) {
2920 let anchor = tree.add(FillWidget::new());
2921 let c1 = tree.add(FillWidget::new());
2922 let c2 = tree.add(FillWidget::new());
2923 tree.layout(SizeProposal::exact(200.0, 100.0));
2924 let o1 = tree.show_overlay(crate::overlay::OverlayRequest::new(
2925 c1,
2926 anchor,
2927 crate::overlay::OverlayPlacement::Below,
2928 crate::overlay::DismissBehavior::Manual,
2929 ));
2930 tree.show_overlay(
2931 crate::overlay::OverlayRequest::new(
2932 c2,
2933 c1,
2934 crate::overlay::OverlayPlacement::Below,
2935 crate::overlay::DismissBehavior::Manual,
2936 )
2937 .parent_overlay(o1),
2938 );
2939 (c1, c2)
2940 }
2941
2942 #[test]
2943 fn nested_overlay_back_key_dismisses_with_arrow_left_under_ltr() {
2944 let mut tree = WidgetTree::new();
2945 let _ = show_two_nested_overlays(&mut tree);
2946 assert_eq!(tree.active_overlays().len(), 2);
2947
2948 tree.press_key(Key::ArrowRight, Modifiers::NONE);
2950 assert_eq!(tree.active_overlays().len(), 2);
2951
2952 tree.press_key(Key::ArrowLeft, Modifiers::NONE);
2954 assert_eq!(tree.active_overlays().len(), 1);
2955 }
2956
2957 #[test]
2958 fn nested_overlay_back_key_flips_to_arrow_right_under_rtl() {
2959 let mut tree = WidgetTree::new();
2960 tree.set_layout_direction(crate::environment::LayoutDirection::RightToLeft);
2961 let _ = show_two_nested_overlays(&mut tree);
2962 assert_eq!(tree.active_overlays().len(), 2);
2963
2964 tree.press_key(Key::ArrowLeft, Modifiers::NONE);
2967 assert_eq!(tree.active_overlays().len(), 2);
2968
2969 tree.press_key(Key::ArrowRight, Modifiers::NONE);
2971 assert_eq!(tree.active_overlays().len(), 1);
2972 }
2973
2974 fn show_inert_overlay(tree: &mut WidgetTree, anchor: WidgetId) -> WidgetId {
2976 let content = tree.add(FillWidget::new());
2977 tree.layout(SizeProposal::exact(200.0, 100.0));
2978 tree.show_overlay(
2979 crate::overlay::OverlayRequest::new(
2980 content,
2981 anchor,
2982 crate::overlay::OverlayPlacement::Below,
2983 crate::overlay::DismissBehavior::EscapeKey,
2984 )
2985 .inert(),
2986 );
2987 content
2988 }
2989
2990 #[test]
2995 fn back_key_does_not_count_an_inert_overlay_as_a_menu_level() {
2996 for inert_first in [true, false] {
2997 let mut tree = WidgetTree::new();
2998 let anchor = tree.add(FillWidget::new());
2999 let menu = tree.add(FillWidget::new());
3000 tree.layout(SizeProposal::exact(200.0, 100.0));
3001 let show_menu = |tree: &mut WidgetTree| {
3002 tree.show_overlay(crate::overlay::OverlayRequest::new(
3003 menu,
3004 anchor,
3005 crate::overlay::OverlayPlacement::Below,
3006 crate::overlay::DismissBehavior::Manual,
3007 ));
3008 };
3009 let inert = if inert_first {
3010 let inert = show_inert_overlay(&mut tree, anchor);
3011 show_menu(&mut tree);
3012 inert
3013 } else {
3014 show_menu(&mut tree);
3015 show_inert_overlay(&mut tree, anchor)
3016 };
3017 assert_eq!(tree.active_overlays().len(), 2);
3018
3019 tree.press_key(Key::ArrowLeft, Modifiers::NONE);
3020 assert_eq!(
3021 tree.active_overlays().len(),
3022 2,
3023 "inert shown first: {inert_first}: one menu is not a cascade"
3024 );
3025 assert!(tree.is_visible(menu) && tree.is_visible(inert));
3026 }
3027 }
3028
3029 #[test]
3032 fn back_key_closes_the_submenu_beneath_an_inert_overlay() {
3033 let mut tree = WidgetTree::new();
3034 let (parent, submenu) = show_two_nested_overlays(&mut tree);
3035 let inert = show_inert_overlay(&mut tree, parent);
3036 assert_eq!(tree.active_overlays().len(), 3);
3037
3038 tree.press_key(Key::ArrowLeft, Modifiers::NONE);
3039 assert!(!tree.is_visible(submenu), "the submenu closes");
3040 assert!(tree.is_visible(parent), "its parent stays open");
3041 assert!(
3042 tree.is_visible(inert),
3043 "the inert overlay is not what closes"
3044 );
3045 }
3046
3047 #[derive(Debug)]
3050 struct KeyProbe {
3051 seen: std::rc::Rc<std::cell::RefCell<Vec<Key>>>,
3052 }
3053
3054 impl Widget for KeyProbe {
3055 fn layout_response(
3056 &self,
3057 proposal: SizeProposal,
3058 _ctx: &crate::widget::LayoutContext,
3059 ) -> crate::widget::LayoutResponse {
3060 proposal.resolve(0.0, 0.0).into()
3061 }
3062
3063 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
3064 let seen = self.seen.clone();
3065 ctx.apply_self_handlers(
3066 crate::widget_builder::HandlerSet::new()
3067 .focusable(true)
3068 .on_key(move |event, _ctx| match event {
3069 WidgetEvent::KeyDown { key, .. } => {
3070 seen.borrow_mut().push(*key);
3071 crate::event::EventResponse::Handled
3072 }
3073 _ => crate::event::EventResponse::Ignored,
3074 }),
3075 );
3076 Vec::new()
3077 }
3078 }
3079
3080 #[test]
3092 fn back_key_ignores_text_affordance_overlays_and_reaches_the_editor() {
3093 let mut tree = WidgetTree::new();
3094 let seen = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
3095 let editor = tree.add(KeyProbe { seen: seen.clone() });
3096 let handles_a = tree.add(FillWidget::new());
3097 let handles_b = tree.add(FillWidget::new());
3098 tree.layout(SizeProposal::exact(200.0, 100.0));
3099 tree.focus(editor);
3100
3101 for content in [handles_a, handles_b] {
3103 tree.show_overlay_in_band(
3104 crate::overlay::OverlayRequest::new(
3105 content,
3106 editor,
3107 crate::overlay::OverlayPlacement::FullViewport,
3108 crate::overlay::DismissBehavior::Manual,
3109 ),
3110 crate::overlay::OverlayBand::TextAffordance,
3111 );
3112 }
3113 assert_eq!(tree.active_overlays().len(), 2);
3114
3115 tree.press_key(Key::ArrowLeft, Modifiers::NONE);
3116
3117 assert_eq!(
3118 tree.active_overlays().len(),
3119 2,
3120 "a text affordance is not a menu cascade level — the back key must \
3121 leave both hosts standing"
3122 );
3123 assert_eq!(
3124 seen.borrow().as_slice(),
3125 &[Key::ArrowLeft],
3126 "ArrowLeft must reach the focused editor; swallowing it is the bug \
3127 that left the caret unable to step left in any dual-pane tab"
3128 );
3129 }
3130
3131 #[test]
3135 fn back_key_still_closes_a_submenu_over_a_mounted_text_affordance() {
3136 let mut tree = WidgetTree::new();
3137 let affordance = tree.add(FillWidget::new());
3138 let anchor = tree.add(FillWidget::new());
3139 let menu = tree.add(FillWidget::new());
3140 let submenu = tree.add(FillWidget::new());
3141 tree.layout(SizeProposal::exact(200.0, 100.0));
3142 tree.show_overlay_in_band(
3143 crate::overlay::OverlayRequest::new(
3144 affordance,
3145 anchor,
3146 crate::overlay::OverlayPlacement::FullViewport,
3147 crate::overlay::DismissBehavior::Manual,
3148 ),
3149 crate::overlay::OverlayBand::TextAffordance,
3150 );
3151 let parent = tree.show_overlay(crate::overlay::OverlayRequest::new(
3152 menu,
3153 anchor,
3154 crate::overlay::OverlayPlacement::Below,
3155 crate::overlay::DismissBehavior::Manual,
3156 ));
3157 tree.show_overlay(
3158 crate::overlay::OverlayRequest::new(
3159 submenu,
3160 menu,
3161 crate::overlay::OverlayPlacement::Below,
3162 crate::overlay::DismissBehavior::Manual,
3163 )
3164 .parent_overlay(parent),
3165 );
3166 assert_eq!(tree.active_overlays().len(), 3);
3167
3168 tree.press_key(Key::ArrowLeft, Modifiers::NONE);
3169 assert_eq!(
3170 tree.active_overlays().len(),
3171 2,
3172 "the submenu must still close: the affordance host narrows the \
3173 count, it does not disarm the back key"
3174 );
3175 }
3176
3177 #[test]
3182 fn back_key_does_not_dismiss_a_dialog_on_top_of_a_modal() {
3183 let mut tree = WidgetTree::new();
3184 let anchor = tree.add(FillWidget::new());
3185 let scrim1 = tree.add(FillWidget::new());
3186 let scrim2 = tree.add(FillWidget::new());
3187 let dialog = tree.add(FillWidget::new());
3188 tree.layout(SizeProposal::exact(200.0, 100.0));
3189 for c in [scrim1, scrim2] {
3191 tree.show_overlay(crate::overlay::OverlayRequest::new(
3192 c,
3193 anchor,
3194 crate::overlay::OverlayPlacement::Below,
3195 crate::overlay::DismissBehavior::Manual,
3196 ));
3197 }
3198 tree.show_overlay(crate::overlay::OverlayRequest::new(
3200 dialog,
3201 anchor,
3202 crate::overlay::OverlayPlacement::Centered,
3203 crate::overlay::DismissBehavior::Manual,
3204 ));
3205 assert_eq!(tree.active_overlays().len(), 3);
3206
3207 tree.press_key(Key::ArrowLeft, Modifiers::NONE);
3210 assert_eq!(
3211 tree.active_overlays().len(),
3212 3,
3213 "the back key must not close a dialog sitting on top of a modal"
3214 );
3215 }
3216
3217 #[test]
3218 fn escape_does_not_dismiss_manual_overlay() {
3219 let mut tree = WidgetTree::new();
3220 let anchor = tree.add(FillWidget::new().focusable());
3221 let content = tree.add(FillWidget::new());
3222 tree.layout(SizeProposal::exact(200.0, 100.0));
3223 tree.focus(anchor);
3224
3225 tree.show_overlay(crate::overlay::OverlayRequest::new(
3226 content,
3227 anchor,
3228 crate::overlay::OverlayPlacement::Below,
3229 crate::overlay::DismissBehavior::Manual,
3230 ));
3231
3232 assert_eq!(tree.active_overlays().len(), 1);
3233
3234 tree.press_key(Key::Escape, Modifiers::NONE);
3235 assert_eq!(tree.active_overlays().len(), 1);
3237 }
3238
3239 #[test]
3240 fn click_outside_dismisses_overlay() {
3241 let mut tree = WidgetTree::new();
3242 let anchor = tree.add(FillWidget::new());
3243 let content = tree.add(FillWidget::new());
3244 tree.layout(SizeProposal::exact(200.0, 100.0));
3245
3246 let overlay = tree.show_overlay(crate::overlay::OverlayRequest::new(
3247 content,
3248 anchor,
3249 crate::overlay::OverlayPlacement::Below,
3250 crate::overlay::DismissBehavior::ClickOutside,
3251 ));
3252
3253 tree.overlay_manager
3254 .set_content_bounds(overlay, teksilo_canvas::Size::new(100.0, 50.0));
3255
3256 assert_eq!(tree.active_overlays().len(), 1);
3257
3258 tree.dispatch_event(WidgetEvent::pointer_down(
3259 Point::new(500.0, 500.0),
3260 PointerButton::Primary,
3261 Modifiers::NONE,
3262 ));
3263 assert!(tree.active_overlays().is_empty());
3264 assert!(!tree.is_visible(content));
3265 }
3266
3267 #[test]
3268 fn cascade_dismissal() {
3269 let mut tree = WidgetTree::new();
3270 let anchor = tree.add(FillWidget::new());
3271 let content_a = tree.add(FillWidget::new());
3272 let content_b = tree.add(FillWidget::new());
3273 tree.layout(SizeProposal::exact(200.0, 100.0));
3274
3275 let parent = tree.show_overlay(crate::overlay::OverlayRequest::new(
3276 content_a,
3277 anchor,
3278 crate::overlay::OverlayPlacement::Below,
3279 crate::overlay::DismissBehavior::Manual,
3280 ));
3281 tree.show_overlay(
3282 crate::overlay::OverlayRequest::new(
3283 content_b,
3284 content_a,
3285 crate::overlay::OverlayPlacement::TrailingEdge,
3286 crate::overlay::DismissBehavior::Manual,
3287 )
3288 .parent_overlay(parent),
3289 );
3290
3291 assert_eq!(tree.active_overlays().len(), 2);
3292
3293 tree.dismiss_overlay(parent);
3294 assert!(tree.active_overlays().is_empty());
3295 assert!(!tree.is_visible(content_a));
3296 assert!(!tree.is_visible(content_b));
3297 }
3298
3299 #[test]
3300 fn dismissed_overlay_content_is_dormant_and_invisible() {
3301 let mut tree = WidgetTree::new();
3302 let anchor = tree.add(FillWidget::new());
3303 let content = tree.add(FillWidget::new());
3304 tree.layout(SizeProposal::exact(800.0, 600.0));
3305
3306 let id = tree.show_overlay(crate::overlay::OverlayRequest::new(
3307 content,
3308 anchor,
3309 crate::overlay::OverlayPlacement::Below,
3310 crate::overlay::DismissBehavior::Manual,
3311 ));
3312
3313 tree.layout(SizeProposal::exact(800.0, 600.0));
3314
3315 tree.dismiss_overlay(id);
3316 assert!(!tree.is_visible(content));
3317
3318 tree.layout(SizeProposal::exact(800.0, 600.0));
3319
3320 let center = tree.bounds(content).center();
3321 let hit = tree.hit_test(center);
3322 assert_ne!(hit, Some(content));
3323
3324 let _frame = tree.render();
3325 assert!(!tree.is_visible(content));
3326 }
3327
3328 #[test]
3329 fn tooltip_appears_after_delay() {
3330 let mut tree = WidgetTree::new();
3331 let anchor = tree.add(FillWidget::new());
3332 let tooltip = tree.add(FillWidget::new().label("Tooltip text"));
3333 tree.layout(SizeProposal::exact(200.0, 100.0));
3334
3335 tree.attach_tooltip(anchor, tooltip, std::time::Duration::from_millis(500));
3336
3337 let center = tree.bounds(anchor).center();
3338 tree.pointer_move(center);
3339 assert!(tree.active_overlays().is_empty());
3340
3341 tree.advance_time(std::time::Duration::from_millis(600));
3342
3343 assert_eq!(tree.active_overlays().len(), 1);
3344 assert!(tree.find_by_label("Tooltip text").is_some());
3345 }
3346
3347 #[test]
3348 fn tooltip_survives_theme_switch() {
3349 let mut tree = WidgetTree::new().with_theme(crate::presets::intui::light());
3354 let anchor = tree.add(FillWidget::new());
3355 let tooltip = tree.add(FillWidget::new().label("Tip"));
3356 tree.layout(SizeProposal::exact(200.0, 100.0));
3357
3358 tree.attach_tooltip(anchor, tooltip, std::time::Duration::from_millis(500));
3359
3360 tree.set_theme(crate::presets::intui::dark());
3361
3362 tree.pointer_move(tree.bounds(anchor).center());
3363 tree.advance_time(std::time::Duration::from_millis(600));
3364
3365 assert_eq!(tree.active_overlays().len(), 1);
3366 assert!(tree.find_by_label("Tip").is_some());
3367 }
3368
3369 #[test]
3370 fn tooltip_suppressed_when_hovering_anchor_owned_overlay_content() {
3371 let mut tree = WidgetTree::new();
3379 let anchor = tree.add(FillWidget::new());
3380 let panel = tree.add_child(anchor, FillWidget::new());
3383 let row = tree.add_child(panel, FillWidget::new());
3384 let tip = tree.add(FillWidget::new().label("Tip"));
3385 tree.layout(SizeProposal::exact(200.0, 100.0));
3386
3387 let delay = std::time::Duration::from_millis(100);
3388 tree.attach_tooltip(anchor, tip, delay);
3389
3390 tree.tooltip_pointer_enter(anchor);
3393 tree.advance_time(delay + std::time::Duration::from_millis(50));
3394 assert_eq!(
3395 tree.active_overlays().len(),
3396 1,
3397 "tooltip should appear when hovering the anchor itself"
3398 );
3399 tree.pointer_move(Point::new(500.0, 500.0));
3402 tree.advance_time(std::time::Duration::from_millis(150));
3403 assert!(tree.active_overlays().is_empty());
3404
3405 tree.show_overlay(crate::overlay::OverlayRequest::new(
3407 panel,
3408 anchor,
3409 crate::overlay::OverlayPlacement::Below,
3410 crate::overlay::DismissBehavior::Manual,
3411 ));
3412 assert_eq!(tree.active_overlays().len(), 1);
3413
3414 tree.tooltip_pointer_enter(row);
3417 tree.advance_time(delay + std::time::Duration::from_millis(50));
3418 assert_eq!(
3419 tree.active_overlays().len(),
3420 1,
3421 "anchor tooltip must not leak onto its own overlay's rows"
3422 );
3423 }
3424
3425 #[test]
3426 fn tooltip_inside_overlay_still_fires() {
3427 let mut tree = WidgetTree::new();
3431 let host = tree.add(FillWidget::new());
3432 let panel = tree.add_child(host, FillWidget::new());
3433 let row = tree.add_child(panel, FillWidget::new());
3434 let tip = tree.add(FillWidget::new().label("Row tip"));
3435 tree.layout(SizeProposal::exact(200.0, 100.0));
3436
3437 let delay = std::time::Duration::from_millis(100);
3438 tree.attach_tooltip(row, tip, delay);
3440
3441 tree.show_overlay(crate::overlay::OverlayRequest::new(
3442 panel,
3443 host,
3444 crate::overlay::OverlayPlacement::Below,
3445 crate::overlay::DismissBehavior::Manual,
3446 ));
3447 assert_eq!(tree.active_overlays().len(), 1);
3448
3449 tree.tooltip_pointer_enter(row);
3450 tree.advance_time(delay + std::time::Duration::from_millis(50));
3451 assert_eq!(
3452 tree.active_overlays().len(),
3453 2,
3454 "a row's own tooltip should still fire inside an overlay"
3455 );
3456 }
3457
3458 #[test]
3459 fn tooltip_dismissed_on_pointer_leave() {
3460 let mut tree = WidgetTree::new();
3461 let anchor = tree.add(FillWidget::new());
3462 let tooltip = tree.add(FillWidget::new().label("Tip"));
3463 tree.layout(SizeProposal::exact(200.0, 100.0));
3464
3465 tree.attach_tooltip(anchor, tooltip, std::time::Duration::from_millis(500));
3466
3467 tree.pointer_move(tree.bounds(anchor).center());
3468 tree.advance_time(std::time::Duration::from_millis(600));
3469 assert_eq!(tree.active_overlays().len(), 1);
3470
3471 tree.pointer_move(Point::new(500.0, 500.0));
3476 assert_eq!(
3477 tree.active_overlays().len(),
3478 1,
3479 "tooltip persists briefly after anchor-leave (hoverable grace)"
3480 );
3481 tree.advance_time(std::time::Duration::from_millis(150));
3482 assert!(
3483 tree.active_overlays().is_empty(),
3484 "tooltip dismissed after the 100ms grace outside anchor+overlay"
3485 );
3486 }
3487
3488 #[test]
3489 fn tooltip_not_shown_if_pointer_leaves_before_delay() {
3490 let mut tree = WidgetTree::new();
3491 let anchor = tree.add(FillWidget::new());
3492 let tooltip = tree.add(FillWidget::new().label("Tip"));
3493 tree.layout(SizeProposal::exact(200.0, 100.0));
3494
3495 tree.attach_tooltip(anchor, tooltip, std::time::Duration::from_millis(500));
3496
3497 tree.pointer_move(tree.bounds(anchor).center());
3498 tree.advance_time(std::time::Duration::from_millis(200));
3499 tree.pointer_move(Point::new(500.0, 500.0));
3500
3501 tree.advance_time(std::time::Duration::from_millis(500));
3502 assert!(tree.active_overlays().is_empty());
3503 }
3504
3505 #[test]
3506 fn tooltip_reshow_uses_short_delay_after_prior_tip() {
3507 let mut tree = WidgetTree::new();
3510 let a = tree.add(FillWidget::new());
3511 let b = tree.add(FillWidget::new());
3512 let tip_a = tree.add(FillWidget::new().label("Tip A"));
3513 let tip_b = tree.add(FillWidget::new().label("Tip B"));
3514 tree.layout(SizeProposal::exact(400.0, 200.0));
3515
3516 let delay = std::time::Duration::from_millis(500);
3517 tree.attach_tooltip(a, tip_a, delay);
3518 tree.attach_tooltip(b, tip_b, delay);
3519
3520 tree.tooltip_pointer_enter(a);
3523 tree.advance_time(std::time::Duration::from_millis(150));
3524 assert!(
3525 tree.active_overlays().is_empty(),
3526 "must not appear before full initial delay"
3527 );
3528 tree.advance_time(std::time::Duration::from_millis(400));
3529 assert_eq!(
3530 tree.active_overlays().len(),
3531 1,
3532 "first tip after initial delay"
3533 );
3534 assert!(tree.find_by_label("Tip A").is_some());
3535
3536 let mut noop = crate::window::NoopWindowOps;
3538 tree.tooltip_pointer_leave(a, &mut noop);
3539 tree.tooltip_pointer_enter(b);
3540 tree.advance_time(std::time::Duration::from_millis(120));
3541 assert!(
3542 tree.find_by_label("Tip B").is_some(),
3543 "second tip should use the short reshow delay while session is warm"
3544 );
3545 }
3546
3547 #[test]
3548 fn reshow_delay_reverts_to_full_after_the_session_grace_expires() {
3549 let mut tree = WidgetTree::new();
3555 tree.set_accessibility_preferences(false, true, 1.0);
3559 let a = tree.add(FillWidget::new());
3560 let b = tree.add(FillWidget::new());
3561 let tip_a = tree.add(FillWidget::new().label("Tip A"));
3562 let tip_b = tree.add(FillWidget::new().label("Tip B"));
3563 tree.layout(SizeProposal::exact(400.0, 200.0));
3564
3565 let delay = std::time::Duration::from_millis(500);
3566 tree.attach_tooltip(a, tip_a, delay);
3567 tree.attach_tooltip(b, tip_b, delay);
3568
3569 tree.tooltip_pointer_enter(a);
3571 tree.advance_time(std::time::Duration::from_millis(550));
3572 assert!(tree.find_by_label("Tip A").is_some(), "first tip shown");
3573
3574 tree.pointer_move(Point::new(900.0, 900.0));
3575 tree.advance_time(std::time::Duration::from_millis(150));
3576 assert!(tree.active_overlays().is_empty(), "A dismissed on leave");
3577
3578 tree.advance_time(super::TOOLTIP_SESSION_GRACE + std::time::Duration::from_millis(50));
3580
3581 tree.tooltip_pointer_enter(b);
3582 tree.advance_time(std::time::Duration::from_millis(150));
3583 assert!(
3584 tree.active_overlays().is_empty(),
3585 "session went cold — B must pay the FULL delay, not the 100 ms reshow"
3586 );
3587 tree.advance_time(std::time::Duration::from_millis(400));
3588 assert!(
3589 tree.find_by_label("Tip B").is_some(),
3590 "B still appears once its full delay elapses"
3591 );
3592 }
3593
3594 #[test]
3595 fn warm_reshow_scales_the_delay_rather_than_flattening_every_tier() {
3596 let mut tree = WidgetTree::new();
3602 let light = tree.add(FillWidget::new());
3603 let heavy = tree.add(FillWidget::new());
3604 let tip_light = tree.add(FillWidget::new().label("Light"));
3605 let tip_heavy = tree.add(FillWidget::new().label("Heavy"));
3606 tree.layout(SizeProposal::exact(400.0, 200.0));
3607
3608 tree.attach_tooltip(light, tip_light, std::time::Duration::from_millis(500));
3609 tree.attach_tooltip(heavy, tip_heavy, std::time::Duration::from_millis(700));
3610
3611 tree.tooltip_pointer_enter(light);
3613 tree.advance_time(std::time::Duration::from_millis(550));
3614 assert!(tree.find_by_label("Light").is_some(), "session warm");
3615
3616 let mut noop = crate::window::NoopWindowOps;
3617 tree.tooltip_pointer_leave(light, &mut noop);
3618 tree.tooltip_pointer_enter(heavy);
3619
3620 tree.advance_time(std::time::Duration::from_millis(120));
3622 assert!(
3623 tree.find_by_label("Heavy").is_none(),
3624 "a heavy tooltip must not fire at the light tier's reshow delay"
3625 );
3626 tree.advance_time(std::time::Duration::from_millis(40));
3628 assert!(
3629 tree.find_by_label("Heavy").is_some(),
3630 "heavy reshow is the scaled 140 ms"
3631 );
3632 }
3633
3634 #[test]
3635 fn a_pinned_sticky_tooltip_does_not_hold_the_session_warm() {
3636 let mut tree = WidgetTree::new();
3640 tree.set_accessibility_preferences(false, true, 1.0); let a = tree.add(FillWidget::new());
3642 let b = tree.add(FillWidget::new());
3643 let tip_a = tree.add(FillWidget::new().label("Pinned"));
3644 let tip_b = tree.add(FillWidget::new().label("Other"));
3645 tree.layout(SizeProposal::exact(400.0, 200.0));
3646
3647 tree.attach_tooltip_with_sticky(
3648 a,
3649 tip_a,
3650 std::time::Duration::from_millis(500),
3651 Some(std::time::Duration::from_millis(100)),
3652 );
3653 tree.attach_tooltip(b, tip_b, std::time::Duration::from_millis(500));
3654
3655 tree.tooltip_pointer_enter(a);
3656 tree.advance_time(std::time::Duration::from_millis(550));
3657 assert!(tree.find_by_label("Pinned").is_some());
3658 tree.promote_tooltip_to_sticky(tip_a);
3659
3660 tree.advance_time(super::TOOLTIP_SESSION_GRACE + std::time::Duration::from_millis(50));
3662 tree.tooltip_pointer_enter(b);
3663 tree.advance_time(std::time::Duration::from_millis(150));
3664 assert!(
3665 tree.find_by_label("Other").is_none(),
3666 "a pinned sticky must not keep every other anchor on the reshow path"
3667 );
3668 }
3669
3670 #[test]
3671 fn reattaching_a_tooltip_does_not_grow_the_entry_table() {
3672 let mut tree = WidgetTree::new();
3678 let anchor = tree.add(FillWidget::new());
3679 tree.layout(SizeProposal::exact(200.0, 100.0));
3680
3681 let delay = std::time::Duration::from_millis(100);
3682 for _ in 0..25 {
3683 let tip = tree.add(FillWidget::new().label("Tip"));
3685 tree.attach_tooltip(anchor, tip, delay);
3686 assert_eq!(
3687 tree.tooltip_entry_count(),
3688 1,
3689 "an anchor must own exactly one tooltip entry across rebuilds"
3690 );
3691 }
3692
3693 tree.tooltip_pointer_enter(anchor);
3695 tree.advance_time(delay + std::time::Duration::from_millis(50));
3696 assert_eq!(
3697 tree.active_overlays().len(),
3698 1,
3699 "latest tooltip still shows"
3700 );
3701 }
3702
3703 #[test]
3704 fn destroying_an_anchor_reaps_its_tooltip_entry() {
3705 let mut tree = WidgetTree::new();
3708 let host = tree.add(FillWidget::new());
3709 let anchor = tree.add_child(host, FillWidget::new());
3710 let tip = tree.add(FillWidget::new().label("Tip"));
3711 tree.layout(SizeProposal::exact(200.0, 100.0));
3712
3713 tree.attach_tooltip(anchor, tip, std::time::Duration::from_millis(100));
3714 assert_eq!(tree.tooltip_entry_count(), 1);
3715
3716 tree.destroy_subtree(anchor);
3717 assert_eq!(
3718 tree.tooltip_entry_count(),
3719 0,
3720 "destroying the anchor must reap its entry and content node"
3721 );
3722 }
3723
3724 #[test]
3725 fn a_leaving_tooltip_schedules_a_wake_for_its_dismissal() {
3726 let mut tree = WidgetTree::new();
3731 tree.set_accessibility_preferences(false, true, 1.0); let anchor = tree.add(FillWidget::new());
3733 let tip = tree.add(FillWidget::new().label("Tip"));
3734 tree.layout(SizeProposal::exact(400.0, 200.0));
3735
3736 tree.attach_tooltip(anchor, tip, std::time::Duration::from_millis(100));
3737 tree.pointer_move(tree.bounds(anchor).center());
3738 tree.advance_time(std::time::Duration::from_millis(150));
3739 assert_eq!(tree.active_overlays().len(), 1, "tooltip shown");
3740
3741 assert!(
3743 tree.next_timer_deadline().is_none(),
3744 "a settled tooltip under the pointer schedules nothing"
3745 );
3746
3747 tree.pointer_move(Point::new(900.0, 900.0));
3750 assert!(
3751 tree.next_timer_deadline().is_some(),
3752 "the PointerLeave grace must contribute a wake deadline"
3753 );
3754 }
3755
3756 #[test]
3767 fn a_fading_out_overlay_schedules_a_wake_for_its_deferred_removal() {
3768 let mut tree = WidgetTree::new();
3769 let anchor = tree.add(FillWidget::new());
3770 let content = tree.add(FillWidget::new().label("Faded"));
3771 tree.layout(SizeProposal::exact(200.0, 100.0));
3772
3773 let id = tree.show_overlay(
3774 crate::overlay::OverlayRequest::new(
3775 content,
3776 anchor,
3777 crate::overlay::OverlayPlacement::Below,
3778 crate::overlay::DismissBehavior::Manual,
3779 )
3780 .with_fade(std::time::Duration::from_millis(200)),
3781 );
3782 tree.dismiss_overlay(id);
3783 assert!(
3784 tree.is_visible(content),
3785 "precondition: the removal is deferred, so there is something to wake for"
3786 );
3787
3788 let expected = tree.overlay_manager.next_fade_dismiss_deadline();
3794 assert!(
3795 expected.is_some(),
3796 "precondition: the fade start was stamped, so there is a deadline to compare against"
3797 );
3798 assert_eq!(
3799 tree.next_timer_deadline(),
3800 expected,
3801 "the wake deadline must be the deferred removal's own, not merely some deadline"
3802 );
3803 }
3804
3805 #[test]
3806 fn pressing_cancels_a_pending_dwell_and_dismisses_a_shown_tooltip() {
3807 let mut tree = WidgetTree::new();
3808 let anchor = tree.add(FillWidget::new());
3809 let tip = tree.add(FillWidget::new().label("Tip"));
3810 tree.layout(SizeProposal::exact(400.0, 200.0));
3811
3812 let delay = std::time::Duration::from_millis(500);
3813 tree.attach_tooltip(anchor, tip, delay);
3814
3815 tree.pointer_move(tree.bounds(anchor).center());
3818 tree.advance_time(std::time::Duration::from_millis(300));
3819 tree.tooltip_pointer_press(None);
3820 tree.advance_time(std::time::Duration::from_millis(400));
3821 assert!(
3822 tree.active_overlays().is_empty(),
3823 "a press must cancel the pending dwell, not merely delay it"
3824 );
3825
3826 tree.tooltip_pointer_enter(anchor);
3829 tree.advance_time(delay + std::time::Duration::from_millis(50));
3830 assert_eq!(tree.active_overlays().len(), 1, "tooltip shown again");
3831 tree.tooltip_pointer_press(Some(tree.bounds(anchor).center()));
3832 assert!(
3833 tree.active_overlays().is_empty(),
3834 "a press must dismiss the shown tooltip"
3835 );
3836 }
3837
3838 #[test]
3839 fn a_pointer_that_left_the_window_by_a_jump_arms_no_tooltip() {
3840 let mut tree = WidgetTree::new();
3846 let anchor = tree.add(FillWidget::new());
3847 let tip = tree.add(FillWidget::new().label("Tip"));
3848 tree.layout(SizeProposal::exact(400.0, 200.0));
3849 let delay = std::time::Duration::from_millis(300);
3850 tree.attach_tooltip(anchor, tip, delay);
3851
3852 let centre = tree.bounds(anchor).center();
3853 tree.pointer_move(centre);
3854 tree.dispatch_event(WidgetEvent::pointer_down(
3855 centre,
3856 PointerButton::Primary,
3857 Modifiers::NONE,
3858 ));
3859 tree.dispatch_event(WidgetEvent::pointer_up(
3860 centre,
3861 PointerButton::Primary,
3862 Modifiers::NONE,
3863 ));
3864
3865 let mut noop = crate::window::NoopWindowOps;
3866 tree.pointer_left_window(&mut noop);
3867 tree.arena.mark_needs_layout(anchor);
3868 tree.arena.mark_ancestors_need_layout(anchor);
3869 tree.layout(SizeProposal::exact(400.0, 200.0));
3870 tree.advance_time(delay * 3);
3871 assert!(
3872 tree.active_overlays().is_empty(),
3873 "no tooltip may open once the pointer has left the window"
3874 );
3875 assert_eq!(
3876 tree.pending_tooltip_count(),
3877 0,
3878 "no dwell may be left running either"
3879 );
3880
3881 tree.pointer_move(Point::new(centre.x + 1.0, centre.y));
3883 tree.advance_time(delay * 2);
3884 assert_eq!(tree.active_overlays().len(), 1, "a pointer inside arms it");
3885 }
3886
3887 #[test]
3888 fn a_click_that_rebuilds_the_anchor_does_not_start_its_dwell_again() {
3889 let mut tree = WidgetTree::new();
3895 let anchor = tree.add(FillWidget::new());
3896 let tip = tree.add(FillWidget::new().label("Tip"));
3897 tree.layout(SizeProposal::exact(400.0, 200.0));
3898 let delay = std::time::Duration::from_millis(300);
3899 tree.attach_tooltip(anchor, tip, delay);
3900
3901 let centre = tree.bounds(anchor).center();
3902 tree.pointer_move(centre);
3903 tree.dispatch_event(WidgetEvent::pointer_down(
3904 centre,
3905 PointerButton::Primary,
3906 Modifiers::NONE,
3907 ));
3908 tree.dispatch_event(WidgetEvent::pointer_up(
3909 centre,
3910 PointerButton::Primary,
3911 Modifiers::NONE,
3912 ));
3913
3914 tree.set_hovered(None);
3916 tree.arena.mark_needs_layout(anchor);
3917 tree.arena.mark_ancestors_need_layout(anchor);
3918 tree.layout(SizeProposal::exact(400.0, 200.0));
3919 assert!(tree.hovered_id().is_some(), "hover is recovered");
3920 tree.advance_time(delay * 3);
3921 assert!(
3922 tree.active_overlays().is_empty(),
3923 "no tooltip right after a click on its anchor"
3924 );
3925
3926 tree.pointer_left_window(&mut crate::window::NoopWindowOps);
3928 tree.pointer_move(centre);
3929 tree.advance_time(delay * 2);
3930 assert_eq!(tree.active_overlays().len(), 1);
3931 }
3932
3933 #[test]
3934 fn window_deactivation_retires_hover_tooltips() {
3935 let mut tree = WidgetTree::new();
3936 let anchor = tree.add(FillWidget::new());
3937 let tip = tree.add(FillWidget::new().label("Tip"));
3938 tree.layout(SizeProposal::exact(400.0, 200.0));
3939
3940 tree.attach_tooltip(anchor, tip, std::time::Duration::from_millis(100));
3941 tree.pointer_move(tree.bounds(anchor).center());
3942 tree.advance_time(std::time::Duration::from_millis(150));
3943 assert_eq!(tree.active_overlays().len(), 1);
3944
3945 tree.set_window_active(false);
3946 assert!(
3947 tree.active_overlays().is_empty(),
3948 "a tooltip must not float over another window's chrome"
3949 );
3950 }
3951
3952 #[test]
3953 fn only_the_innermost_anchor_arms_its_dwell() {
3954 let mut tree = WidgetTree::new();
3957 let panel = tree.add(FillWidget::new());
3958 let row = tree.add_child(panel, FillWidget::new());
3959 let panel_tip = tree.add(FillWidget::new().label("Panel"));
3960 let row_tip = tree.add(FillWidget::new().label("Row"));
3961 tree.layout(SizeProposal::exact(400.0, 200.0));
3962
3963 let delay = std::time::Duration::from_millis(100);
3964 tree.attach_tooltip(panel, panel_tip, delay);
3965 tree.attach_tooltip(row, row_tip, delay);
3966
3967 tree.tooltip_pointer_enter(row);
3968 tree.advance_time(delay + std::time::Duration::from_millis(50));
3969
3970 assert_eq!(
3971 tree.active_overlays().len(),
3972 1,
3973 "exactly one tooltip may open for a hover"
3974 );
3975 assert!(
3976 tree.find_by_label("Row").is_some(),
3977 "the innermost anchor wins"
3978 );
3979 }
3980
3981 #[test]
3982 fn escape_dismisses_a_hover_tooltip_and_falls_through_to_the_menu_below() {
3983 let mut tree = WidgetTree::new();
3987 tree.set_accessibility_preferences(false, true, 1.0); let anchor = tree.add(FillWidget::new());
3989 let menu = tree.add(FillWidget::new());
3990 let tip = tree.add(FillWidget::new().label("Tip"));
3991 tree.layout(SizeProposal::exact(400.0, 200.0));
3992
3993 let menu_overlay = tree.show_overlay(crate::overlay::OverlayRequest::new(
3994 menu,
3995 anchor,
3996 crate::overlay::OverlayPlacement::Below,
3997 crate::overlay::DismissBehavior::EscapeOrClickOutside,
3998 ));
3999 assert_eq!(tree.active_overlays().len(), 1);
4000
4001 tree.attach_tooltip(anchor, tip, std::time::Duration::from_millis(100));
4003 tree.tooltip_pointer_enter(anchor);
4004 tree.advance_time(std::time::Duration::from_millis(150));
4005 assert_eq!(
4006 tree.active_overlays().len(),
4007 2,
4008 "tooltip sits above the menu"
4009 );
4010
4011 let dismissed = tree.overlay_manager.try_dismiss_top_on_escape();
4013 assert!(dismissed.is_some(), "Escape must dismiss the hover tooltip");
4014 assert_eq!(tree.active_overlays().len(), 1);
4015
4016 let dismissed = tree.overlay_manager.try_dismiss_top_on_escape();
4018 assert_eq!(
4019 dismissed.map(|(id, _, _)| id),
4020 Some(menu_overlay),
4021 "Escape must then reach the menu underneath"
4022 );
4023 assert!(tree.active_overlays().is_empty());
4024 }
4025
4026 #[test]
4027 fn tooltip_timer_restarts_when_pointer_keeps_moving() {
4028 let mut tree = WidgetTree::new();
4031 let anchor = tree.add(FillWidget::new());
4032 let tooltip = tree.add(FillWidget::new().label("Tip"));
4033 tree.layout(SizeProposal::exact(200.0, 100.0));
4034
4035 tree.attach_tooltip(anchor, tooltip, std::time::Duration::from_millis(500));
4036
4037 let start = tree.bounds(anchor).center();
4038 tree.pointer_move(start);
4039 tree.advance_time(std::time::Duration::from_millis(300));
4040 tree.pointer_move(Point::new(start.x + 20.0, start.y));
4042 tree.advance_time(std::time::Duration::from_millis(300));
4045 assert!(
4046 tree.active_overlays().is_empty(),
4047 "moving past stationary slop must restart the delay"
4048 );
4049 tree.advance_time(std::time::Duration::from_millis(250));
4050 assert_eq!(
4051 tree.active_overlays().len(),
4052 1,
4053 "tooltip appears after a full delay of stillness"
4054 );
4055 }
4056
4057 #[test]
4058 fn timed_overlay_auto_dismisses_after_duration() {
4059 let mut tree = WidgetTree::new();
4060 let anchor = tree.add(FillWidget::new());
4061 let content = tree.add(FillWidget::new().label("Toast"));
4062 tree.layout(SizeProposal::exact(200.0, 100.0));
4063
4064 tree.show_overlay_for(
4065 crate::overlay::OverlayRequest::new(
4066 content,
4067 anchor,
4068 crate::overlay::OverlayPlacement::Below,
4069 crate::overlay::DismissBehavior::Manual,
4070 ),
4071 std::time::Duration::from_millis(300),
4072 );
4073
4074 assert_eq!(tree.active_overlays().len(), 1);
4075
4076 tree.advance_time(std::time::Duration::from_millis(200));
4077 assert_eq!(tree.active_overlays().len(), 1);
4078
4079 tree.advance_time(std::time::Duration::from_millis(150));
4080 assert!(tree.active_overlays().is_empty());
4081 assert!(!tree.is_visible(content));
4082 }
4083
4084 #[test]
4085 fn fade_dismiss_keeps_overlay_off_active_list_immediately() {
4086 let mut tree = WidgetTree::new();
4094 let anchor = tree.add(FillWidget::new());
4095 let content = tree.add(FillWidget::new().label("Faded"));
4096 tree.layout(SizeProposal::exact(200.0, 100.0));
4097
4098 let id = tree.show_overlay(
4099 crate::overlay::OverlayRequest::new(
4100 content,
4101 anchor,
4102 crate::overlay::OverlayPlacement::Below,
4103 crate::overlay::DismissBehavior::Manual,
4104 )
4105 .with_fade(std::time::Duration::from_millis(100)),
4106 );
4107 assert_eq!(tree.active_overlays().len(), 1);
4108
4109 tree.dismiss_overlay(id);
4110 assert!(tree.active_overlays().is_empty());
4115 }
4116
4117 #[test]
4118 fn fade_dismiss_defers_content_dormancy_until_sim_tween_completes() {
4119 let mut tree = WidgetTree::new();
4125 let anchor = tree.add(FillWidget::new());
4126 let content = tree.add(FillWidget::new().label("Faded"));
4127 tree.layout(SizeProposal::exact(200.0, 100.0));
4128
4129 let id = tree.show_overlay(
4130 crate::overlay::OverlayRequest::new(
4131 content,
4132 anchor,
4133 crate::overlay::OverlayPlacement::Below,
4134 crate::overlay::DismissBehavior::Manual,
4135 )
4136 .with_fade(std::time::Duration::from_millis(100)),
4137 );
4138 tree.advance_time(std::time::Duration::from_secs(1));
4144
4145 tree.dismiss_overlay(id);
4146 assert!(
4147 tree.is_visible(content),
4148 "content stays active during fade-out"
4149 );
4150
4151 tree.advance_time(std::time::Duration::from_millis(60));
4155 assert!(
4156 tree.is_visible(content),
4157 "60 ms into a 100 ms tween the content is still up"
4158 );
4159
4160 tree.advance_time(std::time::Duration::from_millis(90));
4161 assert!(
4162 !tree.is_visible(content),
4163 "after sim-time past the tween window, deferred removal fires"
4164 );
4165 }
4166
4167 #[test]
4179 fn an_auto_dismissed_fade_starts_at_the_instant_the_dismiss_ran() {
4180 let mut tree = WidgetTree::new();
4181 let anchor = tree.add(FillWidget::new());
4182 let content = tree.add(FillWidget::new().label("Toast"));
4183 tree.layout(SizeProposal::exact(200.0, 100.0));
4184
4185 tree.show_overlay_for(
4186 crate::overlay::OverlayRequest::new(
4187 content,
4188 anchor,
4189 crate::overlay::OverlayPlacement::Below,
4190 crate::overlay::DismissBehavior::Manual,
4191 )
4192 .with_fade(std::time::Duration::from_millis(100)),
4193 std::time::Duration::from_millis(500),
4194 );
4195 assert_eq!(tree.active_overlays().len(), 1);
4196
4197 tree.advance_time(std::time::Duration::from_millis(600));
4201 assert!(
4202 tree.active_overlays().is_empty(),
4203 "precondition: the auto-dismiss fired inside this advance"
4204 );
4205 assert!(
4206 tree.is_visible(content),
4207 "the fade must start at the instant the dismiss ran, so the \
4208 content survives the frame that dismissed it"
4209 );
4210
4211 tree.advance_time(std::time::Duration::from_millis(150));
4212 assert!(
4213 !tree.is_visible(content),
4214 "and is reaped once the tween's own window has passed"
4215 );
4216 }
4217
4218 #[derive(Debug)]
4224 struct Block(f32, f32);
4225
4226 impl Widget for Block {
4227 fn layout_response(
4228 &self,
4229 _proposal: SizeProposal,
4230 _ctx: &LayoutContext,
4231 ) -> crate::widget::LayoutResponse {
4232 teksilo_canvas::Size::new(self.0, self.1).into()
4233 }
4234 }
4235
4236 fn panel_and_an_overlay_above(
4240 panel_dismiss: crate::overlay::DismissBehavior,
4241 top: impl Widget + 'static,
4242 top_dismiss: crate::overlay::DismissBehavior,
4243 top_at: Point,
4244 inert: bool,
4245 ) -> (WidgetTree, WidgetId, WidgetId) {
4246 let mut tree = WidgetTree::new();
4247 let panel = tree.add(Block(100.0, 60.0));
4248 let top = tree.add(top);
4249 let beneath = tree.add(FillWidget::new());
4253 tree.show_overlay(crate::overlay::OverlayRequest::new(
4254 panel,
4255 beneath,
4256 crate::overlay::OverlayPlacement::AtPointer(Point::new(20.0, 20.0)),
4257 panel_dismiss,
4258 ));
4259 let request = crate::overlay::OverlayRequest::new(
4260 top,
4261 beneath,
4262 crate::overlay::OverlayPlacement::AtPointer(top_at),
4263 top_dismiss,
4264 );
4265 tree.show_overlay(if inert { request.inert() } else { request });
4266 tree.layout(SizeProposal::exact(400.0, 200.0));
4267 (tree, panel, top)
4268 }
4269
4270 fn panel_and_an_inert_overlay(
4273 panel_dismiss: crate::overlay::DismissBehavior,
4274 inert_dismiss: crate::overlay::DismissBehavior,
4275 inert_at: Point,
4276 ) -> (WidgetTree, WidgetId, WidgetId) {
4277 panel_and_an_overlay_above(
4278 panel_dismiss,
4279 Block(60.0, 40.0),
4280 inert_dismiss,
4281 inert_at,
4282 true,
4283 )
4284 }
4285
4286 #[test]
4287 fn an_inert_overlay_hands_the_point_to_the_overlay_beneath_it() {
4288 let (tree, panel, inert) = panel_and_an_inert_overlay(
4289 crate::overlay::DismissBehavior::Manual,
4290 crate::overlay::DismissBehavior::EscapeKey,
4291 Point::new(30.0, 30.0),
4292 );
4293 let at = Point::new(40.0, 40.0);
4294 let over = tree.overlay_manager.find_by_content(inert).unwrap();
4295 assert!(
4296 tree.overlay_content_bounds(over).unwrap().contains(at),
4297 "fixture: the inert overlay covers the point"
4298 );
4299 assert_eq!(
4300 tree.hit_test(at),
4301 Some(panel),
4302 "the panel under it takes the point, not the window under both"
4303 );
4304 }
4305
4306 #[test]
4307 fn a_press_on_an_inert_overlay_is_outside_the_overlays_it_is_outside_of() {
4308 let (mut tree, panel, inert) = panel_and_an_inert_overlay(
4309 crate::overlay::DismissBehavior::ClickOutside,
4310 crate::overlay::DismissBehavior::EscapeKey,
4311 Point::new(200.0, 100.0),
4312 );
4313 let at = Point::new(220.0, 110.0);
4314 let over = tree.overlay_manager.find_by_content(inert).unwrap();
4315 assert!(
4316 tree.overlay_content_bounds(over).unwrap().contains(at),
4317 "fixture: the press lands on the inert overlay"
4318 );
4319 tree.pointer_down_button(at, crate::event::PointerButton::Primary);
4320 assert_eq!(
4321 tree.overlay_manager.find_by_content(panel),
4322 None,
4323 "the press was outside the panel, whatever floats over that spot",
4324 );
4325 }
4326
4327 #[test]
4328 fn an_inert_overlay_is_not_an_interactive_rect() {
4329 let (tree, panel, _inert) = panel_and_an_inert_overlay(
4332 crate::overlay::DismissBehavior::Manual,
4333 crate::overlay::DismissBehavior::EscapeKey,
4334 Point::new(200.0, 100.0),
4335 );
4336 let panel_bounds = tree
4337 .overlay_content_bounds(tree.overlay_manager.find_by_content(panel).unwrap())
4338 .unwrap();
4339 assert_eq!(tree.overlay_manager.interactive_rects(), vec![panel_bounds]);
4340 }
4341
4342 #[test]
4343 fn escape_steps_over_an_inert_overlay_to_the_one_beneath() {
4344 let (mut tree, panel, inert) = panel_and_an_inert_overlay(
4347 crate::overlay::DismissBehavior::EscapeKey,
4348 crate::overlay::DismissBehavior::Manual,
4349 Point::new(200.0, 100.0),
4350 );
4351 tree.press_key(Key::Escape, Modifiers::NONE);
4352 assert_eq!(
4353 tree.overlay_manager.find_by_content(panel),
4354 None,
4355 "the panel beneath took the Escape"
4356 );
4357 assert!(
4358 tree.overlay_manager.find_by_content(inert).is_some(),
4359 "and the inert one, which Escape may not close, is still up"
4360 );
4361 }
4362
4363 #[test]
4364 fn an_inert_overlay_over_the_window_hands_the_point_to_the_window() {
4365 let mut tree = WidgetTree::new();
4369 let page = tree.add(FillWidget::new());
4370 let inert = tree.add(Block(60.0, 40.0));
4371 tree.show_overlay(
4372 crate::overlay::OverlayRequest::new(
4373 inert,
4374 page,
4375 crate::overlay::OverlayPlacement::AtPointer(Point::new(200.0, 100.0)),
4376 crate::overlay::DismissBehavior::EscapeKey,
4377 )
4378 .inert(),
4379 );
4380 tree.layout(SizeProposal::exact(400.0, 200.0));
4381 let at = Point::new(220.0, 110.0);
4382 assert!(
4383 tree.overlay_content_bounds(tree.overlay_manager.find_by_content(inert).unwrap())
4384 .unwrap()
4385 .contains(at),
4386 "fixture: the inert overlay covers the point"
4387 );
4388 assert_eq!(tree.hit_test(at), Some(page));
4389 tree.pointer_move(at);
4390 assert_eq!(tree.hovered(), Some(page), "and so does a hover");
4391 }
4392
4393 #[test]
4394 fn a_root_that_is_hit_transparent_and_pass_through_is_not_inert() {
4395 use crate::widget_builder::WidgetBuilder;
4396
4397 let flagged = || {
4401 Block(60.0, 40.0)
4402 .hit_transparent(true)
4403 .event_pass_through(true)
4404 };
4405 let at = Point::new(220.0, 110.0);
4406
4407 let (mut tree, panel, top) = panel_and_an_overlay_above(
4408 crate::overlay::DismissBehavior::ClickOutside,
4409 flagged(),
4410 crate::overlay::DismissBehavior::Manual,
4411 Point::new(200.0, 100.0),
4412 false,
4413 );
4414 let over = tree.overlay_manager.find_by_content(top).unwrap();
4415 assert!(
4416 tree.overlay_content_bounds(over).unwrap().contains(at),
4417 "fixture: the press lands on the flagged overlay"
4418 );
4419 assert_eq!(
4420 tree.overlay_manager.hit_test(at),
4421 Some(over),
4422 "the stack still answers with the overlay"
4423 );
4424 assert_eq!(
4425 tree.overlay_manager.interactive_rects().len(),
4426 2,
4427 "which is an interactive rect"
4428 );
4429 tree.pointer_down_button(at, crate::event::PointerButton::Primary);
4430 tree.pointer_up_button(at, crate::event::PointerButton::Primary);
4431 assert!(
4432 tree.overlay_manager.find_by_content(panel).is_some(),
4433 "a press on it is inside the stack, so the panel beneath stays"
4434 );
4435
4436 let (mut tree, panel, top) = panel_and_an_overlay_above(
4437 crate::overlay::DismissBehavior::EscapeKey,
4438 flagged(),
4439 crate::overlay::DismissBehavior::Manual,
4440 Point::new(200.0, 100.0),
4441 false,
4442 );
4443 tree.press_key(Key::Escape, Modifiers::NONE);
4444 assert!(
4445 tree.overlay_manager.find_by_content(panel).is_some()
4446 && tree.overlay_manager.find_by_content(top).is_some(),
4447 "a `Manual` overlay owns the Escape: nothing beneath it closes"
4448 );
4449
4450 let (mut tree, panel, top) = panel_and_an_overlay_above(
4451 crate::overlay::DismissBehavior::EscapeKey,
4452 flagged(),
4453 crate::overlay::DismissBehavior::EscapeKey,
4454 Point::new(200.0, 100.0),
4455 false,
4456 );
4457 tree.press_key(Key::Escape, Modifiers::NONE);
4458 assert_eq!(
4459 tree.overlay_manager.find_by_content(top),
4460 None,
4461 "an `EscapeKey` one is what the Escape closes"
4462 );
4463 assert!(
4464 tree.overlay_manager.find_by_content(panel).is_some(),
4465 "and it is spent there"
4466 );
4467 }
4468
4469 #[test]
4470 fn an_inert_overlay_records_no_focus_to_give_back_on_any_show_path() {
4471 type Show = fn(&mut WidgetTree, crate::overlay::OverlayRequest, WidgetId);
4472 fn from_a_handler(
4473 tree: &mut WidgetTree,
4474 show: impl FnOnce(&mut crate::widget::EventContext),
4475 ) {
4476 tree.run_with_event_context(&mut crate::window::NoopWindowOps, show);
4477 }
4478 let paths: [(&str, Show); 5] = [
4479 ("show_overlay", |tree, request, _| {
4480 from_a_handler(tree, |ctx| ctx.show_overlay(request))
4481 }),
4482 ("show_overlay_for", |tree, request, _| {
4483 from_a_handler(tree, |ctx| {
4484 ctx.show_overlay_for(request, std::time::Duration::from_secs(60))
4485 })
4486 }),
4487 ("show_overlay_with_reveal", |tree, request, _| {
4488 from_a_handler(tree, |ctx| {
4489 ctx.show_overlay_with_reveal(
4490 request,
4491 crate::signal::Signal::new(0.0),
4492 std::time::Duration::from_millis(100),
4493 )
4494 })
4495 }),
4496 ("show_overlay_after", |tree, request, _| {
4497 from_a_handler(tree, |ctx| {
4498 ctx.show_overlay_after(request, std::time::Duration::ZERO)
4499 });
4500 tree.layout(SizeProposal::exact(400.0, 200.0));
4501 }),
4502 ("show_overlay_from_source", |tree, request, field| {
4503 tree.show_overlay_from_source(field, request);
4504 }),
4505 ];
4506 for (path, show) in paths {
4507 let mut tree = WidgetTree::new();
4508 let field = tree.add(FillWidget::new().focusable());
4509 let inert = tree.add(Block(60.0, 40.0));
4510 let ordinary = tree.add(Block(60.0, 40.0));
4511 tree.layout(SizeProposal::exact(400.0, 200.0));
4512 tree.focus(field);
4513 for (content, inert) in [(inert, true), (ordinary, false)] {
4514 let request = crate::overlay::OverlayRequest::new(
4515 content,
4516 field,
4517 crate::overlay::OverlayPlacement::AtPointer(Point::new(20.0, 20.0)),
4518 crate::overlay::DismissBehavior::EscapeKey,
4519 );
4520 show(
4521 &mut tree,
4522 if inert { request.inert() } else { request },
4523 field,
4524 );
4525 }
4526 let restore = |content: WidgetId| {
4527 tree.overlay_manager
4528 .stack
4529 .iter()
4530 .find(|o| o.content_id == content)
4531 .map(|o| o.focus_restore)
4532 };
4533 assert_eq!(
4534 restore(ordinary),
4535 Some(Some(field)),
4536 "{path}: an ordinary one does"
4537 );
4538 assert_eq!(
4539 restore(inert),
4540 Some(None),
4541 "{path}: an inert one took no focus"
4542 );
4543 }
4544 }
4545}