1use super::*;
9
10use crate::event::ButtonMask;
11use crate::gesture::{GestureEvent, RawPointerEvent, TapEvent};
12
13fn fire_event_handler_both(
17 external: &mut Option<Box<dyn FnMut(&WidgetEvent, &mut EventContext) -> EventResponse>>,
18 own: &mut Option<Box<dyn FnMut(&WidgetEvent, &mut EventContext) -> EventResponse>>,
19 event: &WidgetEvent,
20 ctx: &mut EventContext,
21) -> EventResponse {
22 let r1 = external
23 .as_mut()
24 .map(|h| h(event, ctx))
25 .unwrap_or(EventResponse::Ignored);
26 let r2 = own
27 .as_mut()
28 .map(|h| h(event, ctx))
29 .unwrap_or(EventResponse::Ignored);
30 if r1 == EventResponse::Handled || r2 == EventResponse::Handled {
31 EventResponse::Handled
32 } else {
33 EventResponse::Ignored
34 }
35}
36
37pub(super) enum QueuedDispatch {
44 Event {
51 event: WidgetEvent,
52 snapshot: Box<crate::pointer::InputSnapshot>,
53 },
54 Cancel {
65 pointer: crate::pointer::PointerId,
66 reason: crate::pointer::CancelReason,
67 recipient: Option<WidgetId>,
75 },
76}
77
78fn pointer_event_position(event: &WidgetEvent) -> Option<Point> {
84 match event {
85 WidgetEvent::PointerDown { position, .. }
86 | WidgetEvent::PointerUp { position, .. }
87 | WidgetEvent::PointerMove { position, .. } => Some(*position),
88 _ => None,
92 }
93}
94
95#[derive(Copy, Clone)]
100struct BubbleGates {
101 fire_on_pointer_event: bool,
109 arena_blocked: bool,
114}
115
116impl WidgetTree {
117 fn scope_distance_from_focus(&self, focus: WidgetId, scope_id: WidgetId) -> Option<usize> {
129 let mut hops = 0usize;
130 let mut current = Some(focus);
131 while let Some(id) = current {
132 if id == scope_id {
133 return Some(hops);
134 }
135 current = self.arena.parent(id);
136 hops += 1;
137 }
138 None
139 }
140
141 pub(crate) fn focus_or_modal(&self) -> Option<WidgetId> {
147 self.focused
148 .filter(|id| self.arena.is_active(*id))
149 .or_else(|| {
150 self.overlay_manager
151 .topmost_modal()
152 .map(|overlay| overlay.content_id)
153 })
154 }
155
156 fn select_shortcut_for_focus(
167 &self,
168 candidates: &[(&'static str, crate::shortcut::ShortcutScope, bool)],
169 ) -> Option<(&'static str, crate::shortcut::ShortcutScope, bool)> {
170 use crate::shortcut::ShortcutScope;
171 let mut best: Option<(usize, (&'static str, ShortcutScope, bool))> = None;
172 let focus = self.focus_or_modal();
181 let modal = focus.and_then(|f| self.intent_walk(f, &[]).2);
182 for &(id, scope, propagate) in candidates {
183 let score = match scope {
188 ShortcutScope::Global => (crate::shortcut::is_framework_shortcut_id(id) || {
189 let owners = self.shortcut_registry.owners(id);
190 owners.is_empty()
191 || owners
192 .iter()
193 .any(|&owner| self.global_applies(owner, modal))
194 })
195 .then_some(0usize),
196 ShortcutScope::Scoped(scope_id) => focus
197 .and_then(|f| self.scope_distance_from_focus(f, scope_id))
198 .map(|hops| usize::MAX - hops),
199 };
200 let Some(score) = score else { continue };
201 if best.as_ref().is_none_or(|(b, _)| score > *b) {
204 best = Some((score, (id, scope, propagate)));
205 }
206 }
207 best.map(|(_, c)| c)
208 }
209
210 pub fn dispatch_event_with_ops(
224 &mut self,
225 event: WidgetEvent,
226 ops: &mut dyn crate::window::WindowOps,
227 ) {
228 let mut snapshot = crate::pointer::InputSnapshot::from_event(&event);
231 if snapshot.pointer.time == crate::pointer::EventTime::ZERO {
236 snapshot.pointer.time = self.input_now();
237 }
238 self.dispatch_with_input_snapshot(event, snapshot, ops)
239 }
240
241 pub fn dispatch_event(&mut self, event: WidgetEvent) {
247 let mut noop = crate::window::NoopWindowOps;
248 self.dispatch_event_with_ops(event, &mut noop);
249 }
250
251 pub fn dispatch_pointer(&mut self, sample: crate::pointer::PointerSample) {
273 let mut noop = crate::window::NoopWindowOps;
274 self.dispatch_pointer_with_ops(sample, &mut noop);
275 }
276
277 pub fn dispatch_pointer_with_ops(
281 &mut self,
282 sample: crate::pointer::PointerSample,
283 ops: &mut dyn crate::window::WindowOps,
284 ) {
285 use crate::pointer::PointerPhase;
286
287 crate::trace_input!(
288 Samples,
289 "{:?} {:?} at {:?} buttons={:?} t={:?}",
290 sample.phase,
291 sample.pointer.id,
292 sample.position,
293 sample.pointer.buttons,
294 sample.pointer.time
295 );
296
297 let button = sample
301 .button
302 .unwrap_or(crate::event::PointerButton::Primary);
303 let event = match sample.phase {
304 PointerPhase::Down => WidgetEvent::PointerDown {
305 position: sample.position,
306 button,
307 modifiers: sample.modifiers,
308 pointer: sample.pointer,
309 },
310 PointerPhase::Move => WidgetEvent::PointerMove {
311 position: sample.position,
312 modifiers: sample.modifiers,
313 pointer: sample.pointer,
314 },
315 PointerPhase::Up => WidgetEvent::PointerUp {
316 position: sample.position,
317 button,
318 modifiers: sample.modifiers,
319 pointer: sample.pointer,
320 },
321 PointerPhase::Cancel => {
327 self.overlay_manager.abort_dismiss(sample.pointer.id);
332 self.cancel_pointer(
333 sample.pointer.id,
334 crate::pointer::CancelReason::Platform,
335 ops,
336 );
337 if !sample.pointer.kind.hovers() {
344 self.pointers.end(sample.pointer.id);
345 }
346 return;
347 }
348 };
349
350 if !self.pointers.would_admit(&sample.pointer) {
356 return;
357 }
358 let ends_pointer = matches!(sample.phase, PointerPhase::Up | PointerPhase::Cancel)
362 && !sample.pointer.kind.hovers();
363 let pointer_id = sample.pointer.id;
364
365 let snapshot = crate::pointer::InputSnapshot::from_pointer_sample(&sample);
366 self.dispatch_with_input_snapshot(event, snapshot, ops);
367
368 if ends_pointer {
369 self.pointers.end(pointer_id);
370 }
371 }
372
373 pub fn dispatch_scroll(&mut self, sample: crate::pointer::ScrollSample) {
381 let mut noop = crate::window::NoopWindowOps;
382 self.dispatch_scroll_with_ops(sample, &mut noop);
383 }
384
385 pub fn dispatch_scroll_with_ops(
388 &mut self,
389 sample: crate::pointer::ScrollSample,
390 ops: &mut dyn crate::window::WindowOps,
391 ) {
392 crate::trace_input!(
393 Samples,
394 "scroll {:?} {:?}/{:?} at {:?}",
395 sample.delta,
396 sample.phase,
397 sample.source,
398 sample.position
399 );
400
401 let event = WidgetEvent::Scroll {
402 delta: sample.delta,
403 modifiers: sample.modifiers,
404 window_position: sample.position,
405 phase: sample.phase,
406 pointer: sample.pointer,
407 };
408 let snapshot = crate::pointer::InputSnapshot::from_scroll_sample(&sample);
409 self.dispatch_with_input_snapshot(event, snapshot, ops);
410 }
411
412 pub fn pointer_left_window(&mut self, ops: &mut dyn crate::window::WindowOps) {
437 if self
441 .pointers
442 .hover_owner_id()
443 .and_then(|id| self.captured_by(id))
444 .is_some()
445 {
446 return;
447 }
448 self.hover_owner_outside_window = true;
449 self.tooltip_dwell_held = false;
450 let Some(hovered) = self.hovered_id() else {
451 return;
452 };
453 let leave = WidgetEvent::PointerLeave {
456 pointer: self.hover_transition_pointer(),
457 };
458 self.dispatch_to_widget(hovered, &leave, &mut *ops);
459 self.tooltip_pointer_leave(hovered, &mut *ops);
460 self.set_hovered(None);
461 self.update_hover_within_signals(Some(hovered), None);
462 }
463
464 pub(super) fn hover_transition_pointer(&self) -> crate::pointer::PointerInfo {
481 self.pointers
482 .hover_owner()
483 .map(|entry| entry.info)
484 .unwrap_or_else(|| crate::pointer::PointerInfo::mouse(self.input_now()))
485 }
486
487 fn dispatch_with_input_snapshot(
494 &mut self,
495 event: WidgetEvent,
496 snapshot: crate::pointer::InputSnapshot,
497 ops: &mut dyn crate::window::WindowOps,
498 ) {
499 self.pending_dispatch.push_back(QueuedDispatch::Event {
509 event,
510 snapshot: Box::new(snapshot),
511 });
512 if self.dispatch_depth > 0 {
513 return;
514 }
515 self.drain_pending_dispatch(&mut *ops);
516 }
517
518 pub(super) fn drain_pending_dispatch(&mut self, ops: &mut dyn crate::window::WindowOps) {
524 while let Some(queued) = self.pending_dispatch.pop_front() {
525 match queued {
526 QueuedDispatch::Event { event, snapshot } => {
527 self.run_one_dispatch(event, *snapshot, &mut *ops);
528 }
529 QueuedDispatch::Cancel {
530 pointer,
531 reason,
532 recipient,
533 } => {
534 self.run_one_cancel(pointer, reason, recipient, &mut *ops);
535 }
536 }
537 }
538 }
539
540 fn run_one_dispatch(
547 &mut self,
548 event: WidgetEvent,
549 snapshot: crate::pointer::InputSnapshot,
550 ops: &mut dyn crate::window::WindowOps,
551 ) {
552 let previous = std::mem::replace(&mut self.current_input, snapshot);
553 self.dispatch_depth += 1;
554 self.dispatch_event_impl(event, ops);
555 self.dispatch_depth -= 1;
556 self.current_input = previous;
557 }
558
559 fn dismiss_top_on_escape(&mut self, ops: &mut dyn crate::window::WindowOps) -> bool {
563 let mark = self.dismissal_mark();
564 let Some((_id, content_ids, focus_restore)) =
565 self.overlay_manager.try_dismiss_top_on_escape()
566 else {
567 return false;
568 };
569 self.dormant_dismissed_content(&content_ids, ops);
570 self.return_focus_after_dismissal(focus_restore, mark, ops);
571 true
572 }
573
574 fn escape_taken_inside_top_overlay(
589 &mut self,
590 event: &WidgetEvent,
591 ops: &mut dyn crate::window::WindowOps,
592 ) -> bool {
593 let Some((_, content)) = self.overlay_manager.top_escape_target() else {
594 return false;
595 };
596 let Some(focus) = self.focused else {
597 return false;
598 };
599 let mut path = Vec::new();
600 let mut current = self.arena.parent(focus);
601 let mut inside = false;
602 while let Some(id) = current {
603 path.push(id);
604 if id == content {
605 inside = true;
606 break;
607 }
608 current = self.arena.parent(id);
609 }
610 if !inside || !self.arena.is_enabled(focus) {
611 return false;
612 }
613 for &id in path.iter().rev() {
614 let frame = self.arena.local_frame(id);
615 let mut ctx = self
616 .make_event_context(&mut *ops)
617 .with_dispatch_node(id)
618 .with_content_language(self.content_language(id))
619 .with_dispatch_target(focus)
620 .with_local_frame(frame);
621 let response = if let Some(node) = self.arena.get_mut(id) {
622 Self::try_handler_preview(node, event, &mut ctx).unwrap_or(EventResponse::Ignored)
623 } else {
624 EventResponse::Ignored
625 };
626 self.collect_from_ctx(ctx, id);
627 if response == EventResponse::Handled {
628 self.arena.mark_needs_paint(id);
629 self.note_key_press(focus);
632 return true;
633 }
634 }
635 false
636 }
637
638 #[doc(hidden)]
652 pub fn answer_close_request_with_modal(
653 &mut self,
654 ops: &mut dyn crate::window::WindowOps,
655 ) -> bool {
656 if !self.overlay_manager.has_open_modal() {
657 return false;
658 }
659 self.tooltip_escape_pressed();
662 self.inert_overlays_escape_pressed(ops);
663 self.dismiss_top_on_escape(ops);
664 true
665 }
666
667 fn note_key_press(&mut self, target: WidgetId) {
671 let Some((identity, repeat)) = self.current_key else {
672 return;
673 };
674 match self.key_presses.iter_mut().find(|(id, _)| *id == identity) {
675 Some(_) if repeat => {}
676 Some(record) => record.1 = target,
677 None => self.key_presses.push((identity, target)),
678 }
679 }
680
681 fn receives_every_key_release(&self, id: WidgetId) -> bool {
685 self.arena
686 .get(id)
687 .is_some_and(|node| node.receives_every_key_release)
688 }
689
690 fn dispatch_key_release(
701 &mut self,
702 key: Key,
703 event: &WidgetEvent,
704 ops: &mut dyn crate::window::WindowOps,
705 ) {
706 let identity = self.current_key.map(|(id, _)| id);
707 let pressed = identity.and_then(|identity| {
708 let at = self
709 .key_presses
710 .iter()
711 .position(|(id, _)| *id == identity)?;
712 Some(self.key_presses.remove(at).1)
713 });
714 match pressed {
715 Some(target) if Some(target) == self.focused => {
716 self.dispatch_to_widget(target, event, &mut *ops);
717 }
718 Some(target) => {
719 if self.arena.is_active(target)
720 && (!self.is_behind_modal(target)
721 || self.is_keyboard_capture(target)
722 || self.receives_every_key_release(target))
723 {
724 let behind_modal = self.is_behind_modal(target);
730 let mut current = Some(target);
731 while let Some(id) = current {
732 if self.dispatch_to_widget_direct_returning_handled(id, event, &mut *ops)
733 || behind_modal
734 {
735 break;
736 }
737 current = self.arena.parent(id);
738 }
739 }
740 }
741 None if matches!(key, Key::Enter | Key::Space) => {}
742 None => {
743 if let Some(focused) = self.focused {
744 self.dispatch_to_widget(focused, event, &mut *ops);
745 }
746 }
747 }
748 }
749
750 fn dispatch_event_impl(&mut self, event: WidgetEvent, ops: &mut dyn crate::window::WindowOps) {
751 if let Some(position) = pointer_event_position(&event) {
757 let is_down = matches!(event, WidgetEvent::PointerDown { .. });
758 let is_move = matches!(event, WidgetEvent::PointerMove { .. });
759 if !self.admit_current_pointer(position, is_down, is_move) {
760 return;
761 }
762 if self.current_input.pointer.kind.hovers() {
766 self.claim_hover_owner_for_current(&mut *ops);
767 }
768 }
769
770 if let WidgetEvent::KeyDown { key, .. } | WidgetEvent::KeyUp { key, .. } = &event {
773 let noted = self
774 .window_state
775 .as_ref()
776 .and_then(|w| w.take_key_identity());
777 self.current_key = Some(noted.unwrap_or_else(|| (logical_key_identity(*key), false)));
778 } else if self.dispatch_depth <= 1 {
779 self.current_key = None;
781 }
782
783 match &event {
787 WidgetEvent::KeyDown { .. } if !self.focus_visible.get() => {
788 self.focus_visible.set(true);
789 }
790 WidgetEvent::PointerDown { .. } if self.focus_visible.get() => {
791 self.focus_visible.set(false);
792 }
793 _ => {}
794 }
795
796 let overlay_back_key = match self.layout_direction {
802 crate::environment::LayoutDirection::RightToLeft => Key::ArrowRight,
803 crate::environment::LayoutDirection::LeftToRight => Key::ArrowLeft,
804 };
805 if let WidgetEvent::KeyDown { key, .. } = &event
806 && *key == overlay_back_key
807 {
808 let nested_menu_overlays = {
838 let ids: Vec<_> = self
839 .overlay_manager
840 .stack
841 .iter()
842 .filter(|o| o.band == crate::overlay::OverlayBand::Standard && !o.inert)
843 .map(|o| o.id)
844 .collect();
845 ids.into_iter()
846 .filter(|&id| !self.overlay_is_host_surface(id))
847 .count()
848 };
849 let top_id = self
856 .overlay_manager
857 .stack
858 .iter()
859 .rev()
860 .find(|o| !o.inert)
861 .map(|o| o.id);
862 let top_is_back_navigable = top_id.is_some_and(|id| !self.overlay_is_host_surface(id));
863 if nested_menu_overlays > 1
864 && top_is_back_navigable
865 && let Some(top_id) = top_id
866 {
867 let mark = self.dismissal_mark();
868 let (content_ids, focus_restore) =
869 self.overlay_manager.dismiss_with_focus_restore_because(
870 top_id,
871 crate::overlay::DismissReason::Escape,
872 );
873 self.dormant_dismissed_content(&content_ids, &mut *ops);
874 self.return_focus_after_dismissal(focus_restore, mark, &mut *ops);
875 return;
876 }
877 }
878
879 if let WidgetEvent::KeyDown {
885 key: Key::Escape, ..
886 } = &event
887 {
888 self.tooltip_escape_pressed();
889 self.inert_overlays_escape_pressed(&mut *ops);
892 }
893
894 if let WidgetEvent::KeyDown {
895 key: Key::Escape, ..
896 } = &event
897 && !self.overlay_manager.is_empty()
898 && (self.escape_taken_inside_top_overlay(&event, &mut *ops)
899 || self.dismiss_top_on_escape(&mut *ops))
900 {
901 return;
902 }
903
904 match &event {
909 WidgetEvent::PointerDown {
910 position, button, ..
911 } => {
912 if self.arm_outside_press_dismissal(*position, *button, &mut *ops) {
913 return;
914 }
915 }
916 WidgetEvent::PointerUp { position, .. } => {
917 if self.commit_outside_press_dismissal(*position, &mut *ops) {
918 return;
919 }
920 }
921 WidgetEvent::PointerCancel { pointer, .. } => {
922 self.overlay_manager.abort_dismiss(pointer.id);
926 }
927 _ => {}
928 }
929
930 if let WidgetEvent::KeyDown { key, modifiers, .. } = &event
941 && let Some(callback) = self.take_key_capture()
942 {
943 let keystroke = crate::shortcut::KeyStroke::new(*key, *modifiers);
944 let mut cap_ctx = self.make_event_context(&mut *ops);
945 callback(keystroke, self.shortcut_registry_mut(), &mut cap_ctx);
946 let anchor = self.focused.or_else(|| self.intent_anchor());
949 if let Some(anchor_id) = anchor {
950 self.collect_from_ctx(cap_ctx, anchor_id);
951 self.drain_pending_intents(&mut *ops);
952 }
953 return;
954 }
955
956 let focus_captures_keys = matches!(&event, WidgetEvent::KeyDown { .. })
964 && self.focused.is_some_and(|f| self.is_keyboard_capture(f));
965
966 if !focus_captures_keys && let WidgetEvent::KeyDown { key, modifiers, .. } = &event {
982 let keystroke = crate::shortcut::KeyStroke::new(*key, *modifiers);
983 let candidates: Vec<(&'static str, crate::shortcut::ShortcutScope, bool)> = self
992 .shortcut_registry
993 .matches_by_keystroke(keystroke)
994 .map(|eff| {
995 (
996 eff.shortcut.id,
997 eff.shortcut.scope,
998 eff.shortcut.propagate_when_disabled,
999 )
1000 })
1001 .collect();
1002 let (region_commands, others): (Vec<_>, Vec<_>) = candidates
1008 .into_iter()
1009 .partition(|(id, _, _)| crate::shortcut::region_direction(id).is_some());
1010 let lookup = self.select_shortcut_for_focus(&others).or_else(|| {
1011 let source = self.focus_or_modal().or_else(|| self.intent_anchor());
1012 let live: Vec<_> = region_commands
1013 .into_iter()
1014 .filter(|(id, _, _)| {
1015 crate::shortcut::region_direction(id).is_some_and(|forward| {
1016 self.region_cycle_target_from(source, forward).is_some()
1017 || source.is_some_and(|source| self.can_handle_from(source, id))
1018 })
1019 })
1020 .collect();
1021 self.select_shortcut_for_focus(&live)
1022 });
1023 if let Some((id, scope, propagate_when_disabled)) = lookup {
1024 let anchor = match scope {
1025 crate::shortcut::ShortcutScope::Global => {
1031 self.focus_or_modal().or_else(|| self.intent_anchor())
1032 }
1033 crate::shortcut::ShortcutScope::Scoped(scope_id) => self
1034 .focus_or_modal()
1035 .filter(|f| self.scope_distance_from_focus(*f, scope_id).is_some()),
1036 };
1037 if let Some(anchor_id) = anchor {
1038 let mut act_ctx = self.make_event_context(&mut *ops);
1039 if let Some(intent) =
1040 self.shortcut_registry
1041 .invoke_on_activate(id, keystroke, &mut act_ctx)
1042 {
1043 self.collect_from_ctx(act_ctx, anchor_id);
1044 self.drain_pending_intents(&mut *ops);
1048 let intent = self.sent_here(
1052 intent.with_source(crate::telemetry::IntentSource::Shortcut),
1053 );
1054 let keep = self.keeps_unclaimed(&intent).then(|| intent.clone());
1055 let consumed = self.dispatch_intent(
1056 anchor_id,
1057 intent,
1058 propagate_when_disabled,
1059 &mut *ops,
1060 );
1061 self.drain_pending_intents(&mut *ops);
1062 if consumed {
1063 return;
1064 }
1065 if let Some(intent) = keep {
1068 self.keep_unclaimed(intent, &mut *ops);
1069 return;
1070 }
1071 }
1078 }
1079 }
1084 }
1087
1088 if self.outbound_drag_source.is_some()
1094 && let WidgetEvent::KeyDown {
1095 key: Key::Escape, ..
1096 } = &event
1097 {
1098 ops.cancel_os_drag();
1099 }
1104
1105 if self.os_drag_reentered
1119 && matches!(
1120 event,
1121 WidgetEvent::PointerMove { .. } | WidgetEvent::PointerUp { .. }
1122 )
1123 {
1124 let dragging = self.current_pointer_id();
1125 let own = self
1126 .active_drag
1127 .as_ref()
1128 .is_some_and(|d| d.pointer.id == dragging);
1129 if own && matches!(event, WidgetEvent::PointerMove { .. }) {
1130 return;
1131 }
1132 } else if self.active_drag.is_some() {
1133 match &event {
1134 WidgetEvent::PointerMove { position, .. } => {
1135 self.handle_drag_sample(*position, &mut *ops);
1136 return;
1137 }
1138 WidgetEvent::PointerUp { position, .. } => {
1139 self.handle_drag_drop(*position, &mut *ops);
1140 return;
1141 }
1142 WidgetEvent::KeyDown {
1143 key: Key::Escape, ..
1144 } => {
1145 self.cancel_active_drag(&mut *ops);
1146 return;
1147 }
1148 WidgetEvent::Scroll { .. } => {
1149 let target_and_pos = self
1155 .active_drag
1156 .as_ref()
1157 .and_then(|d| d.current_target.map(|t| (t, d.current_position)));
1158 if let Some((target, _pos)) = target_and_pos {
1159 self.dispatch_to_widget(target, &event, &mut *ops);
1160 }
1161 if let Some((_, pos)) = target_and_pos
1162 && self.active_drag.is_some()
1163 {
1164 self.handle_drag_move(pos, &mut *ops);
1165 }
1166 return;
1167 }
1168 _ => {}
1169 }
1170 }
1171
1172 if let WidgetEvent::KeyDown { key, modifiers, .. } = &event
1181 && is_context_menu_chord(*key, *modifiers)
1182 && self.open_context_menu_from_keyboard(&mut *ops)
1183 {
1184 return;
1185 }
1186
1187 match &event {
1188 WidgetEvent::PointerMove { position, .. } => {
1189 self.note_sequence_position(*position);
1193 self.revalidate_sequence(&mut *ops);
1194 self.tick_sequence_timers();
1197 self.note_palm_sample(*position);
1202 self.feed_pinch(super::pan_arbiter::PinchFeed::Move, *position, &mut *ops);
1203 if let Some(captured) = self.current_pointer_capture() {
1204 self.dispatch_to_widget(captured, &event, &mut *ops);
1205 if self.active_drag.is_none() {
1210 self.advance_sequence(&event, &mut *ops);
1211 }
1212 } else {
1213 self.handle_pointer_move(&event, *position, &mut *ops);
1214 if self.active_drag.is_none() {
1219 self.advance_sequence(&event, &mut *ops);
1220 }
1221 }
1222 self.advance_pan(*position, &mut *ops);
1225 self.update_press(*position);
1228 self.touch_route_moved(self.current_pointer_id());
1231 if self.pointers.hover_owner_id() == Some(self.current_pointer_id()) {
1241 self.update_pointer_leave_overlays(*position, &mut *ops);
1242 }
1243 }
1244 WidgetEvent::PointerDown {
1245 position, button, ..
1246 } => {
1247 let pressed = self.current_pointer_id();
1250 self.cancelled_pointers.retain(|p| *p != pressed);
1251 self.tooltip_pointer_press(Some(*position));
1258 let pressing = self.current_input.pointer;
1262 if let Some(target) = self.hit_test_for(*position, &pressing) {
1263 if *button == PointerButton::Secondary
1264 && self.show_context_menu_for(
1265 target,
1266 *position,
1267 crate::widget_builder::ContextMenuTrigger::Pointer,
1268 &mut *ops,
1269 )
1270 {
1271 return;
1272 }
1273 self.begin_sequence(target, *position);
1279 let modifiers = match &event {
1284 WidgetEvent::PointerDown { modifiers, .. } => *modifiers,
1285 _ => crate::event::Modifiers::NONE,
1286 };
1287 self.begin_pan(target, *position, modifiers);
1288 self.begin_palm_watch(*position);
1289 self.feed_pinch(super::pan_arbiter::PinchFeed::Down, *position, &mut *ops);
1290 let focusable = self.find_focusable_at_or_above(target);
1294 self.begin_press(focusable);
1295 if !pressing.kind.is_direct()
1305 && let Some(focusable) = focusable
1306 && self.click_may_focus(focusable)
1307 {
1308 self.focus_with_origin_ops(
1309 focusable,
1310 crate::focus::FocusOrigin::Pointer(pressing.kind),
1311 &mut *ops,
1312 );
1313 }
1314 self.dispatch_to_widget(target, &event, &mut *ops);
1315 if self.active_drag.is_none() {
1320 self.enrol_sequence_members(&event, &mut *ops);
1321 }
1322 self.adopt_press_owner(*button);
1326 self.arm_touch_route(target, *position);
1331 }
1332 }
1333 WidgetEvent::PointerUp {
1334 position, button, ..
1335 } => {
1336 let released = self.current_pointer_id();
1342 self.cancel_touch_route(released);
1346 if let Some(index) = self.cancelled_pointers.iter().position(|p| *p == released) {
1347 self.cancelled_pointers.swap_remove(index);
1348 crate::trace_input!(
1349 Samples,
1350 "swallowing the Up for {released:?}: its press was cancelled"
1351 );
1352 return;
1353 }
1354 self.feed_pinch(super::pan_arbiter::PinchFeed::Up, *position, &mut *ops);
1361 if self.take_palm_verdict(released) {
1362 crate::trace_input!(
1363 Samples,
1364 "{released:?} released as a palm: large, and it never moved"
1365 );
1366 self.cancel_pointer(
1367 released,
1368 crate::pointer::CancelReason::PalmRejected,
1369 &mut *ops,
1370 );
1371 return;
1372 }
1373 self.end_pan(*position, &mut *ops);
1376 self.note_sequence_position(*position);
1383 let taps_unfocusable = self.release_taps_unfocusable(*position, *button);
1386 self.end_sequence(&event, &mut *ops);
1387 self.focus_on_release(*position, taps_unfocusable, &mut *ops);
1392 if let Some(captured) = self.current_pointer_capture() {
1393 self.dispatch_to_widget(captured, &event, &mut *ops);
1394 self.set_current_pointer_capture(None);
1397 } else {
1398 let releasing = self.current_input.pointer;
1399 if let Some(target) = self.hit_test_for(*position, &releasing) {
1400 self.dispatch_to_widget(target, &event, &mut *ops);
1401 }
1402 }
1403 let released = self.current_pointer_id();
1406 self.release_arenas_following(released);
1407 self.end_press(released);
1411 }
1412 WidgetEvent::PointerCancel {
1413 reason, pointer, ..
1414 } => {
1415 let (reason, pointer) = (*reason, pointer.id);
1420 self.cancel_pointer(pointer, reason, &mut *ops);
1421 }
1422 WidgetEvent::Scroll {
1423 window_position: position,
1424 ..
1425 } => {
1426 use super::pan_arbiter::ScrollDelivery;
1427 match ScrollDelivery::for_source(self.current_input.scroll_source) {
1428 ScrollDelivery::ClaimantChain => {
1433 let position = *position;
1434 self.route_scroll_along_chain(&event, position, &mut *ops);
1435 }
1436 ScrollDelivery::Bubble => {
1442 let scrolling = self.current_input.pointer;
1443 let target = match position {
1444 Some(p) => self.hit_test_for(*p, &scrolling),
1445 None => self.hovered_id().or(self.focused),
1446 };
1447 if let Some(target) = target {
1448 self.dispatch_to_widget(target, &event, &mut *ops);
1449 }
1450 }
1451 }
1452 }
1453 WidgetEvent::KeyDown { key, modifiers, .. } => {
1454 if *key == Key::Tab {
1455 let captured_focus = self
1470 .focused
1471 .is_some_and(|focused| self.is_keyboard_capture(focused));
1472 if captured_focus && modifiers.ctrl() {
1473 self.cycle_focus(modifiers.shift(), &mut *ops);
1474 return;
1475 }
1476 if let Some(focused) = self.focused {
1483 self.note_key_press(focused);
1484 }
1485 let handled = self
1486 .focused
1487 .map(|focused| {
1488 self.dispatch_to_widget_returning_handled(focused, &event, &mut *ops)
1489 })
1490 .unwrap_or(false);
1491 if !handled {
1492 self.cycle_focus(modifiers.shift(), &mut *ops);
1493 }
1494 } else if let Some(focused) = self.focused {
1495 self.note_key_press(focused);
1496 self.dispatch_to_widget(focused, &event, &mut *ops);
1497 }
1498 }
1499 WidgetEvent::KeyUp { key, .. } => {
1500 self.dispatch_key_release(*key, &event, &mut *ops);
1501 }
1502 WidgetEvent::ImeComposition { .. } | WidgetEvent::ImeCommit { .. } => {
1503 if let Some(focused) = self.focused {
1504 self.dispatch_to_widget(focused, &event, &mut *ops);
1505 }
1506 }
1507 WidgetEvent::AccessAction {
1508 target,
1509 action,
1510 target_node,
1511 ..
1512 } => {
1513 if let Some(id) =
1531 target.filter(|id| self.arena.is_active(*id) && !self.is_behind_modal(*id))
1532 {
1533 if *action == accesskit::Action::Focus {
1534 let synthetic =
1573 *target_node != crate::accessibility::widget_id_to_node_id(id);
1574 let takes_focus_itself = !synthetic
1575 && (self
1576 .arena
1577 .get(id)
1578 .is_some_and(|node| self.is_node_focusable(node))
1579 || self.focusable_composite_behind(id).is_some());
1580 let offered = !takes_focus_itself
1586 && if synthetic {
1587 self.published_node_advertises_focus(*target_node)
1588 } else {
1589 self.advertises_focus_action(id)
1590 && self.first_focusable_descendant(id).is_none()
1591 };
1592 let focused_before = self.focused;
1593 let answered = if offered {
1594 self.offer_item_focus(id, synthetic, &event, &mut *ops)
1595 } else {
1596 None
1597 };
1598 if let Some(answerer) = answered {
1599 let landed = self.focused.is_some_and(|focused| {
1608 Some(focused) != focused_before
1609 || focused == answerer
1610 || self.is_descendant_of(focused, answerer)
1611 || answerer == id
1612 });
1613 if landed {
1614 self.focus_origin = Some(crate::focus::FocusOrigin::Accessibility);
1618 if let Some(visible) =
1619 crate::focus::FocusOrigin::Accessibility.focus_visible()
1620 && self.focus_visible.get() != visible
1621 {
1622 self.focus_visible.set(visible);
1623 }
1624 }
1625 self.access_action_handled = landed;
1626 } else if self.advertises_focus_action(id) {
1627 let target = self
1628 .focusable_composite_behind(id)
1629 .or_else(|| self.first_focusable_descendant(id))
1630 .unwrap_or(id);
1631 if self.arena.is_enabled(target)
1632 && self
1633 .arena
1634 .get(target)
1635 .is_some_and(|node| self.is_node_focusable(node))
1636 {
1637 self.focus_with_origin_ops(
1644 target,
1645 crate::focus::FocusOrigin::Accessibility,
1646 &mut *ops,
1647 );
1648 self.access_action_handled = self.focused == Some(target);
1652 } else {
1653 self.access_action_handled = false;
1658 }
1659 } else {
1660 self.access_action_handled = false;
1661 }
1662 } else if *action == accesskit::Action::ShowContextMenu {
1663 self.access_action_handled =
1679 if self.dispatch_to_widget_returning_handled(id, &event, &mut *ops) {
1680 true
1681 } else {
1682 let target = self.resolve_context_menu_target(id);
1686 let position = self.arena.bounds(target).center();
1687 self.show_context_menu_for(
1688 target,
1689 position,
1690 crate::widget_builder::ContextMenuTrigger::Accessibility,
1691 &mut *ops,
1692 )
1693 };
1694 } else {
1695 if *action == accesskit::Action::Click
1702 && !self.in_scroll_chrome(id)
1703 && match self.find_focusable_at_or_above(id) {
1704 Some(focusable) => !self.click_may_focus(focusable),
1705 None => !self.belongs_to_focused(id),
1706 }
1707 {
1708 self.commit_pending_edit(&mut *ops);
1709 }
1710 self.access_action_handled =
1711 self.dispatch_to_widget_returning_handled(id, &event, &mut *ops);
1712 }
1713 }
1714 }
1715 WidgetEvent::Gesture { .. } => {
1716 if let Some(target) = self.hovered_id().or(self.focused) {
1717 self.dispatch_to_widget(target, &event, &mut *ops);
1718 }
1719 }
1720 WidgetEvent::ScrollIntoView { .. }
1721 | WidgetEvent::PointerEnter { .. }
1722 | WidgetEvent::PointerLeave { .. }
1723 | WidgetEvent::FocusGained { .. }
1724 | WidgetEvent::FocusLost => {}
1725 }
1726 self.drain_pending_intents(&mut *ops);
1731 }
1732
1733 fn offer_item_focus(
1753 &mut self,
1754 id: WidgetId,
1755 synthetic: bool,
1756 event: &WidgetEvent,
1757 ops: &mut dyn crate::window::WindowOps,
1758 ) -> Option<WidgetId> {
1759 let start = if self.arena.is_enabled(id) {
1760 Some(id)
1761 } else {
1762 let greyed_item = !synthetic
1763 && self
1764 .arena
1765 .get(id)
1766 .and_then(|node| node.enabled_state.as_ref())
1767 .is_some_and(|state| !state.get())
1768 && !self.has_focusable_descendant(id);
1769 self.arena
1770 .parent(id)
1771 .filter(|&parent| greyed_item && self.arena.is_enabled(parent))
1772 };
1773 let mut at = start;
1774 while let Some(node) = at {
1775 if self.dispatch_to_widget_direct_returning_handled(node, event, &mut *ops) {
1776 return Some(node);
1777 }
1778 if self
1779 .arena
1780 .get(node)
1781 .is_some_and(|n| self.is_node_focusable(n))
1782 {
1783 return None;
1784 }
1785 at = self.arena.parent(node);
1786 }
1787 None
1788 }
1789
1790 fn has_focusable_descendant(&self, id: WidgetId) -> bool {
1793 let mut stack: Vec<WidgetId> = self.arena.children(id).to_vec();
1794 while let Some(node) = stack.pop() {
1795 if self
1796 .arena
1797 .get(node)
1798 .is_some_and(|n| self.is_node_focusable(n))
1799 {
1800 return true;
1801 }
1802 stack.extend_from_slice(self.arena.children(node));
1803 }
1804 false
1805 }
1806
1807 fn published_node_advertises_focus(&self, node_id: accesskit::NodeId) -> bool {
1811 self.cached_a11y.as_ref().is_some_and(|update| {
1812 update
1813 .nodes
1814 .iter()
1815 .any(|(id, node)| *id == node_id && node.supports_action(accesskit::Action::Focus))
1816 })
1817 }
1818
1819 fn open_context_menu_from_keyboard(&mut self, ops: &mut dyn crate::window::WindowOps) -> bool {
1832 let Some(focused) = self.focused else {
1833 return false;
1834 };
1835 let target = self.resolve_context_menu_target(focused);
1836
1837 let bounds = self.bounds(target);
1841 let anchor = Point {
1842 x: bounds.x + bounds.width / 2.0,
1843 y: bounds.y + bounds.height / 2.0,
1844 };
1845 self.show_context_menu_for(
1846 target,
1847 anchor,
1848 crate::widget_builder::ContextMenuTrigger::Keyboard,
1849 ops,
1850 )
1851 }
1852
1853 pub(super) fn resolve_context_menu_target(&self, start: WidgetId) -> WidgetId {
1863 const MAX_HOPS: usize = 8;
1864 let next_of = |id: WidgetId| {
1865 self.arena
1866 .get(id)
1867 .and_then(|node| node.widget.context_menu_key_target())
1868 .filter(|next| self.arena.is_active(*next))
1869 };
1870 let mut passed = [start; MAX_HOPS + 1];
1871 let mut target = start;
1872 for hop in 0..MAX_HOPS {
1873 let Some(next) = next_of(target) else {
1874 break;
1875 };
1876 if passed[..=hop].contains(&next) {
1877 debug_assert!(
1878 false,
1879 "context_menu_key_target cycle through {next:?}: a widget names an ancestor's target"
1880 );
1881 break;
1882 }
1883 passed[hop + 1] = next;
1884 target = next;
1885 }
1886 target
1887 }
1888
1889 pub(super) fn show_context_menu_for(
1907 &mut self,
1908 target: WidgetId,
1909 position: Point,
1910 trigger: crate::widget_builder::ContextMenuTrigger,
1911 ops: &mut dyn crate::window::WindowOps,
1912 ) -> bool {
1913 let mut ctx = self.make_event_context(&mut *ops);
1919 ctx.context_menu_trigger = Some(trigger);
1920 let mut walker = Some(target);
1921 let mut menu_decision: Option<(WidgetId, Box<dyn Widget>, bool)> = None;
1924 while let Some(id) = walker {
1925 let Some(node) = self.arena.get(id) else {
1926 break;
1927 };
1928 if let Some(factory) = node.context_menu_factory.as_ref()
1933 && let Some(menu) = factory(position, &mut ctx)
1934 {
1935 menu_decision = Some((id, menu, true));
1936 break;
1937 }
1938 if let Some(contribution) = node.context_menu_contribution.as_ref()
1941 && let Some(section) = contribution(&mut ctx)
1942 {
1943 menu_decision = Some((id, section, false));
1944 break;
1945 }
1946 walker = node.parent;
1947 }
1948
1949 if let Some((owner_id, menu, by_factory)) = menu_decision.as_mut() {
1955 let sealed = *by_factory && self.is_focusable_control(*owner_id);
1956 if !sealed {
1957 let mut probe = if *by_factory {
1960 Some(*owner_id)
1961 } else {
1962 self.arena.get(*owner_id).and_then(|node| node.parent)
1963 };
1964 while let Some(id) = probe {
1965 let Some(node) = self.arena.get(id) else {
1966 break;
1967 };
1968 if id != *owner_id && self.is_focusable_control(id) {
1969 break;
1970 }
1971 if let Some(contribution) = node.context_menu_contribution.as_ref()
1972 && let Some(section) = contribution(&mut ctx)
1973 && menu.append_context_menu_section(section).is_err()
1974 {
1975 note_refused_section(*owner_id);
1976 }
1977 probe = node.parent;
1978 }
1979 }
1980 }
1981 let menu_decision = menu_decision.map(|(owner, menu, _)| (owner, menu));
1982
1983 let drain_anchor = menu_decision.as_ref().map(|(id, _)| *id).unwrap_or(target);
1989 self.collect_from_ctx(ctx, drain_anchor);
1990
1991 let Some((owner_id, menu_widget)) = menu_decision else {
1992 return false;
1993 };
1994
1995 let keep: std::collections::HashSet<WidgetId> = self
2001 .overlay_manager
2002 .stack
2003 .iter()
2004 .map(|o| o.content_id)
2005 .filter(|&content_id| self.is_descendant_of(owner_id, content_id))
2006 .collect();
2007 let dismissed = self.overlay_manager.dismiss_except(&keep);
2008 self.dormant_dismissed_content(&dismissed, &mut *ops);
2009
2010 let content_id = self.add_boxed(menu_widget);
2011 let prev_focus = self.focused;
2012 let placement =
2019 crate::overlay::OverlayPlacement::at_pointer_for(position, &self.current_input.pointer);
2020 let mut request = crate::overlay::OverlayRequest::new(
2023 content_id,
2024 owner_id,
2025 placement,
2026 crate::overlay::DismissBehavior::EscapeOrClickOutside,
2027 );
2028 request.destroy_content_on_dismiss = true;
2029 self.overlay_manager.show(request);
2030 if let Some(focus_id) = prev_focus {
2031 self.record_top_focus_restore(focus_id);
2032 }
2033 if trigger != crate::widget_builder::ContextMenuTrigger::Pointer
2037 && !self.focus_visible.get()
2038 {
2039 self.focus_visible.set(true);
2040 }
2041 self.focus_ops(content_id, &mut *ops);
2042 self.drain_pending_intents(&mut *ops);
2047 true
2048 }
2049
2050 fn is_focusable_control(&self, id: WidgetId) -> bool {
2055 let focusable = |id: WidgetId| {
2056 self.arena
2057 .get(id)
2058 .is_some_and(|node| self.is_node_focusable(node))
2059 };
2060 if focusable(id) || self.focusable_composite_behind(id).is_some() {
2061 return true;
2062 }
2063 let mut current = id;
2064 for _ in 0..8 {
2065 let Some(proxy) = self.live_accessibility_proxy(current) else {
2066 return false;
2067 };
2068 if focusable(proxy) {
2069 return true;
2070 }
2071 current = proxy;
2072 }
2073 false
2074 }
2075
2076 fn arm_outside_press_dismissal(
2097 &mut self,
2098 position: Point,
2099 button: PointerButton,
2100 ops: &mut dyn crate::window::WindowOps,
2101 ) -> bool {
2102 self.prune_stale_dismiss_arms();
2103 let pressing = self.current_input.pointer;
2104 let busy = self.busy_press_points(pressing.id);
2105
2106 if pressing.kind.is_direct() {
2107 return self
2108 .overlay_manager
2109 .arm_dismiss(pressing.id, position, &busy)
2110 .suppress_beneath;
2111 }
2112
2113 let mark = self.dismissal_mark();
2114 let (dismissed, focus_restore, toggle_anchors) = self
2115 .overlay_manager
2116 .dismiss_outside_press_toggles(position, &busy);
2117 if dismissed.is_empty() {
2118 return false;
2119 }
2120 self.dormant_dismissed_content(&dismissed, &mut *ops);
2121 self.return_focus_after_dismissal(focus_restore, mark, &mut *ops);
2122 toggle_anchors
2135 .iter()
2136 .any(|&toggle| self.press_reopens(toggle, position, button, &pressing))
2137 }
2138
2139 fn press_reopens(
2151 &self,
2152 toggle: crate::overlay::ToggleAnchor,
2153 position: Point,
2154 button: PointerButton,
2155 pointer: &crate::pointer::PointerInfo,
2156 ) -> bool {
2157 let anchor = toggle.anchor;
2158 if !self.arena.is_active(anchor) || !self.arena.bounds(anchor).contains(position) {
2159 return false;
2160 }
2161 if toggle.modal {
2162 return self.first_tapper(position, button, pointer) == Some(anchor);
2163 }
2164 button == PointerButton::Primary
2165 || self
2166 .anchor_tap_buttons(anchor, position, pointer)
2167 .contains(button)
2168 }
2169
2170 fn first_tapper(
2173 &self,
2174 position: Point,
2175 button: PointerButton,
2176 pointer: &crate::pointer::PointerInfo,
2177 ) -> Option<WidgetId> {
2178 let mut node = self.hit_test_for(position, pointer);
2179 while let Some(id) = node {
2180 if self.tap_buttons(id).contains(button) {
2181 return Some(id);
2182 }
2183 node = self.arena.parent(id);
2184 }
2185 None
2186 }
2187
2188 fn anchor_tap_buttons(
2198 &self,
2199 anchor: WidgetId,
2200 position: Point,
2201 pointer: &crate::pointer::PointerInfo,
2202 ) -> ButtonMask {
2203 let mut mask = ButtonMask::NONE;
2204 let mut node = self.hit_test_for(position, pointer);
2205 while let Some(id) = node {
2206 mask = mask.union(self.tap_buttons(id));
2207 if id == anchor {
2208 return mask;
2209 }
2210 node = self.arena.parent(id);
2211 }
2212 ButtonMask::NONE
2213 }
2214
2215 fn commit_outside_press_dismissal(
2222 &mut self,
2223 position: Point,
2224 ops: &mut dyn crate::window::WindowOps,
2225 ) -> bool {
2226 let pointer = self.current_pointer_id();
2227 if !self.overlay_manager.has_armed_dismiss(pointer) {
2228 return false;
2229 }
2230 let mark = self.dismissal_mark();
2231 let (dismissed, focus_restore, _anchors) =
2232 self.overlay_manager.commit_dismiss(pointer, position);
2233 if !dismissed.is_empty() {
2234 self.dormant_dismissed_content(&dismissed, &mut *ops);
2235 self.return_focus_after_dismissal(focus_restore, mark, &mut *ops);
2236 }
2237 true
2238 }
2239
2240 fn busy_press_points(&self, exclude: crate::pointer::PointerId) -> Vec<Point> {
2257 self.pointers
2258 .iter()
2259 .filter(|entry| entry.info.id != exclude)
2260 .filter(|entry| self.press_is_revocable(entry.info.id))
2261 .map(|entry| entry.down_position)
2262 .collect()
2263 }
2264
2265 fn prune_stale_dismiss_arms(&mut self) {
2272 let stale: Vec<crate::pointer::PointerId> = self
2273 .overlay_manager
2274 .armed_pointers()
2275 .into_iter()
2276 .filter(|id| self.pointers.get(*id).is_none())
2277 .collect();
2278 for id in stale {
2279 self.overlay_manager.abort_dismiss(id);
2280 }
2281 }
2282
2283 fn begin_press(&mut self, focusable: Option<WidgetId>) {
2304 let pointer = self.current_pointer_id();
2305 let now = self.sequence_now();
2306 let delay = self
2307 .pan_session_open(pointer)
2308 .then(|| self.current_profile().press_feedback_delay)
2309 .filter(|d| !d.is_zero());
2310 self.presses.press(pointer, focusable, now, delay);
2311 }
2312
2313 fn adopt_press_owner(&mut self, button: PointerButton) {
2336 let pointer = self.current_pointer_id();
2337 let Some(owner) = self.current_sequence().and_then(|s| s.pressed_owner()) else {
2338 return;
2339 };
2340 if !self.press_buttons(owner).contains(button) {
2341 crate::trace_input!(
2342 Samples,
2343 "no press visual for {owner:?}: {button:?} is not one of its accepted buttons"
2344 );
2345 return;
2346 }
2347 self.presses.set_owner(pointer, owner);
2348 self.publish_pressed(owner);
2349 }
2350
2351 fn update_press(&mut self, position: Point) {
2364 let pointer = self.current_pointer_id();
2365 if self.presses.get(pointer).is_none() {
2366 return;
2367 }
2368 let claimed_elsewhere = self.current_sequence().is_some_and(|sequence| {
2371 sequence
2372 .winner()
2373 .is_some_and(|winner| Some(winner) != sequence.pressed_owner())
2374 });
2375 if claimed_elsewhere {
2376 self.end_press(pointer);
2377 return;
2378 }
2379 let profile = self.current_profile();
2380 let origin = self.current_sequence().map(|s| s.press_origin());
2381 let owner = self.presses.get(pointer).and_then(|p| p.owner);
2382 let inside = match (origin, owner) {
2383 (Some(origin), Some(owner)) => {
2384 let bounds = self
2385 .arena
2386 .is_active(owner)
2387 .then(|| self.arena.bounds(owner));
2388 !crate::gesture::TapBoundary::for_pointer(&self.current_input.pointer, &profile)
2389 .left(origin, position, bounds, &profile)
2390 }
2391 _ => true,
2394 };
2395 let Some(press) = self.presses.get_mut(pointer) else {
2396 return;
2397 };
2398 if press.inside == inside {
2399 return;
2400 }
2401 press.inside = inside;
2402 if let Some(owner) = owner {
2403 self.publish_pressed(owner);
2404 }
2405 }
2406
2407 pub(crate) fn end_press(&mut self, pointer: crate::pointer::PointerId) {
2413 if let Some(owner) = self.presses.release(pointer) {
2414 self.publish_pressed(owner);
2415 }
2416 }
2417
2418 pub(crate) fn resolve_press_delays(&mut self, now: crate::pointer::EventTime) {
2421 if self.presses.is_empty() {
2422 return;
2423 }
2424 for id in self.presses.resolve_delays(now) {
2425 self.publish_pressed(id);
2426 self.arena.mark_needs_paint(id);
2427 }
2428 }
2429
2430 pub(crate) fn next_press_deadline(&self) -> Option<std::time::Instant> {
2433 self.presses.next_deadline().map(|t| self.instant_for(t))
2434 }
2435
2436 pub(crate) fn commit_pending_edit(&mut self, ops: &mut dyn crate::window::WindowOps) {
2452 let Some(focus) = self.focused.filter(|id| self.arena.is_active(*id)) else {
2453 return;
2454 };
2455 let (chain, _, _) = self.intent_walk(focus, &[]);
2456 for id in chain {
2457 for external in [true, false] {
2458 let handler = self.arena.get_mut(id).and_then(|node| {
2459 let handlers = if external {
2460 &mut node.external_handlers
2461 } else {
2462 &mut node.handlers
2463 };
2464 handlers.on_commit_edit.take()
2465 });
2466 let Some(mut handler) = handler else { continue };
2467 let mut ctx = self
2468 .make_event_context(&mut *ops)
2469 .with_dispatch_node(id)
2470 .with_content_language(self.content_language(id));
2471 handler(&mut ctx);
2472 if let Some(node) = self.arena.get_mut(id) {
2473 let handlers = if external {
2474 &mut node.external_handlers
2475 } else {
2476 &mut node.handlers
2477 };
2478 if handlers.on_commit_edit.is_none() {
2480 handlers.on_commit_edit = Some(handler);
2481 }
2482 }
2483 self.collect_from_ctx(ctx, id);
2484 }
2485 }
2486 }
2487
2488 fn release_taps_unfocusable(&self, position: Point, button: PointerButton) -> bool {
2509 let Some(press) = self.presses.get(self.current_pointer_id()) else {
2510 return false;
2511 };
2512 let Some(owner) = press.owner.filter(|_| press.focusable.is_none()) else {
2513 return false;
2514 };
2515 if !self.arena.is_active(owner) || !self.tap_buttons(owner).contains(button) {
2516 return false;
2517 }
2518 let Some(sequence) = self.current_sequence() else {
2519 return false;
2520 };
2521 if let Some(winner) = sequence.winner()
2526 && (winner != owner
2527 || sequence.members().iter().any(|member| {
2528 member.id == winner
2529 && matches!(member.role, crate::gesture::MemberRole::Gesture)
2530 }))
2531 {
2532 return false;
2533 }
2534 let profile = self.current_profile();
2535 let left = crate::gesture::TapBoundary::for_pointer(&self.current_input.pointer, &profile)
2536 .left(
2537 sequence.press_origin(),
2538 position,
2539 Some(self.arena.bounds(owner)),
2540 &profile,
2541 );
2542 !left && !self.in_scroll_chrome(owner) && !self.belongs_to_focused(owner)
2543 }
2544
2545 fn in_scroll_chrome(&self, id: WidgetId) -> bool {
2550 let mut current = Some(id);
2551 while let Some(node) = current {
2552 if self.arena.get(node).is_some_and(|n| n.scroll_chrome) {
2553 return true;
2554 }
2555 current = self.arena.parent(node);
2556 }
2557 false
2558 }
2559
2560 fn belongs_to_focused(&self, id: WidgetId) -> bool {
2565 self.focused
2566 .is_some_and(|focus| self.intent_walk(id, &[]).0.contains(&focus))
2567 }
2568
2569 fn click_may_focus(&self, focusable: WidgetId) -> bool {
2577 self.arena
2578 .get(focusable)
2579 .is_none_or(|node| node.focus_on_click)
2580 }
2581
2582 fn focus_on_release(
2606 &mut self,
2607 position: Point,
2608 taps_unfocusable: bool,
2609 ops: &mut dyn crate::window::WindowOps,
2610 ) {
2611 if taps_unfocusable {
2612 self.commit_pending_edit(&mut *ops);
2613 return;
2614 }
2615 let releasing = self.current_input.pointer;
2616 let pointer = self.current_pointer_id();
2617 let Some(pressed) = self.presses.get(pointer).and_then(|p| p.focusable) else {
2618 return;
2619 };
2620 if !releasing.kind.is_direct() && self.click_may_focus(pressed) {
2621 return;
2622 }
2623 let Some(target) = self.hit_test_for(position, &releasing) else {
2624 return;
2625 };
2626 if self.find_focusable_at_or_above(target) != Some(pressed) {
2627 return;
2628 }
2629 if !self.click_may_focus(pressed) {
2630 if !self.in_scroll_chrome(target) {
2633 self.commit_pending_edit(&mut *ops);
2634 }
2635 } else {
2636 self.focus_with_origin_ops(
2637 pressed,
2638 crate::focus::FocusOrigin::Pointer(releasing.kind),
2639 &mut *ops,
2640 );
2641 }
2642 }
2643
2644 fn handle_pointer_move(
2664 &mut self,
2665 event: &WidgetEvent,
2666 position: Point,
2667 ops: &mut dyn crate::window::WindowOps,
2668 ) {
2669 let moving = self.current_input.pointer;
2674 if self.pointers.hover_owner_id() != Some(self.current_pointer_id()) {
2675 if let Some(target) = self.hit_test_for(position, &moving) {
2676 self.dispatch_to_widget(target, event, &mut *ops);
2677 }
2678 return;
2679 }
2680 let target = self.hit_test_for(position, &moving);
2681
2682 if target != self.hovered_id() {
2683 let hover = self.hover_transition_pointer();
2685 let previously_hovered = self.hovered_id();
2686 if let Some(old) = previously_hovered {
2687 self.dispatch_to_widget(
2688 old,
2689 &WidgetEvent::PointerLeave { pointer: hover },
2690 &mut *ops,
2691 );
2692 self.tooltip_pointer_leave(old, &mut *ops);
2693 }
2694 if let Some(new) = target {
2695 self.dispatch_to_widget(
2696 new,
2697 &WidgetEvent::PointerEnter { pointer: hover },
2698 &mut *ops,
2699 );
2700 self.tooltip_pointer_enter(new);
2701 }
2702 self.tooltip_dwell_held = false;
2705 self.set_hovered(target);
2706 self.update_hover_within_signals(previously_hovered, target);
2707 } else if let Some(target) = target {
2708 self.tooltip_pointer_moved(target, position);
2711 }
2712
2713 if let Some(target) = target {
2714 self.dispatch_to_widget(target, event, &mut *ops);
2715 }
2716 }
2717
2718 pub(super) fn dispatch_to_widget(
2719 &mut self,
2720 target: WidgetId,
2721 event: &WidgetEvent,
2722 ops: &mut dyn crate::window::WindowOps,
2723 ) {
2724 self.dispatch_to_widget_returning_handled(target, event, ops);
2725 }
2726
2727 pub(super) fn localize_event(
2743 frame: &crate::arena::LocalFrame,
2744 event: &WidgetEvent,
2745 ) -> Option<WidgetEvent> {
2746 match event {
2747 WidgetEvent::PointerDown {
2748 position,
2749 button,
2750 modifiers,
2751 pointer,
2752 } => Some(WidgetEvent::PointerDown {
2753 position: frame.to_local(*position),
2754 button: *button,
2755 modifiers: *modifiers,
2756 pointer: *pointer,
2757 }),
2758 WidgetEvent::PointerUp {
2759 position,
2760 button,
2761 modifiers,
2762 pointer,
2763 } => Some(WidgetEvent::PointerUp {
2764 position: frame.to_local(*position),
2765 button: *button,
2766 modifiers: *modifiers,
2767 pointer: *pointer,
2768 }),
2769 WidgetEvent::PointerMove {
2770 position,
2771 modifiers,
2772 pointer,
2773 } => Some(WidgetEvent::PointerMove {
2774 position: frame.to_local(*position),
2775 modifiers: *modifiers,
2776 pointer: *pointer,
2777 }),
2778 WidgetEvent::Gesture { gesture } => Some(WidgetEvent::Gesture {
2779 gesture: Self::localize_gesture(frame, gesture),
2780 }),
2781 _ => None,
2787 }
2788 }
2789
2790 fn localize_gesture(frame: &crate::arena::LocalFrame, gesture: &GestureEvent) -> GestureEvent {
2797 let loc = |p: teksilo_canvas::Point| frame.to_local(p);
2798 let tap = |t: &TapEvent| {
2799 TapEvent::new(loc(t.position), t.button, t.modifiers).with_pointer(t.pointer)
2800 };
2801 match gesture {
2802 GestureEvent::Tap(t) => GestureEvent::Tap(tap(t)),
2803 GestureEvent::DoubleTap(t) => GestureEvent::DoubleTap(tap(t)),
2804 GestureEvent::TripleTap(t) => GestureEvent::TripleTap(tap(t)),
2805 GestureEvent::LongPress(t) => GestureEvent::LongPress(tap(t)),
2806 GestureEvent::DragStarted {
2807 position,
2808 button,
2809 pointer,
2810 } => GestureEvent::DragStarted {
2811 position: loc(*position),
2812 button: *button,
2813 pointer: *pointer,
2814 },
2815 GestureEvent::DragMoved {
2816 position,
2817 delta,
2818 pointer,
2819 } => GestureEvent::DragMoved {
2820 position: loc(*position),
2821 delta: *delta,
2822 pointer: *pointer,
2823 },
2824 GestureEvent::DragEnded { position, pointer } => GestureEvent::DragEnded {
2825 position: loc(*position),
2826 pointer: *pointer,
2827 },
2828 GestureEvent::DragCancelled {
2829 position,
2830 pointer,
2831 reason,
2832 } => GestureEvent::DragCancelled {
2833 position: loc(*position),
2834 pointer: *pointer,
2835 reason: *reason,
2836 },
2837 GestureEvent::PinchStarted { center } => GestureEvent::PinchStarted {
2838 center: loc(*center),
2839 },
2840 GestureEvent::PinchChanged {
2841 center,
2842 scale,
2843 rotation,
2844 } => GestureEvent::PinchChanged {
2845 center: loc(*center),
2846 scale: *scale,
2847 rotation: *rotation,
2848 },
2849 GestureEvent::PinchEnded => GestureEvent::PinchEnded,
2850 GestureEvent::PinchCancelled { reason } => {
2851 GestureEvent::PinchCancelled { reason: *reason }
2852 }
2853 GestureEvent::Swipe {
2854 direction,
2855 velocity,
2856 } => GestureEvent::Swipe {
2857 direction: *direction,
2858 velocity: *velocity,
2859 },
2860 }
2861 }
2862
2863 pub(super) fn dispatch_to_widget_returning_handled(
2869 &mut self,
2870 target: WidgetId,
2871 event: &WidgetEvent,
2872 ops: &mut dyn crate::window::WindowOps,
2873 ) -> bool {
2874 if !self.arena.is_enabled(target) && !matches!(event, WidgetEvent::FocusLost) {
2880 return false;
2881 }
2882
2883 let mut ancestors = Vec::new();
2884 let mut current = self.arena.parent(target);
2885 while let Some(id) = current {
2886 ancestors.push(id);
2887 current = self.arena.parent(id);
2888 }
2889 ancestors.reverse();
2890
2891 let tap_owner: Option<WidgetId> = if matches!(
2909 event,
2910 WidgetEvent::PointerDown { .. } | WidgetEvent::PointerUp { .. }
2911 ) {
2912 let mut owner = None;
2913 let mut cur = Some(target);
2914 while let Some(id) = cur {
2915 if self.arena.get(id).is_some_and(|n| {
2916 n.any_handler(|h| h.on_tap.is_some() || h.on_long_press.is_some())
2917 }) {
2918 owner = Some(id);
2919 break;
2920 }
2921 cur = self.arena.parent(id);
2922 }
2923 owner
2924 } else {
2925 None
2926 };
2927
2928 for &id in &ancestors {
2929 let frame = self.arena.local_frame(id);
2930 let mut ctx = self
2931 .make_event_context(&mut *ops)
2932 .with_dispatch_node(id)
2933 .with_content_language(self.content_language(id))
2934 .with_dispatch_target(target)
2935 .with_local_frame(frame);
2936 ctx.press_claimed_by_interactive_child =
2937 tap_owner.is_some_and(|owner| owner != id && self.is_descendant_of(owner, id));
2938 let localized = Self::localize_event(&frame, event);
2941 let event = localized.as_ref().unwrap_or(event);
2942 let response = if let Some(node) = self.arena.get_mut(id) {
2943 Self::try_handler_preview(node, event, &mut ctx).unwrap_or(EventResponse::Ignored)
2944 } else {
2945 EventResponse::Ignored
2946 };
2947 self.collect_from_ctx(ctx, id);
2948 if response == EventResponse::Handled {
2949 self.arena.mark_needs_paint(id);
2950 if matches!(event, WidgetEvent::PointerDown { .. }) {
2958 self.note_preview_claim(id);
2959 }
2960 return true;
2961 }
2962 }
2963
2964 let needs_layout_on_handle = matches!(
2965 event,
2966 WidgetEvent::Scroll { .. } | WidgetEvent::ScrollIntoView { .. }
2967 );
2968 let mut current = Some(target);
2969 let mut is_target = true;
2970 while let Some(id) = current {
2971 let frame = self.arena.local_frame(id);
2972 let mut ctx = self
2973 .make_event_context(&mut *ops)
2974 .with_dispatch_node(id)
2975 .with_content_language(self.content_language(id))
2976 .with_dispatch_target(target)
2977 .with_local_frame(frame);
2978 ctx.press_claimed_by_interactive_child =
2979 tap_owner.is_some_and(|owner| owner != id && self.is_descendant_of(owner, id));
2980 let localized = Self::localize_event(&frame, event);
2983 let gesture_cx = self.recognizer_context(id);
2984 let arena_blocked = self.sequence_blocks_arena(id);
2987 let WidgetTree {
2988 arena,
2989 gesture_owners,
2990 ..
2991 } = self;
2992 let event = localized.as_ref().unwrap_or(event);
2993 let response = if let Some(node) = arena.get_mut(id) {
2994 Self::try_handler_bubble(
2995 node,
2996 event,
2997 &mut ctx,
2998 BubbleGates {
2999 fire_on_pointer_event: is_target,
3000 arena_blocked,
3001 },
3002 id,
3003 gesture_owners,
3004 gesture_cx,
3005 )
3006 .unwrap_or(EventResponse::Ignored)
3007 } else {
3008 EventResponse::Ignored
3009 };
3010 self.collect_from_ctx(ctx, id);
3011 if response == EventResponse::Handled {
3012 if needs_layout_on_handle {
3013 self.arena.mark_needs_layout(id);
3014 } else {
3015 self.arena.mark_needs_paint(id);
3016 }
3017 self.note_pointer_acceptance(id, event);
3018 if !matches!(
3033 event,
3034 WidgetEvent::PointerEnter { .. } | WidgetEvent::PointerLeave { .. }
3035 ) {
3036 return true;
3037 }
3038 }
3039 is_target = false;
3040 current = self.arena.parent(id);
3041 }
3042 false
3043 }
3044
3045 pub(super) fn dispatch_to_widget_direct(
3046 &mut self,
3047 target: WidgetId,
3048 event: &WidgetEvent,
3049 ops: &mut dyn crate::window::WindowOps,
3050 ) {
3051 self.dispatch_to_widget_direct_returning_handled(target, event, ops);
3052 }
3053
3054 pub(super) fn dispatch_to_widget_direct_returning_handled(
3064 &mut self,
3065 target: WidgetId,
3066 event: &WidgetEvent,
3067 ops: &mut dyn crate::window::WindowOps,
3068 ) -> bool {
3069 if !self.arena.is_enabled(target) && !matches!(event, WidgetEvent::FocusLost) {
3072 return false;
3073 }
3074
3075 let frame = self.arena.local_frame(target);
3076 let mut ctx = self
3077 .make_event_context(&mut *ops)
3078 .with_dispatch_node(target)
3079 .with_content_language(self.content_language(target))
3080 .with_dispatch_target(target)
3081 .with_local_frame(frame);
3082 let gesture_cx = self.recognizer_context(target);
3083 let arena_blocked = self.sequence_blocks_arena(target);
3084 let WidgetTree {
3085 arena,
3086 gesture_owners,
3087 ..
3088 } = self;
3089 let response = if let Some(node) = arena.get_mut(target) {
3090 Self::try_handler_bubble(
3091 node,
3092 event,
3093 &mut ctx,
3094 BubbleGates {
3095 fire_on_pointer_event: true,
3096 arena_blocked,
3097 },
3098 target,
3099 gesture_owners,
3100 gesture_cx,
3101 )
3102 .unwrap_or(EventResponse::Ignored)
3103 } else {
3104 EventResponse::Ignored
3105 };
3106 self.collect_from_ctx(ctx, target);
3107
3108 if response == EventResponse::Handled {
3109 if matches!(
3112 event,
3113 WidgetEvent::Scroll { .. } | WidgetEvent::ScrollIntoView { .. }
3114 ) {
3115 self.arena.mark_needs_layout(target);
3116 } else {
3117 self.arena.mark_needs_paint(target);
3118 }
3119 self.note_pointer_acceptance(target, event);
3120 }
3121 response == EventResponse::Handled
3122 }
3123
3124 pub(super) fn note_pointer_acceptance(&mut self, target: WidgetId, event: &WidgetEvent) {
3133 if !matches!(
3134 event,
3135 WidgetEvent::PointerDown { .. }
3136 | WidgetEvent::PointerMove { .. }
3137 | WidgetEvent::PointerUp { .. }
3138 ) {
3139 return;
3140 }
3141 let pointer = self.current_pointer_id();
3142 if let Some(entry) = self.pointers.get_mut(pointer) {
3143 entry.last_accepted = Some(target);
3144 }
3145 }
3146
3147 fn try_handler_preview(
3148 node: &mut crate::arena::WidgetNode,
3149 event: &WidgetEvent,
3150 ctx: &mut EventContext,
3151 ) -> Option<EventResponse> {
3152 match event {
3153 WidgetEvent::KeyDown { .. }
3161 | WidgetEvent::KeyUp { .. }
3162 | WidgetEvent::ImeComposition { .. }
3163 | WidgetEvent::ImeCommit { .. } => {
3164 let has = node.external_handlers.on_key_preview.is_some()
3165 || node.handlers.on_key_preview.is_some();
3166 if !has {
3167 return None;
3168 }
3169 Some(fire_event_handler_both(
3170 &mut node.external_handlers.on_key_preview,
3171 &mut node.handlers.on_key_preview,
3172 event,
3173 ctx,
3174 ))
3175 }
3176 WidgetEvent::PointerEnter { .. } | WidgetEvent::PointerLeave { .. } => None,
3188 _ => {
3189 let has = node.external_handlers.on_pointer_event.is_some()
3190 || node.handlers.on_pointer_event.is_some();
3191 if !has {
3192 return None;
3193 }
3194 Some(fire_event_handler_both(
3195 &mut node.external_handlers.on_pointer_event,
3196 &mut node.handlers.on_pointer_event,
3197 event,
3198 ctx,
3199 ))
3200 }
3201 }
3202 }
3203
3204 fn try_handler_bubble(
3205 node: &mut crate::arena::WidgetNode,
3206 event: &WidgetEvent,
3207 ctx: &mut EventContext,
3208 gates: BubbleGates,
3209 node_id: WidgetId,
3210 gesture_owners: &mut std::collections::HashSet<WidgetId>,
3211 gesture_cx: crate::gesture::RecognizerContext<'_>,
3212 ) -> Option<EventResponse> {
3213 let BubbleGates {
3214 fire_on_pointer_event,
3215 arena_blocked,
3216 } = gates;
3217 match event {
3218 WidgetEvent::PointerEnter { .. } => {
3219 if let Some(cursor) = node.node_cursor {
3220 ctx.declared_cursor_request = Some(cursor);
3225 }
3226 let mut fired = false;
3227 if let Some(h) = node.external_handlers.on_hover.as_mut() {
3228 h(true, ctx);
3229 fired = true;
3230 }
3231 if let Some(h) = node.handlers.on_hover.as_mut() {
3232 h(true, ctx);
3233 fired = true;
3234 }
3235 if fired {
3236 Some(EventResponse::Handled)
3237 } else {
3238 node.node_cursor.map(|_| EventResponse::Handled)
3239 }
3240 }
3241 WidgetEvent::PointerLeave { .. } => {
3242 if node.node_cursor.is_some() {
3243 ctx.declared_cursor_request = Some(crate::widget::CursorIcon::Default);
3244 }
3245 let mut fired = false;
3246 if let Some(h) = node.external_handlers.on_hover.as_mut() {
3247 h(false, ctx);
3248 fired = true;
3249 }
3250 if let Some(h) = node.handlers.on_hover.as_mut() {
3251 h(false, ctx);
3252 fired = true;
3253 }
3254 if fired {
3255 Some(EventResponse::Handled)
3256 } else {
3257 node.node_cursor.map(|_| EventResponse::Handled)
3258 }
3259 }
3260 WidgetEvent::FocusGained { origin } => {
3261 let previous_origin = ctx.focus_origin.replace(*origin);
3265 let mut fired = false;
3266 if let Some(h) = node.external_handlers.on_focus.as_mut() {
3267 h(true, ctx);
3268 fired = true;
3269 }
3270 if let Some(h) = node.handlers.on_focus.as_mut() {
3271 h(true, ctx);
3272 fired = true;
3273 }
3274 ctx.focus_origin = previous_origin;
3275 fired.then_some(EventResponse::Handled)
3276 }
3277 WidgetEvent::FocusLost => {
3278 let mut fired = false;
3279 if let Some(h) = node.external_handlers.on_focus.as_mut() {
3280 h(false, ctx);
3281 fired = true;
3282 }
3283 if let Some(h) = node.handlers.on_focus.as_mut() {
3284 h(false, ctx);
3285 fired = true;
3286 }
3287 fired.then_some(EventResponse::Handled)
3288 }
3289 WidgetEvent::KeyDown { .. }
3290 | WidgetEvent::KeyUp { .. }
3291 | WidgetEvent::ImeComposition { .. }
3292 | WidgetEvent::ImeCommit { .. } => {
3293 if node.external_handlers.on_key.is_some() || node.handlers.on_key.is_some() {
3294 Some(fire_event_handler_both(
3295 &mut node.external_handlers.on_key,
3296 &mut node.handlers.on_key,
3297 event,
3298 ctx,
3299 ))
3300 } else {
3301 None
3302 }
3303 }
3304 WidgetEvent::Scroll { .. } | WidgetEvent::ScrollIntoView { .. } => {
3305 if node.external_handlers.on_scroll.is_some() || node.handlers.on_scroll.is_some() {
3306 Some(fire_event_handler_both(
3307 &mut node.external_handlers.on_scroll,
3308 &mut node.handlers.on_scroll,
3309 event,
3310 ctx,
3311 ))
3312 } else {
3313 None
3314 }
3315 }
3316 WidgetEvent::AccessAction {
3317 action,
3318 target_node,
3319 data,
3320 ..
3321 } => {
3322 let saved_a11y_source = ctx
3342 .current_source
3343 .replace(crate::telemetry::IntentSource::Accessibility);
3344 let mut any_slot = false;
3345 let mut any_handled = false;
3346 if let Some(h) = node.external_handlers.on_access_action_request.as_mut() {
3347 any_slot = true;
3348 any_handled |=
3349 h(*action, *target_node, data.clone(), ctx) == EventResponse::Handled;
3350 }
3351 if let Some(h) = node.handlers.on_access_action_request.as_mut() {
3352 any_slot = true;
3353 any_handled |=
3354 h(*action, *target_node, data.clone(), ctx) == EventResponse::Handled;
3355 }
3356 if let Some(h) = node.external_handlers.on_access_action.as_mut() {
3357 any_slot = true;
3358 any_handled |= h(*action, ctx) == EventResponse::Handled;
3359 }
3360 if let Some(h) = node.handlers.on_access_action.as_mut() {
3361 any_slot = true;
3362 any_handled |= h(*action, ctx) == EventResponse::Handled;
3363 }
3364 let user_handled = any_slot.then_some(if any_handled {
3365 EventResponse::Handled
3366 } else {
3367 EventResponse::Ignored
3368 });
3369
3370 let mut override_handled = false;
3376 if let Some(ov) = node.access_overrides.as_deref_mut() {
3377 if matches!(action, accesskit::Action::CustomAction) {
3378 if let Some(accesskit::ActionData::CustomAction(idx)) = data
3379 && let Some((_, cb)) = ov.custom_actions.get_mut(*idx as usize)
3380 {
3381 cb(ctx);
3382 override_handled = true;
3383 }
3384 } else {
3385 for (a, cb) in ov.actions.iter_mut() {
3386 if *a == *action {
3387 cb(ctx);
3388 override_handled = true;
3389 }
3390 }
3391 }
3392 }
3393
3394 ctx.current_source = saved_a11y_source;
3395 match (user_handled, override_handled) {
3396 (Some(EventResponse::Handled), _) | (_, true) => Some(EventResponse::Handled),
3397 (Some(EventResponse::Ignored), false) => Some(EventResponse::Ignored),
3398 (None, false) => None,
3399 }
3400 }
3401 WidgetEvent::Gesture { gesture } => {
3402 let matched = matches!(
3406 gesture,
3407 GestureEvent::PinchStarted { .. }
3408 | GestureEvent::PinchChanged { .. }
3409 | GestureEvent::PinchEnded
3410 | GestureEvent::Swipe { .. }
3411 | GestureEvent::DoubleTap { .. }
3412 | GestureEvent::TripleTap { .. }
3413 ) && {
3414 let has_handler = match gesture {
3415 GestureEvent::PinchStarted { .. }
3416 | GestureEvent::PinchChanged { .. }
3417 | GestureEvent::PinchEnded => node.any_handler(|h| h.on_pinch.is_some()),
3418 GestureEvent::Swipe { .. } => node.any_handler(|h| h.on_swipe.is_some()),
3419 GestureEvent::DoubleTap { .. } => {
3420 node.any_handler(|h| h.on_double_tap.is_some())
3421 }
3422 GestureEvent::TripleTap { .. } => {
3423 node.any_handler(|h| h.on_triple_tap.is_some())
3424 }
3425 _ => false,
3426 };
3427 if has_handler {
3428 Self::dispatch_recognized_gesture(node, *gesture, ctx);
3429 }
3430 has_handler
3431 };
3432 if matched {
3433 Some(EventResponse::Handled)
3434 } else {
3435 None
3436 }
3437 }
3438 WidgetEvent::PointerDown {
3439 position,
3440 button,
3441 modifiers,
3442 ..
3443 } => {
3444 if fire_on_pointer_event {
3451 let r = fire_event_handler_both(
3452 &mut node.external_handlers.on_pointer_event,
3453 &mut node.handlers.on_pointer_event,
3454 event,
3455 ctx,
3456 );
3457 if r == EventResponse::Handled {
3458 return Some(EventResponse::Handled);
3459 }
3460 }
3461 if arena_blocked {
3462 return None;
3466 }
3467 Self::ensure_gesture_arena(node, node_id, gesture_owners);
3468 if let Some(arena) = node.handlers.gesture_arena.as_mut() {
3469 let cx = gesture_cx;
3470 ctx.capture_pointer_implicit();
3485 let result = arena.process(
3486 &RawPointerEvent::Down {
3487 position: *position,
3488 button: *button,
3489 modifiers: *modifiers,
3490 pointer: cx.pointer,
3491 time: cx.now,
3492 },
3493 &cx,
3494 );
3495 if let Some(gesture) = result {
3496 Self::dispatch_recognized_gesture(node, gesture, ctx);
3497 }
3498 return Some(EventResponse::Handled);
3499 }
3500 None
3501 }
3502 WidgetEvent::PointerUp {
3503 position,
3504 button,
3505 modifiers,
3506 ..
3507 } => {
3508 if fire_on_pointer_event {
3509 let r = fire_event_handler_both(
3510 &mut node.external_handlers.on_pointer_event,
3511 &mut node.handlers.on_pointer_event,
3512 event,
3513 ctx,
3514 );
3515 if r == EventResponse::Handled {
3516 return Some(EventResponse::Handled);
3517 }
3518 }
3519 if arena_blocked {
3520 return None;
3521 }
3522 if let Some(arena) = node.handlers.gesture_arena.as_mut() {
3523 let cx = gesture_cx;
3524 let result = arena.process(
3525 &RawPointerEvent::Up {
3526 position: *position,
3527 button: *button,
3528 modifiers: *modifiers,
3529 pointer: cx.pointer,
3530 time: cx.now,
3531 },
3532 &cx,
3533 );
3534 if let Some(gesture) = result {
3535 Self::dispatch_recognized_gesture(node, gesture, ctx);
3536 }
3537 return Some(EventResponse::Handled);
3538 }
3539 None
3540 }
3541 WidgetEvent::PointerMove { position, .. } => {
3542 if fire_on_pointer_event {
3543 let r = fire_event_handler_both(
3544 &mut node.external_handlers.on_pointer_event,
3545 &mut node.handlers.on_pointer_event,
3546 event,
3547 ctx,
3548 );
3549 if r == EventResponse::Handled {
3550 return Some(EventResponse::Handled);
3551 }
3552 }
3553 if arena_blocked {
3554 return None;
3555 }
3556 if let Some(arena) = node.handlers.gesture_arena.as_mut() {
3557 let cx = gesture_cx;
3558 let result = arena.process(
3559 &RawPointerEvent::Move {
3560 position: *position,
3561 pointer: cx.pointer,
3562 time: cx.now,
3563 },
3564 &cx,
3565 );
3566 if let Some(gesture) = result {
3567 Self::dispatch_recognized_gesture(node, gesture, ctx);
3568 return Some(EventResponse::Handled);
3580 }
3581 return Some(EventResponse::Ignored);
3582 }
3583 None
3584 }
3585 WidgetEvent::PointerCancel {
3586 reason, pointer, ..
3587 } => {
3588 for slot in [
3596 &mut node.external_handlers.on_pointer_cancel,
3597 &mut node.handlers.on_pointer_cancel,
3598 ] {
3599 if let Some(handler) = slot.as_mut() {
3600 handler(pointer, *reason, ctx);
3601 }
3602 }
3603 if fire_on_pointer_event {
3604 let r = fire_event_handler_both(
3605 &mut node.external_handlers.on_pointer_event,
3606 &mut node.handlers.on_pointer_event,
3607 event,
3608 ctx,
3609 );
3610 if r == EventResponse::Handled {
3611 return Some(EventResponse::Handled);
3612 }
3613 }
3614 None
3615 }
3616 }
3617 }
3618
3619 pub(super) fn collect_from_ctx<'ops>(
3620 &mut self,
3621 mut ctx: EventContext<'ops>,
3622 source_widget: WidgetId,
3623 ) {
3624 let local_ops = ctx.window_ops.take();
3630 let mut noop = crate::window::NoopWindowOps;
3631 let ops: &mut dyn crate::window::WindowOps = match local_ops {
3632 Some(o) => o,
3633 None => &mut noop,
3634 };
3635 if ctx.frame_requested {
3636 self.request_frame();
3637 }
3638 if let Some(declared) = ctx.declared_cursor_request {
3642 self.node_declared_cursor = declared;
3643 self.current_cursor = declared;
3644 }
3645 match ctx.cursor_request {
3646 Some(crate::widget::CursorRequest::Set(cursor)) => {
3647 self.current_cursor = cursor;
3648 }
3649 Some(crate::widget::CursorRequest::Release) => {
3653 self.current_cursor = self.node_declared_cursor;
3654 }
3655 None => {}
3656 }
3657 for intent in ctx.pending_intents {
3663 self.enqueue_intent(source_widget, intent, true);
3664 }
3665 if ctx.cancel_key_capture {
3674 self.cancel_key_capture();
3675 }
3676 if let Some(slot) = ctx.pending_key_capture {
3677 self.key_capture = Some(slot);
3678 }
3679 for mutation in ctx.pending_shortcut_mutations {
3681 match mutation {
3682 crate::widget::ShortcutMutation::RebindPrimary { id, keystroke } => {
3683 self.shortcut_registry.rebind_primary(id, keystroke);
3684 }
3685 crate::widget::ShortcutMutation::RebindSecondary { id, keystroke } => {
3686 self.shortcut_registry.rebind_secondary(id, keystroke);
3687 }
3688 crate::widget::ShortcutMutation::ClearOverride { id } => {
3689 self.shortcut_registry.clear_override(&id);
3690 }
3691 }
3692 }
3693 if ctx.close_request_to_modal {
3694 self.answer_close_request_with_modal(&mut *ops);
3695 }
3696 if ctx.close_window_requested {
3697 self.close_window_requested = true;
3698 }
3699 if ctx.force_close_requested {
3700 self.force_close_requested = true;
3701 }
3702 self.pending_modal_requests
3703 .extend(ctx.modal_requests.into_iter().map(|request| {
3704 crate::modal::QueuedModalRequest {
3705 source_widget,
3706 request,
3707 }
3708 }));
3709 let focus_intents = std::mem::take(&mut ctx.pending_focus_intents);
3719 let (fallback_crossings, fallback_modal) = if focus_intents.is_empty() {
3720 (Vec::new(), None)
3721 } else {
3722 let modal = self.intent_walk(source_widget, &[]).2;
3723 (self.intent_route(source_widget, &[], true).crossings, modal)
3724 };
3725 if ctx.dismiss_modal && !self.dismiss_modal_for_source(source_widget, &mut *ops) {
3726 self.pending_modal_dismissal = true;
3727 }
3728 for callback in ctx.idle_callbacks {
3729 self.idle_queue.push_boxed(callback);
3730 }
3731 match ctx.dismiss_scope {
3732 Some(crate::widget::DismissScope::All) => {
3733 let mark = self.dismissal_mark();
3734 let dismissed = self.overlay_manager.dismiss_all();
3735 self.dormant_dismissed_content(&dismissed, &mut *ops);
3736 self.return_focus_after_dismissal(None, mark, &mut *ops);
3737 }
3738 Some(crate::widget::DismissScope::AllExceptHosts) => {
3739 self.dismiss_all_overlays_except_hosts(&mut *ops);
3740 }
3741 Some(crate::widget::DismissScope::SelfChain) => {
3742 self.dismiss_self_overlay_chain_for_source(source_widget, &mut *ops);
3743 }
3744 Some(crate::widget::DismissScope::Top) => {
3745 let mark = self.dismissal_mark();
3746 if let Some((_id, content_ids, focus_restore)) = self.overlay_manager.dismiss_top()
3747 {
3748 self.dormant_dismissed_content(&content_ids, &mut *ops);
3749 self.return_focus_after_dismissal(focus_restore, mark, &mut *ops);
3750 }
3751 }
3752 None => {
3753 for id in ctx.overlay_dismissals {
3754 let mark = self.dismissal_mark();
3755 let dismissed = self.overlay_manager.dismiss(id);
3756 self.dormant_dismissed_content(&dismissed, &mut *ops);
3757 self.return_focus_after_dismissal(None, mark, &mut *ops);
3758 }
3759 }
3760 }
3761 for content_id in ctx.overlay_content_dismissals {
3768 if let Some(overlay_id) = self.overlay_manager.find_by_content(content_id) {
3769 let mark = self.dismissal_mark();
3770 let dismissed = self.overlay_manager.dismiss(overlay_id);
3771 self.dormant_dismissed_content(&dismissed, &mut *ops);
3772 self.return_focus_after_dismissal(None, mark, &mut *ops);
3773 }
3774 }
3775 for (id, pause) in ctx.overlay_pause_requests {
3782 if pause {
3783 self.overlay_manager.pause_auto_dismiss(id);
3784 } else {
3785 self.overlay_manager.resume_auto_dismiss(id);
3786 }
3787 }
3788 for preserve_content in ctx.dismiss_descendant_overlays {
3789 self.dismiss_child_overlays_for_source(source_widget, preserve_content, &mut *ops);
3790 }
3791 if !focus_intents.is_empty() {
3800 let modal_closed = fallback_modal
3801 .is_some_and(|content| self.overlay_manager.find_by_content(content).is_none());
3802 let start = match self.focused.filter(|id| self.arena.is_active(*id)) {
3803 Some(focus) => Some((focus, None)),
3804 None if modal_closed => self.intent_anchor().map(|root| (root, None)),
3805 None if fallback_modal.is_none()
3809 && self.overlay_manager.topmost_modal().is_some() =>
3810 {
3811 self.focus_or_modal().map(|modal| (modal, None))
3812 }
3813 None => Some((source_widget, Some(fallback_crossings))),
3814 };
3815 if let Some((start, crossings)) = start {
3816 for intent in focus_intents {
3817 match &crossings {
3818 None => self.enqueue_intent(start, intent, true),
3819 Some(crossings) => {
3820 self.enqueue_intent_crossing(start, intent, true, crossings.clone())
3821 }
3822 }
3823 }
3824 }
3825 }
3826 let deferred_row_activations =
3827 self.apply_tree_mutations(std::mem::take(&mut ctx.tree_mutations));
3828 if ctx.request_a11y_update {
3829 self.a11y_dirty = true;
3830 }
3831 if let Some(visible) = ctx.soft_keyboard_request.take() {
3832 self.request_soft_keyboard(visible);
3833 }
3834 for (message, politeness) in std::mem::take(&mut ctx.announcements) {
3837 self.announce_with(message, politeness);
3838 }
3839 for mut req in ctx.overlay_requests {
3840 if req.parent_overlay.is_none() {
3841 req.parent_overlay = self.overlay_ancestor_for_widget(source_widget);
3842 }
3843 if self
3844 .overlay_manager
3845 .find_by_content(req.content_id)
3846 .is_some()
3847 {
3848 continue;
3849 }
3850 let current_focus = self.focused;
3851 self.overlay_manager.show(req);
3852 self.a11y_dirty = true;
3856 if let Some(focus_id) = current_focus {
3857 self.record_top_focus_restore(focus_id);
3858 }
3859 }
3860 for (mut req, band) in ctx.overlay_band_requests {
3861 if req.parent_overlay.is_none() {
3862 req.parent_overlay = self.overlay_ancestor_for_widget(source_widget);
3863 }
3864 if self
3865 .overlay_manager
3866 .find_by_content(req.content_id)
3867 .is_some()
3868 {
3869 continue;
3870 }
3871 let content_id = req.content_id;
3872 self.overlay_manager.show_in_band(req, band);
3873 self.arena.activate(content_id);
3874 self.a11y_dirty = true;
3875 }
3879 for (content_id, placement) in ctx.overlay_placement_updates {
3882 if let Some(overlay_id) = self.overlay_manager.find_by_content(content_id) {
3883 self.overlay_manager.update_placement(overlay_id, placement);
3884 }
3885 }
3886 for (content_id, source) in ctx.overlay_placement_sources {
3887 if let Some(overlay_id) = self.overlay_manager.find_by_content(content_id) {
3888 self.overlay_manager
3889 .set_placement_source(overlay_id, source);
3890 }
3891 }
3892 for (mut req, duration) in ctx.timed_overlay_requests {
3893 if req.parent_overlay.is_none() {
3894 req.parent_overlay = self.overlay_ancestor_for_widget(source_widget);
3895 }
3896 if self
3897 .overlay_manager
3898 .find_by_content(req.content_id)
3899 .is_some()
3900 {
3901 continue;
3902 }
3903 let current_focus = self.focused;
3904 let overlay_id = self.overlay_manager.show_for(req, duration);
3905 self.overlay_manager
3906 .set_shown_at_sim(overlay_id, self.sim_clock);
3907 self.a11y_dirty = true;
3908 if let Some(focus_id) = current_focus {
3909 self.record_top_focus_restore(focus_id);
3910 }
3911 }
3912 for (mut req, progress, duration) in ctx.reveal_overlay_requests {
3913 if req.parent_overlay.is_none() {
3914 req.parent_overlay = self.overlay_ancestor_for_widget(source_widget);
3915 }
3916 if self
3917 .overlay_manager
3918 .find_by_content(req.content_id)
3919 .is_some()
3920 {
3921 continue;
3922 }
3923 let content_id = req.content_id;
3924 let current_focus = self.focused;
3925 let overlay_id = self.overlay_manager.show(req);
3926 self.overlay_manager
3927 .set_shown_at_sim(overlay_id, self.sim_clock);
3928 self.a11y_dirty = true;
3929 if let Some(focus_id) = current_focus {
3930 self.record_top_focus_restore(focus_id);
3931 }
3932 self.register_animated_signal(&progress, content_id);
3938 let _ = progress.try_animate_with_options(crate::animation::AnimationRequest {
3939 target: 1.0,
3940 duration,
3941 easing: teksilo_tokens::Easing::EaseOut,
3942 frame_interval: None,
3943 looping: false,
3944 epsilon: 0.0,
3945 max_duration: None,
3946 });
3947 self.overlay_manager
3948 .attach_fade(overlay_id, progress, duration);
3949 }
3950 if let Some((pointer, capture)) = ctx.pointer_capture {
3951 let named = pointer;
3955 let pointer = pointer.unwrap_or_else(|| self.current_pointer_id());
3956 self.set_pointer_capture(pointer, capture.then_some(source_widget));
3957 if capture && ctx.explicit_capture && named.is_none() {
3961 self.note_explicit_capture(source_widget);
3962 }
3963 }
3964 if let Some(activation) = ctx.drag_activation_override.take() {
3965 self.note_drag_activation_override(source_widget, activation);
3969 }
3970 if ctx.recognized_owning_gesture {
3971 self.note_gesture_recognized(source_widget);
3974 }
3975 if !ctx.gesture_acts.is_empty() {
3976 let acts = std::mem::take(&mut ctx.gesture_acts);
3977 self.apply_gesture_acts(&acts, source_widget);
3978 }
3979 if let Some(reason) = ctx.cancel_pointer_request {
3980 let pointer = self.current_pointer_id();
3981 self.cancel_pointer(pointer, reason, &mut *ops);
3982 }
3983 for (mut request, delay, focus_target, replace_siblings) in ctx.delayed_overlay_requests {
3984 if request.parent_overlay.is_none() {
3985 request.parent_overlay = self.overlay_ancestor_for_widget(source_widget);
3986 }
3987 if self
3988 .overlay_manager
3989 .find_by_content(request.content_id)
3990 .is_some()
3991 {
3992 continue;
3993 }
3994 let content_id = request.content_id;
3995 self.pending_delayed_overlays
3996 .retain(|pending| pending.request.content_id != content_id);
3997 self.pending_delayed_overlays.push(PendingDelayedOverlay {
3998 request,
3999 delay,
4000 focus_target,
4001 replace_siblings,
4002 real_requested_at: std::time::Instant::now(),
4003 sim_requested_at: self.sim_clock,
4004 });
4005 self.arena.mark_needs_paint(source_widget);
4006 }
4007 for content_id in ctx.cancel_delayed_overlays {
4008 self.pending_delayed_overlays
4009 .retain(|pending| pending.request.content_id != content_id);
4010 }
4011 for content_id in ctx.safe_region_arm_requests {
4018 if let Some(apex) = self
4019 .previous_pointer_position
4020 .or_else(|| self.hover_owner_position())
4021 {
4022 self.overlay_manager.arm_safe_region(
4023 content_id,
4024 apex,
4025 std::time::Instant::now(),
4026 self.sim_clock,
4027 );
4028 }
4029 }
4030 for id in ctx.repaint_requests {
4031 self.arena.mark_needs_paint(id);
4032 }
4033 for id in ctx.synthetic_clicks {
4034 self.synthesise_tap_with_ops(id, &mut *ops);
4039 }
4040 if ctx.clear_focus_requested {
4043 self.clear_focus_ops(&mut *ops);
4044 }
4045 if let Some(&id) = ctx.focus_requests.last() {
4050 self.request_focus_with_ops(id, super::FocusRequestMode::SelfOrDescendant, &mut *ops);
4060 }
4061 if let Some(&id) = ctx.focus_into_requests.last() {
4062 self.request_focus_with_ops(id, super::FocusRequestMode::Into, &mut *ops);
4069 }
4070
4071 for req in ctx.scroll_into_view_requests {
4080 self.scroll_rect_into_view(
4081 req.from.unwrap_or(source_widget),
4084 req.rect,
4085 req.margin,
4086 req.align,
4087 req.motion,
4088 &mut *ops,
4089 );
4090 }
4091 for (id, margin) in ctx.scroll_widget_into_view_requests {
4098 if self.arena.get(id).is_some() {
4099 let bounds = self.arena.bounds(id);
4100 self.scroll_rect_into_view(
4101 id,
4102 bounds,
4103 margin,
4104 crate::event::ScrollAlign::Minimal,
4105 crate::event::ScrollMotion::Instant,
4106 &mut *ops,
4107 );
4108 }
4109 }
4110
4111 if let Some(&id) = ctx.highlight_tooltip_requests.last() {
4116 self.show_highlight_tooltip(id, &mut *ops);
4117 }
4118
4119 if let Some((source_widget, payload, preview_widget)) = ctx.drag_start_request {
4121 let (preview_content_id, preview_overlay_id) = if let Some(preview) = preview_widget {
4122 let content_id = self.add_boxed(preview);
4129 let overlay_id = self
4130 .overlay_manager
4131 .show(crate::overlay::OverlayRequest::new(
4132 content_id,
4133 source_widget,
4134 crate::overlay::OverlayPlacement::AtPointer(teksilo_canvas::Point::ZERO),
4135 crate::overlay::DismissBehavior::Manual,
4136 ));
4137 self.arena.mark_needs_layout(content_id);
4141 (Some(content_id), Some(overlay_id))
4142 } else {
4143 (None, None)
4144 };
4145 self.active_drag = Some(crate::drag_state::DragSession {
4146 payload,
4147 pointer: self.current_input.pointer,
4153 source_widget: Some(source_widget),
4154 is_external: false,
4155 current_position: teksilo_canvas::Point::ZERO,
4156 current_target: None,
4157 feedback: crate::drag_state::DropFeedback::NoFeedback,
4158 preview_content_id,
4159 preview_overlay_id,
4160 });
4161 self.set_current_pointer_capture(Some(source_widget));
4162 self.current_cursor = crate::widget::CursorIcon::Grabbing;
4165 }
4166 if ctx.cancel_drag {
4167 self.cancel_active_drag(&mut *ops);
4168 }
4169
4170 if let Some(theme) = ctx.theme_request {
4172 self.pending_theme_request = Some(theme);
4178 }
4179 if ctx.follow_system_request {
4180 self.pending_follow_system_request = true;
4184 }
4185 if let Some(locale) = ctx.locale_request {
4186 self.pending_locale_request = Some(locale);
4192 }
4193 if let Some(scale) = ctx.text_scale_request {
4194 self.pending_text_scale_request = Some(scale);
4199 }
4200 if !deferred_row_activations.is_empty() {
4207 self.run_with_event_context(&mut *ops, move |ctx| {
4208 for action in deferred_row_activations {
4209 action(ctx);
4210 }
4211 });
4212 }
4213 }
4214
4215 #[must_use]
4221 fn apply_tree_mutations(
4222 &mut self,
4223 mutations: Vec<crate::widget::TreeMutation>,
4224 ) -> Vec<std::rc::Rc<dyn Fn(&mut crate::widget::EventContext)>> {
4225 let mut deferred_row_activations = Vec::new();
4226 use crate::binding::BindingLevel;
4227 use crate::widget::TreeMutation;
4228
4229 for mutation in mutations {
4230 match mutation {
4231 TreeMutation::SetDormant(id) => {
4232 self.park_subtree(id);
4233 }
4234 TreeMutation::Activate(id) => self.arena.activate(id),
4235 TreeMutation::Destroy(id) => {
4236 if let Some(overlay_id) = self.overlay_manager().find_by_content(id) {
4249 self.dismiss_overlay(overlay_id);
4250 }
4251 self.destroy_subtree(id);
4252 }
4253 TreeMutation::MaterializeNow(id) => {
4257 if self.arena.get(id).is_some() {
4258 self.rebuild_single_widget(id);
4259 }
4260 }
4261 TreeMutation::RowSpaceActivate { row, fallback } => {
4262 deferred_row_activations.push(self.keyboard_toggle_in(row).unwrap_or(fallback));
4272 }
4273 TreeMutation::WithWidgetMut { id, dirty, apply } => {
4274 let existed = if let Some(any) =
4279 self.arena.get_mut(id).and_then(|n| n.widget.as_any_mut())
4280 {
4281 apply(any);
4282 true
4283 } else {
4284 false
4285 };
4286 if existed {
4287 match dirty {
4288 BindingLevel::RepaintOnly => self.arena.mark_needs_paint(id),
4289 BindingLevel::SubtreeRepaint => self.arena.mark_subtree_needs_paint(id),
4290 BindingLevel::Relayout => {
4291 self.arena.mark_needs_layout(id);
4292 self.arena.mark_ancestors_need_layout(id);
4293 }
4294 BindingLevel::Rebuild => {
4295 self.arena.mark_needs_rebuild(id);
4296 self.arena.mark_ancestors_need_layout(id);
4297 }
4298 BindingLevel::AccessibilityOnly => self.a11y_dirty = true,
4299 }
4300 }
4301 }
4302 }
4303 }
4304 deferred_row_activations
4305 }
4306
4307 pub fn hit_test(&self, point: Point) -> Option<WidgetId> {
4316 self.hit_test_excluding_overlay_and_widget(point, None, None)
4317 }
4318
4319 pub fn hit_test_for(
4330 &self,
4331 point: Point,
4332 pointer: &crate::pointer::PointerInfo,
4333 ) -> Option<WidgetId> {
4334 self.hit_test_for_excluding(point, pointer, None, None)
4335 }
4336
4337 pub fn hit_test_for_excluding(
4340 &self,
4341 point: Point,
4342 pointer: &crate::pointer::PointerInfo,
4343 exclude_overlay: Option<crate::overlay::OverlayId>,
4344 exclude_widget: Option<WidgetId>,
4345 ) -> Option<WidgetId> {
4346 let surfaces = self.text_surfaces();
4347 let read_only = |id: WidgetId| surfaces.is_read_only(id);
4348 let hit =
4349 crate::pointer::hit_slop::HitContext::new(pointer.kind, &self.effective_theme.input)
4350 .direction(self.layout_direction)
4351 .read_only_probe(&read_only);
4352 self.hit_test_with(point, exclude_overlay, exclude_widget, &hit)
4353 }
4354
4355 pub fn hit_test_excluding_overlay_and_widget(
4362 &self,
4363 point: Point,
4364 exclude_overlay: Option<crate::overlay::OverlayId>,
4365 exclude_widget: Option<WidgetId>,
4366 ) -> Option<WidgetId> {
4367 self.hit_test_with(
4368 point,
4369 exclude_overlay,
4370 exclude_widget,
4371 &crate::pointer::hit_slop::HitContext::mouse(),
4372 )
4373 }
4374
4375 pub(crate) fn hit_test_with(
4378 &self,
4379 point: Point,
4380 exclude_overlay: Option<crate::overlay::OverlayId>,
4381 exclude_widget: Option<WidgetId>,
4382 hit: &crate::pointer::hit_slop::HitContext<'_>,
4383 ) -> Option<WidgetId> {
4384 if let Some(overlay_id) = self.overlay_manager.hit_test(point) {
4385 if Some(overlay_id) == exclude_overlay {
4386 } else if let Some(overlay) = self.overlay_manager.overlay(overlay_id) {
4388 if self.overlay_manager.is_modal_scrim(overlay)
4390 && let Some(chrome) = self.window_chrome_under_modal(point, exclude_widget, hit)
4391 {
4392 return Some(chrome);
4393 }
4394 let content_id = overlay.content_id;
4398 if let Some(found) =
4399 self.arena
4400 .hit_test_in_subtree_with_slop(content_id, point, exclude_widget, hit)
4401 {
4402 return Some(found);
4403 }
4404 if !self
4422 .arena
4423 .get(content_id)
4424 .is_some_and(|node| node.event_pass_through)
4425 {
4426 return None;
4427 }
4428 }
4429 }
4430
4431 if self.overlay_manager.topmost_modal().is_some() {
4432 return self.window_chrome_under_modal(point, exclude_widget, hit);
4433 }
4434
4435 let mut roots = self.arena.roots();
4441 let inert: Vec<WidgetId> = self
4442 .overlay_manager
4443 .stack
4444 .iter()
4445 .filter(|overlay| overlay.inert)
4446 .map(|overlay| overlay.content_id)
4447 .collect();
4448 if !inert.is_empty() {
4449 roots.retain(|root| !inert.contains(root));
4450 }
4451 self.arena
4452 .hit_test_roots_with_slop(roots, point, exclude_widget, hit)
4453 }
4454}
4455
4456impl WidgetTree {
4457 fn window_chrome_under_modal(
4472 &self,
4473 point: Point,
4474 exclude_widget: Option<WidgetId>,
4475 hit: &crate::pointer::hit_slop::HitContext<'_>,
4476 ) -> Option<WidgetId> {
4477 let overlays: Vec<WidgetId> = self
4478 .overlay_manager
4479 .stack
4480 .iter()
4481 .map(|overlay| overlay.content_id)
4482 .collect();
4483 let mut roots = self.arena.roots();
4484 roots.retain(|root| !overlays.contains(root));
4485 let found = self
4486 .arena
4487 .hit_test_roots_with_slop(roots, point, exclude_widget, hit)?;
4488 let mut node = Some(found);
4489 while let Some(id) = node {
4490 let current = self.arena.get(id)?;
4491 if current.window_chrome {
4492 return Some(id);
4493 }
4494 if current.gesture_dead_zone {
4495 return None;
4496 }
4497 node = self.arena.parent(id);
4498 }
4499 None
4500 }
4501}
4502
4503fn is_context_menu_chord(key: Key, modifiers: Modifiers) -> bool {
4521 match key {
4522 Key::ContextMenu => modifiers == Modifiers::NONE,
4523 Key::F10 => modifiers == Modifiers::SHIFT,
4524 #[cfg(target_os = "macos")]
4525 Key::M => modifiers == Modifiers::CTRL | Modifiers::SHIFT,
4526 _ => false,
4527 }
4528}
4529
4530#[cfg(test)]
4531mod tests {
4532 use super::*;
4533 use crate::test_widgets::FillWidget;
4534 use crate::widget::CursorIcon;
4535 use crate::widget_builder::WidgetBuilder;
4536
4537 #[test]
4538 fn pointer_enter_leave_synthesized() {
4539 let mut tree = WidgetTree::new();
4540 let widget = tree.add(FillWidget::new());
4541 tree.layout(SizeProposal::exact(100.0, 50.0));
4542 tree.pointer_move(Point::new(50.0, 25.0));
4543 assert_eq!(tree.hovered(), Some(widget));
4544 tree.pointer_move(Point::new(200.0, 200.0));
4545 assert_eq!(tree.hovered(), None);
4546 }
4547
4548 #[test]
4549 fn pointer_hover_updates_current_cursor() {
4550 let mut tree = WidgetTree::new();
4551 tree.add(FillWidget::new().cursor(CursorIcon::ColResize));
4552 tree.layout(SizeProposal::exact(100.0, 50.0));
4553
4554 tree.pointer_move(Point::new(50.0, 25.0));
4555 assert_eq!(tree.current_cursor(), CursorIcon::ColResize);
4556
4557 tree.pointer_move(Point::new(200.0, 200.0));
4558 assert_eq!(tree.current_cursor(), CursorIcon::Default);
4559 }
4560
4561 #[derive(Debug)]
4564 struct SelfDeclared(CursorIcon);
4565
4566 impl crate::widget::Widget for SelfDeclared {
4567 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
4568 ctx.apply_self_handlers(crate::widget_builder::HandlerSet::new().cursor(self.0));
4569 Vec::new()
4570 }
4571
4572 fn layout_response(
4573 &self,
4574 proposal: SizeProposal,
4575 _ctx: &crate::widget::LayoutContext,
4576 ) -> crate::widget::LayoutResponse {
4577 proposal.resolve(100.0, 50.0).into()
4578 }
4579 }
4580
4581 #[test]
4587 fn declared_cursor_reads_what_a_node_asks_for_and_current_cursor_follows_the_hover() {
4588 let over = Point::new(50.0, 25.0);
4589 let away = Point::new(200.0, 200.0);
4590
4591 let mut tree = WidgetTree::new();
4593 let built = tree.add(FillWidget::new().cursor(CursorIcon::ColResize));
4594 tree.layout(SizeProposal::exact(100.0, 50.0));
4595 assert_eq!(tree.declared_cursor(built), Some(CursorIcon::ColResize));
4596 assert_eq!(
4597 tree.current_cursor(),
4598 CursorIcon::Default,
4599 "not hovered yet"
4600 );
4601 tree.pointer_move(over);
4602 assert_eq!(tree.current_cursor(), CursorIcon::ColResize);
4603 assert_eq!(tree.declared_cursor(built), Some(CursorIcon::ColResize));
4604 tree.pointer_move(away);
4605 assert_eq!(tree.current_cursor(), CursorIcon::Default);
4606 assert_eq!(
4607 tree.declared_cursor(built),
4608 Some(CursorIcon::ColResize),
4609 "the declaration does not depend on the pointer",
4610 );
4611
4612 let mut tree = WidgetTree::new();
4614 let own = tree.add(SelfDeclared(CursorIcon::Crosshair));
4615 tree.layout(SizeProposal::exact(100.0, 50.0));
4616 assert_eq!(tree.declared_cursor(own), Some(CursorIcon::Crosshair));
4617 tree.pointer_move(over);
4618 assert_eq!(tree.current_cursor(), CursorIcon::Crosshair);
4619 tree.pointer_move(away);
4620 assert_eq!(tree.current_cursor(), CursorIcon::Default);
4621
4622 let mut tree = WidgetTree::new();
4624 let plain = tree.add(FillWidget::new());
4625 tree.layout(SizeProposal::exact(100.0, 50.0));
4626 assert_eq!(tree.declared_cursor(plain), None);
4627 let mut tree = WidgetTree::new();
4628 let explicit = tree.add(FillWidget::new().cursor(CursorIcon::Default));
4629 tree.layout(SizeProposal::exact(100.0, 50.0));
4630 assert_eq!(
4631 tree.declared_cursor(explicit),
4632 Some(CursorIcon::Default),
4633 "declaring the default cursor is not declaring nothing",
4634 );
4635 }
4636
4637 #[test]
4647 fn release_cursor_hands_the_cursor_back_to_the_node_that_declared_it() {
4648 let mut tree = WidgetTree::new();
4652 tree.add(
4653 FillWidget::new()
4654 .cursor(CursorIcon::ColResize)
4655 .on_pointer_event(|event, ctx| {
4656 if let WidgetEvent::PointerMove { position, .. } = event {
4657 if position.x < 30.0 {
4658 ctx.set_cursor(CursorIcon::Crosshair);
4659 } else {
4660 ctx.release_cursor();
4661 }
4662 }
4663 EventResponse::Ignored
4664 }),
4665 );
4666 tree.layout(SizeProposal::exact(100.0, 50.0));
4667
4668 tree.pointer_move(Point::new(10.0, 25.0));
4669 assert_eq!(
4670 tree.current_cursor(),
4671 CursorIcon::Crosshair,
4672 "the handler outranks the node it is attached to",
4673 );
4674 tree.pointer_move(Point::new(60.0, 25.0));
4675 assert_eq!(
4676 tree.current_cursor(),
4677 CursorIcon::ColResize,
4678 "and hands it back to the node, not to Default — no enter/leave \
4679 fires on a move within one node, so nothing else could",
4680 );
4681 tree.pointer_move(Point::new(10.0, 25.0));
4682 assert_eq!(
4683 tree.current_cursor(),
4684 CursorIcon::Crosshair,
4685 "and can take it again"
4686 );
4687 tree.pointer_move(Point::new(200.0, 200.0));
4688 assert_eq!(
4689 tree.current_cursor(),
4690 CursorIcon::Default,
4691 "leaving the node clears both the override and the declaration",
4692 );
4693 }
4694
4695 #[test]
4699 fn release_cursor_is_a_no_op_with_nothing_to_undo() {
4700 let mut tree = WidgetTree::new();
4701 tree.add(
4702 FillWidget::new()
4703 .cursor(CursorIcon::ColResize)
4704 .on_pointer_event(|event, ctx| {
4705 if matches!(event, WidgetEvent::PointerMove { .. }) {
4706 ctx.release_cursor();
4707 }
4708 EventResponse::Ignored
4709 }),
4710 );
4711 tree.layout(SizeProposal::exact(100.0, 50.0));
4712 tree.pointer_move(Point::new(50.0, 25.0));
4713 assert_eq!(tree.current_cursor(), CursorIcon::ColResize);
4714
4715 let mut tree = WidgetTree::new();
4717 tree.add(FillWidget::new().on_pointer_event(|event, ctx| {
4718 if let WidgetEvent::PointerMove { position, .. } = event {
4719 if position.x < 30.0 {
4720 ctx.set_cursor(CursorIcon::Crosshair);
4721 } else {
4722 ctx.release_cursor();
4723 }
4724 }
4725 EventResponse::Ignored
4726 }));
4727 tree.layout(SizeProposal::exact(100.0, 50.0));
4728 tree.pointer_move(Point::new(10.0, 25.0));
4729 assert_eq!(tree.current_cursor(), CursorIcon::Crosshair);
4730 tree.pointer_move(Point::new(60.0, 25.0));
4731 assert_eq!(
4732 tree.current_cursor(),
4733 CursorIcon::Default,
4734 "nothing declared a cursor for this chain, so the hand-back \
4735 resolves to Default",
4736 );
4737 }
4738
4739 #[test]
4747 fn an_on_hover_override_does_not_erase_the_declaration_it_outranks() {
4748 let mut tree = WidgetTree::new();
4749 tree.add(
4750 FillWidget::new()
4751 .cursor(CursorIcon::ColResize)
4752 .on_hover(|entered, ctx| {
4753 if entered {
4754 ctx.set_cursor(CursorIcon::Crosshair);
4755 }
4756 })
4757 .on_pointer_event(|event, ctx| {
4758 if let WidgetEvent::PointerMove { position, .. } = event
4759 && position.x >= 30.0
4760 {
4761 ctx.release_cursor();
4762 }
4763 EventResponse::Ignored
4764 }),
4765 );
4766 tree.layout(SizeProposal::exact(100.0, 50.0));
4767
4768 tree.pointer_move(Point::new(10.0, 25.0));
4769 assert_eq!(
4770 tree.current_cursor(),
4771 CursorIcon::Crosshair,
4772 "on_hover runs after the node cursor is applied, so it wins",
4773 );
4774 tree.pointer_move(Point::new(60.0, 25.0));
4775 assert_eq!(
4776 tree.current_cursor(),
4777 CursorIcon::ColResize,
4778 "and the node's declaration survived being overridden",
4779 );
4780 }
4781
4782 #[derive(Debug)]
4785 struct Bumpable {
4786 value: i32,
4787 }
4788
4789 impl crate::widget::Widget for Bumpable {
4790 fn layout_response(
4791 &self,
4792 proposal: SizeProposal,
4793 _ctx: &crate::widget::LayoutContext,
4794 ) -> crate::widget::LayoutResponse {
4795 proposal.resolve(10.0, 10.0).into()
4796 }
4797 fn as_any(&self) -> Option<&dyn std::any::Any> {
4798 Some(self)
4799 }
4800 fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
4801 Some(self)
4802 }
4803 }
4804
4805 #[test]
4806 fn with_widget_mut_applies_and_dirty_marks() {
4807 let mut tree = WidgetTree::new();
4808 let id = tree.add(Bumpable { value: 0 });
4809 tree.layout(SizeProposal::exact(100.0, 100.0));
4810
4811 let mut ctx = EventContext::new();
4812 ctx.with_widget_mut::<Bumpable>(id, crate::binding::BindingLevel::Relayout, |b| {
4813 b.value = 42;
4814 });
4815 tree.collect_from_ctx(ctx, id);
4816
4817 let value = tree
4818 .widget_as_any(id)
4819 .and_then(|a| a.downcast_ref::<Bumpable>())
4820 .map(|b| b.value);
4821 assert_eq!(
4822 value,
4823 Some(42),
4824 "the deferred closure must mutate the live widget"
4825 );
4826 assert!(
4827 tree.needs_layout(),
4828 "Relayout dirty level must mark the tree for relayout"
4829 );
4830 }
4831
4832 #[test]
4833 #[cfg(debug_assertions)]
4834 #[should_panic(expected = "not the requested type")]
4835 fn with_widget_mut_wrong_type_panics_in_debug() {
4836 struct Other;
4837 let mut tree = WidgetTree::new();
4838 let id = tree.add(Bumpable { value: 0 });
4839 let mut ctx = EventContext::new();
4840 ctx.with_widget_mut::<Other>(
4841 id,
4842 crate::binding::BindingLevel::RepaintOnly,
4843 |_o: &mut Other| {},
4844 );
4845 tree.collect_from_ctx(ctx, id);
4848 }
4849
4850 #[test]
4851 fn with_widget_mut_closure_may_fire_observed_signals() {
4852 use crate::signal::Signal;
4860 let mut tree = WidgetTree::new();
4861 let id = tree.add(Bumpable { value: 0 });
4862 tree.layout(SizeProposal::exact(100.0, 100.0));
4863
4864 let trigger = Signal::new(0_u64);
4865 let echo = Signal::new(0_u64);
4866 let echo_for_obs = echo.clone();
4867 let _obs = trigger.observe(move |v| echo_for_obs.set(*v));
4868
4869 let trigger_in = trigger.clone();
4870 let mut ctx = EventContext::new();
4871 ctx.with_widget_mut::<Bumpable>(id, crate::binding::BindingLevel::RepaintOnly, move |b| {
4872 b.value = 7;
4873 trigger_in.set(99);
4875 });
4876 tree.collect_from_ctx(ctx, id); assert_eq!(
4879 echo.get(),
4880 99,
4881 "the observer ran during the deferred mutation"
4882 );
4883 let value = tree
4884 .widget_as_any(id)
4885 .and_then(|a| a.downcast_ref::<Bumpable>())
4886 .map(|b| b.value);
4887 assert_eq!(value, Some(7));
4888 }
4889
4890 #[test]
4891 fn request_accessibility_update_forces_rewalk() {
4892 let mut tree = WidgetTree::new();
4893 let id = tree.add(Bumpable { value: 0 });
4894 tree.layout(SizeProposal::exact(100.0, 100.0));
4895 let _ = tree.sync_accessibility(); assert!(
4897 !tree.a11y_dirty,
4898 "sync_accessibility should clear the dirty flag"
4899 );
4900
4901 let mut ctx = EventContext::new();
4902 ctx.request_accessibility_update();
4903 tree.collect_from_ctx(ctx, id);
4904 assert!(
4905 tree.a11y_dirty,
4906 "request_accessibility_update must force an AT re-walk"
4907 );
4908 }
4909
4910 #[test]
4911 fn rebuild_dirties_accessibility_tree() {
4912 let mut tree = WidgetTree::new();
4919 let id = tree.add(Bumpable { value: 0 });
4920 tree.layout(SizeProposal::exact(100.0, 100.0));
4921 let _ = tree.sync_accessibility(); assert!(
4923 !tree.a11y_dirty,
4924 "sync_accessibility should clear the dirty flag"
4925 );
4926
4927 tree.arena_mark_needs_rebuild_for_testing(id);
4930 tree.layout(SizeProposal::exact(100.0, 100.0));
4931 assert!(
4932 tree.a11y_dirty,
4933 "a rebuild must dirty the AT tree so the next sync re-walks"
4934 );
4935 }
4936
4937 #[test]
4938 fn bound_access_label_change_dirties_accessibility_tree() {
4939 use crate::signal::Signal;
4940 use crate::test_widgets::FillWidget;
4941 use crate::widget_builder::WidgetBuilder;
4942
4943 let label = Signal::new("first".to_string());
4949 let mut tree = WidgetTree::new();
4950 let _id = tree.add(FillWidget::new().access_label(label.clone()));
4951 tree.layout(SizeProposal::exact(100.0, 100.0));
4952 let _ = tree.sync_accessibility(); assert!(!tree.a11y_dirty, "sync_accessibility should clear the flag");
4954
4955 label.set("second".to_string());
4956 tree.layout(SizeProposal::exact(100.0, 100.0));
4957 assert!(
4958 tree.a11y_dirty,
4959 "changing a bound access_label must dirty the AT tree"
4960 );
4961 }
4962
4963 #[test]
4964 fn disabled_ancestor_blocks_event_to_descendant() {
4965 use crate::signal::Signal;
4966 use crate::test_widgets::StackWidget;
4967 use std::cell::Cell;
4968 use std::rc::Rc;
4969
4970 let tapped = Rc::new(Cell::new(false));
4971 let flag = tapped.clone();
4972 let enabled = Signal::new(true);
4973
4974 let mut tree = WidgetTree::new();
4975 let child = tree.add(FillWidget::new().on_tap(move |_pos, _ctx| {
4976 flag.set(true);
4977 }));
4978 let parent = tree.add(StackWidget::new().child(child));
4979 tree.enabled_when(parent, enabled.clone());
4980 tree.layout(SizeProposal::exact(100.0, 50.0));
4981
4982 enabled.set(false);
4983 tree.click(child);
4984 assert!(
4985 !tapped.get(),
4986 "disabled ancestor should block descendant tap"
4987 );
4988
4989 enabled.set(true);
4990 tree.click(child);
4991 assert!(tapped.get(), "re-enabling should restore dispatch");
4992 }
4993
4994 #[test]
4995 fn pointer_positions_are_widget_local_at_nonzero_origin() {
4996 use crate::event::{Modifiers, PointerButton};
4997 use crate::test_widgets::InsetWidget;
4998 use std::cell::Cell;
4999 use std::rc::Rc;
5000
5001 let tap_pos: Rc<Cell<Option<Point>>> = Rc::new(Cell::new(None));
5003 let down_pos: Rc<Cell<Option<Point>>> = Rc::new(Cell::new(None));
5004 let drag_pos: Rc<Cell<Option<Point>>> = Rc::new(Cell::new(None));
5005 let (tp, dp, gp) = (tap_pos.clone(), down_pos.clone(), drag_pos.clone());
5006
5007 let mut tree = WidgetTree::new();
5008 let child = tree.add(
5009 FillWidget::new()
5010 .on_tap(move |ev, _ctx| tp.set(Some(ev.position)))
5011 .on_pointer_event(move |ev, _ctx| {
5012 if let WidgetEvent::PointerDown { position, .. } = ev {
5013 dp.set(Some(*position));
5014 }
5015 crate::event::EventResponse::Ignored
5016 })
5017 .on_drag(move |phase, _ctx| {
5018 use crate::gesture::DragPhase;
5019 match phase {
5020 DragPhase::Started { position, .. }
5021 | DragPhase::Moved { position, .. }
5022 | DragPhase::Ended { position, .. } => gp.set(Some(position)),
5023 _ => {}
5024 }
5025 }),
5026 );
5027 let inset = tree.add(InsetWidget::new(20.0).set_child(child));
5028 let _ = inset;
5029 tree.layout(SizeProposal::exact(200.0, 200.0));
5030 assert_eq!(tree.bounds(child).origin(), Point::new(20.0, 20.0));
5031
5032 tree.dispatch_event(WidgetEvent::pointer_down(
5034 Point::new(50.0, 40.0),
5035 PointerButton::Primary,
5036 Modifiers::NONE,
5037 ));
5038 assert_eq!(
5039 down_pos.get(),
5040 Some(Point::new(30.0, 20.0)),
5041 "on_pointer_event PointerDown must be widget-local"
5042 );
5043 tree.dispatch_event(WidgetEvent::pointer_up(
5044 Point::new(50.0, 40.0),
5045 PointerButton::Primary,
5046 Modifiers::NONE,
5047 ));
5048 assert_eq!(
5049 tap_pos.get(),
5050 Some(Point::new(30.0, 20.0)),
5051 "on_tap position must be widget-local"
5052 );
5053
5054 tree.dispatch_event(WidgetEvent::pointer_down(
5057 Point::new(50.0, 40.0),
5058 PointerButton::Primary,
5059 Modifiers::NONE,
5060 ));
5061 tree.dispatch_event(WidgetEvent::pointer_move(Point::new(65.0, 55.0)));
5064 tree.dispatch_event(WidgetEvent::pointer_move(Point::new(90.0, 70.0)));
5065 assert_eq!(
5066 drag_pos.get(),
5067 Some(Point::new(70.0, 50.0)),
5068 "on_drag position must be widget-local"
5069 );
5070 }
5071
5072 #[test]
5073 fn dormant_widget_not_hit_tested() {
5074 let mut tree = WidgetTree::new();
5075 let widget = tree.add(FillWidget::new());
5076 tree.layout(SizeProposal::exact(100.0, 50.0));
5077
5078 tree.pointer_move(Point::new(50.0, 25.0));
5079 assert_eq!(tree.hovered(), Some(widget));
5080
5081 tree.set_dormant(widget);
5082 tree.pointer_move(Point::new(200.0, 200.0));
5083 tree.pointer_move(Point::new(50.0, 25.0));
5084 assert_eq!(tree.hovered(), None);
5085 }
5086
5087 #[test]
5088 fn ancestor_pointer_handler_does_not_suppress_descendant_hover() {
5089 use crate::event::EventResponse;
5090 use crate::test_widgets::StackWidget;
5091 use std::cell::Cell;
5092 use std::rc::Rc;
5093
5094 let hovered = Rc::new(Cell::new(false));
5096 let h = hovered.clone();
5097
5098 let mut tree = WidgetTree::new();
5099 let child = tree.add(FillWidget::new().on_hover(move |entered, _ctx| h.set(entered)));
5100 tree.add(
5105 StackWidget::new()
5106 .child(child)
5107 .on_pointer_event(|_event, _ctx| EventResponse::Handled),
5108 );
5109 tree.layout(SizeProposal::exact(100.0, 50.0));
5110
5111 tree.pointer_move(Point::new(50.0, 25.0));
5112 assert!(
5113 hovered.get(),
5114 "a greedy ancestor on_pointer_event must NOT swallow the child's PointerEnter"
5115 );
5116
5117 tree.pointer_move(Point::new(500.0, 500.0));
5118 assert!(
5119 !hovered.get(),
5120 "PointerLeave must likewise reach the child despite the ancestor"
5121 );
5122 }
5123
5124 #[test]
5132 fn a_child_hover_handler_does_not_swallow_its_ancestors() {
5133 use crate::test_widgets::StackWidget;
5134 use std::cell::Cell;
5135 use std::rc::Rc;
5136
5137 let (row, button) = (Rc::new(Cell::new(false)), Rc::new(Cell::new(false)));
5138 let (r, b) = (row.clone(), button.clone());
5139
5140 let mut tree = WidgetTree::new();
5141 let child = tree.add(FillWidget::new().on_hover(move |entered, _ctx| b.set(entered)));
5142 tree.add(
5143 StackWidget::new()
5144 .child(child)
5145 .on_hover(move |entered, _ctx| r.set(entered)),
5146 );
5147 tree.layout(SizeProposal::exact(100.0, 50.0));
5148
5149 tree.pointer_move(Point::new(50.0, 25.0));
5150 assert!(button.get(), "the child is hovered");
5151 assert!(row.get(), "and so is the row it is inside");
5152
5153 tree.pointer_move(Point::new(500.0, 500.0));
5154 assert!(!button.get(), "the child heard the leave");
5155 assert!(
5156 !row.get(),
5157 "and so did the row — a container is not still hovered because the \
5158 pointer left it through a button"
5159 );
5160 }
5161
5162 #[test]
5169 fn key_preview_consumes_before_focused_on_key() {
5170 use crate::event::EventResponse;
5173 use crate::test_widgets::StackWidget;
5174 use std::cell::Cell;
5175 use std::rc::Rc;
5176
5177 let leaf_fired = Rc::new(Cell::new(false));
5178 let leaf_flag = leaf_fired.clone();
5179 let preview_fired = Rc::new(Cell::new(false));
5180 let preview_flag = preview_fired.clone();
5181
5182 let mut tree = WidgetTree::new();
5183 let leaf = tree.add(FillWidget::new().focusable().on_key(move |event, _c| {
5184 if matches!(event, WidgetEvent::KeyDown { .. }) {
5187 leaf_flag.set(true);
5188 }
5189 EventResponse::Handled
5190 }));
5191 let mid = tree.add(StackWidget::new().child(leaf));
5192 let _root = tree.add(
5193 StackWidget::new()
5194 .child(mid)
5195 .on_key_preview(move |event, _c| match event {
5196 WidgetEvent::KeyDown {
5197 key: Key::Enter, ..
5198 } => {
5199 preview_flag.set(true);
5200 EventResponse::Handled
5201 }
5202 _ => EventResponse::Ignored,
5203 }),
5204 );
5205
5206 tree.layout(SizeProposal::exact(100.0, 50.0));
5207 tree.focus(leaf);
5208 tree.press_key(Key::Enter, Modifiers::NONE);
5209
5210 assert!(
5211 preview_fired.get(),
5212 "ancestor on_key_preview must fire for KeyDown on a focused descendant"
5213 );
5214 assert!(
5215 !leaf_fired.get(),
5216 "consuming the event in preview must prevent the focused widget's on_key from running"
5217 );
5218 }
5219
5220 #[test]
5221 fn key_preview_falls_through_when_returning_ignored() {
5222 use crate::event::EventResponse;
5225 use crate::test_widgets::StackWidget;
5226 use std::cell::Cell;
5227 use std::rc::Rc;
5228
5229 let leaf_fired = Rc::new(Cell::new(false));
5230 let leaf_flag = leaf_fired.clone();
5231 let preview_fired = Rc::new(Cell::new(false));
5232 let preview_flag = preview_fired.clone();
5233
5234 let mut tree = WidgetTree::new();
5235 let leaf = tree.add(FillWidget::new().focusable().on_key(move |_e, _c| {
5236 leaf_flag.set(true);
5237 EventResponse::Handled
5238 }));
5239 let mid = tree.add(StackWidget::new().child(leaf));
5240 let _root = tree.add(
5241 StackWidget::new()
5242 .child(mid)
5243 .on_key_preview(move |_event, _c| {
5244 preview_flag.set(true);
5245 EventResponse::Ignored
5246 }),
5247 );
5248
5249 tree.layout(SizeProposal::exact(100.0, 50.0));
5250 tree.focus(leaf);
5251 tree.press_key(Key::Enter, Modifiers::NONE);
5252
5253 assert!(preview_fired.get(), "preview must always be invoked");
5254 assert!(
5255 leaf_fired.get(),
5256 "preview returning Ignored must not block the focused widget's on_key"
5257 );
5258 }
5259
5260 #[test]
5261 fn key_preview_excludes_focused_target_itself() {
5262 use crate::event::EventResponse;
5266 use std::cell::Cell;
5267 use std::rc::Rc;
5268
5269 let preview_on_target = Rc::new(Cell::new(false));
5270 let pf = preview_on_target.clone();
5271
5272 let mut tree = WidgetTree::new();
5273 let leaf = tree.add(FillWidget::new().focusable().on_key_preview(move |_e, _c| {
5274 pf.set(true);
5275 EventResponse::Handled
5276 }));
5277 tree.layout(SizeProposal::exact(100.0, 50.0));
5278 tree.focus(leaf);
5279 tree.press_key(Key::Enter, Modifiers::NONE);
5280
5281 assert!(
5282 !preview_on_target.get(),
5283 "the focused widget itself must not see its own on_key_preview"
5284 );
5285 }
5286
5287 #[test]
5288 fn key_preview_root_to_target_order() {
5289 use crate::event::EventResponse;
5293 use crate::test_widgets::StackWidget;
5294 use std::cell::RefCell;
5295 use std::rc::Rc;
5296
5297 let order: Rc<RefCell<Vec<&'static str>>> = Rc::new(RefCell::new(Vec::new()));
5298 let outer_log = order.clone();
5299 let inner_log = order.clone();
5300
5301 let mut tree = WidgetTree::new();
5302 let leaf = tree.add(FillWidget::new().focusable());
5303 let inner = tree.add(
5304 StackWidget::new()
5305 .child(leaf)
5306 .on_key_preview(move |event, _c| {
5307 if matches!(event, WidgetEvent::KeyDown { .. }) {
5308 inner_log.borrow_mut().push("inner");
5309 }
5310 EventResponse::Ignored
5311 }),
5312 );
5313 let _outer = tree.add(
5314 StackWidget::new()
5315 .child(inner)
5316 .on_key_preview(move |event, _c| {
5317 if matches!(event, WidgetEvent::KeyDown { .. }) {
5318 outer_log.borrow_mut().push("outer");
5319 }
5320 EventResponse::Ignored
5321 }),
5322 );
5323
5324 tree.layout(SizeProposal::exact(100.0, 50.0));
5325 tree.focus(leaf);
5326 tree.dispatch_event(WidgetEvent::KeyDown {
5327 key: Key::Enter,
5328 modifiers: Modifiers::NONE,
5329 text: None,
5330 });
5331
5332 assert_eq!(
5333 *order.borrow(),
5334 vec!["outer", "inner"],
5335 "preview must walk root → parent-of-target"
5336 );
5337 }
5338
5339 #[test]
5340 fn access_action_routes_to_cursored_target_not_focus() {
5341 use crate::signal::Signal;
5345 let a_fired = Signal::new(false);
5346 let b_fired = Signal::new(false);
5347 let a_cb = a_fired.clone();
5348 let b_cb = b_fired.clone();
5349
5350 let mut tree = WidgetTree::new();
5351 let a = tree.add(
5352 FillWidget::new().access_action(accesskit::Action::Click, move |_ctx| a_cb.set(true)),
5353 );
5354 let b = tree.add(
5355 FillWidget::new().access_action(accesskit::Action::Click, move |_ctx| b_cb.set(true)),
5356 );
5357 tree.layout(SizeProposal::exact(200.0, 100.0));
5358
5359 tree.focus(a);
5360 tree.dispatch_event(WidgetEvent::AccessAction {
5361 action: accesskit::Action::Click,
5362 target: Some(b),
5363 target_node: crate::accessibility::widget_id_to_node_id(b),
5364 data: None,
5365 });
5366
5367 assert!(b_fired.get(), "the cursored target must receive the action");
5368 assert!(
5369 !a_fired.get(),
5370 "the keyboard-focused widget must NOT receive an action targeting another node"
5371 );
5372 }
5373
5374 #[test]
5375 fn access_action_without_target_is_dropped_not_redirected_to_focus() {
5376 use crate::signal::Signal;
5379 let fired = Signal::new(false);
5380 let cb = fired.clone();
5381
5382 let mut tree = WidgetTree::new();
5383 let widget = tree.add(
5384 FillWidget::new().access_action(accesskit::Action::Click, move |_ctx| cb.set(true)),
5385 );
5386 tree.layout(SizeProposal::exact(200.0, 100.0));
5387
5388 tree.focus(widget);
5389 tree.dispatch_event(WidgetEvent::AccessAction {
5390 action: accesskit::Action::Click,
5391 target: None,
5392 target_node: crate::accessibility::root_node_id(),
5393 data: None,
5394 });
5395
5396 assert!(
5397 !fired.get(),
5398 "a target-less action must not be redirected to the focused widget"
5399 );
5400 }
5401
5402 #[test]
5409 fn shortcut_fires_matching_action_on_source_widget() {
5410 use crate::action::Action;
5411 use crate::shortcut::{KeyStroke, Shortcut};
5412 use std::cell::Cell;
5413 use std::rc::Rc;
5414
5415 let fired = Rc::new(Cell::new(false));
5416 let fired_flag = fired.clone();
5417
5418 let mut tree = WidgetTree::new();
5419 let widget = tree.add(FillWidget::new().focusable());
5420 tree.push_action(
5421 widget,
5422 Action::new("app.save").on_invoke(move |_intent, _ctx| {
5423 fired_flag.set(true);
5424 }),
5425 );
5426 tree.shortcut_registry_mut().register(
5427 Shortcut::new("app.save")
5428 .primary(KeyStroke::command(Key::S))
5429 .build(),
5430 );
5431
5432 tree.layout(SizeProposal::exact(100.0, 50.0));
5433 tree.focus(widget);
5434
5435 tree.press_key(Key::S, Modifiers::COMMAND);
5436 assert!(fired.get(), "matching action must fire on KeyDown");
5437 }
5438
5439 #[test]
5440 fn global_shortcut_fires_without_focused_widget() {
5441 use crate::action::Action;
5442 use crate::shortcut::{KeyStroke, Shortcut};
5443 use std::cell::Cell;
5444 use std::rc::Rc;
5445
5446 let fired = Rc::new(Cell::new(false));
5450 let fired_flag = fired.clone();
5451
5452 let mut tree = WidgetTree::new();
5453 let root = tree.add(FillWidget::new());
5454 tree.push_action(
5455 root,
5456 Action::new("app.save").on_invoke(move |_intent, _ctx| {
5457 fired_flag.set(true);
5458 }),
5459 );
5460 tree.shortcut_registry_mut().register(
5461 Shortcut::new("app.save")
5462 .primary(KeyStroke::command(Key::S))
5463 .build(),
5464 );
5465
5466 tree.layout(SizeProposal::exact(100.0, 50.0));
5467 tree.press_key(Key::S, Modifiers::COMMAND);
5470 assert!(
5471 fired.get(),
5472 "global shortcut must fire without a focused widget"
5473 );
5474 }
5475
5476 #[test]
5477 fn global_shortcut_fires_after_focused_widget_destroyed() {
5478 use crate::action::Action;
5479 use crate::shortcut::{KeyStroke, Shortcut};
5480 use std::cell::Cell;
5481 use std::rc::Rc;
5482
5483 let fired = Rc::new(Cell::new(false));
5488 let fired_flag = fired.clone();
5489
5490 let mut tree = WidgetTree::new();
5491 let root = tree.add(FillWidget::new());
5492 let focusable = tree.add_child(root, FillWidget::new().focusable());
5493 tree.push_action(
5494 root,
5495 Action::new("app.save").on_invoke(move |_intent, _ctx| {
5496 fired_flag.set(true);
5497 }),
5498 );
5499 tree.shortcut_registry_mut().register(
5500 Shortcut::new("app.save")
5501 .primary(KeyStroke::command(Key::S))
5502 .build(),
5503 );
5504
5505 tree.layout(SizeProposal::exact(100.0, 50.0));
5506 tree.focus(focusable);
5507 assert_eq!(tree.focused(), Some(focusable));
5508
5509 tree.destroy_subtree(focusable);
5512 assert_eq!(tree.focused(), None, "focus must clear when destroyed");
5513
5514 tree.press_key(Key::S, Modifiers::COMMAND);
5515 assert!(
5516 fired.get(),
5517 "global shortcut must still fire after the focused widget is destroyed"
5518 );
5519 }
5520
5521 #[test]
5522 fn scoped_shortcut_matches_only_when_focus_in_scope() {
5523 use crate::action::Action;
5524 use crate::shortcut::{KeyStroke, Shortcut, ShortcutScope};
5525 use std::cell::Cell;
5526 use std::rc::Rc;
5527
5528 let fired = Rc::new(Cell::new(0));
5529 let fired_flag = fired.clone();
5530
5531 let mut tree = WidgetTree::new();
5532 let scope_root = tree.add(FillWidget::new().focusable());
5533 let inside = tree.add_child(scope_root, FillWidget::new().focusable());
5534 let outside = tree.add(FillWidget::new().focusable());
5535
5536 tree.push_action(
5537 scope_root,
5538 Action::new("editor.find").on_invoke(move |_i, _c| {
5539 fired_flag.set(fired_flag.get() + 1);
5540 }),
5541 );
5542 tree.shortcut_registry_mut().register(
5543 Shortcut::new("editor.find")
5544 .primary(KeyStroke::command(Key::F))
5545 .scope(ShortcutScope::Scoped(scope_root))
5546 .build(),
5547 );
5548
5549 tree.layout(SizeProposal::exact(200.0, 100.0));
5550
5551 tree.focus(outside);
5553 tree.press_key(Key::F, Modifiers::COMMAND);
5554 assert_eq!(
5555 fired.get(),
5556 0,
5557 "scoped shortcut must not fire outside scope"
5558 );
5559
5560 tree.focus(inside);
5562 tree.press_key(Key::F, Modifiers::COMMAND);
5563 assert_eq!(
5564 fired.get(),
5565 1,
5566 "scoped shortcut must fire when focus in scope"
5567 );
5568 }
5569
5570 #[test]
5571 fn same_chord_scoped_first_falls_back_to_global_when_focus_outside() {
5572 use crate::action::Action;
5578 use crate::shortcut::{KeyStroke, Shortcut, ShortcutScope};
5579 use std::cell::Cell;
5580 use std::rc::Rc;
5581
5582 let scoped_fired = Rc::new(Cell::new(0));
5583 let global_fired = Rc::new(Cell::new(0));
5584 let sf = scoped_fired.clone();
5585 let gf = global_fired.clone();
5586
5587 let mut tree = WidgetTree::new();
5588 let root = tree.add(FillWidget::new());
5589 let editor = tree.add_child(root, FillWidget::new().focusable());
5590 let _editor_inner = tree.add_child(editor, FillWidget::new().focusable());
5591 let sidebar = tree.add_child(root, FillWidget::new().focusable());
5592
5593 tree.push_action(
5594 editor,
5595 Action::new("editor.saveBlock").on_invoke(move |_i, _c| sf.set(sf.get() + 1)),
5596 );
5597 tree.push_action(
5598 root,
5599 Action::new("zzz.global.save").on_invoke(move |_i, _c| gf.set(gf.get() + 1)),
5600 );
5601 tree.shortcut_registry_mut().register(
5602 Shortcut::new("editor.saveBlock")
5603 .primary(KeyStroke::command(Key::S))
5604 .scope(ShortcutScope::Scoped(editor))
5605 .build(),
5606 );
5607 tree.shortcut_registry_mut().register(
5608 Shortcut::new("zzz.global.save")
5609 .primary(KeyStroke::command(Key::S))
5610 .build(),
5611 );
5612
5613 tree.layout(SizeProposal::exact(200.0, 100.0));
5614 tree.focus(sidebar);
5615 tree.press_key(Key::S, Modifiers::COMMAND);
5616
5617 assert_eq!(global_fired.get(), 1, "applicable global must fire");
5618 assert_eq!(
5619 scoped_fired.get(),
5620 0,
5621 "inapplicable scoped binding must not eat the chord"
5622 );
5623 }
5624
5625 #[test]
5626 fn same_chord_global_first_yields_to_scoped_when_focus_inside() {
5627 use crate::action::Action;
5632 use crate::shortcut::{KeyStroke, Shortcut, ShortcutScope};
5633 use std::cell::Cell;
5634 use std::rc::Rc;
5635
5636 let scoped_fired = Rc::new(Cell::new(0));
5637 let global_fired = Rc::new(Cell::new(0));
5638 let sf = scoped_fired.clone();
5639 let gf = global_fired.clone();
5640
5641 let mut tree = WidgetTree::new();
5642 let root = tree.add(FillWidget::new());
5643 let editor = tree.add_child(root, FillWidget::new().focusable());
5644 let editor_inner = tree.add_child(editor, FillWidget::new().focusable());
5645 let sidebar = tree.add_child(root, FillWidget::new().focusable());
5646
5647 tree.push_action(
5648 editor,
5649 Action::new("editor.saveBlock").on_invoke(move |_i, _c| sf.set(sf.get() + 1)),
5650 );
5651 tree.push_action(
5652 root,
5653 Action::new("app.save").on_invoke(move |_i, _c| gf.set(gf.get() + 1)),
5654 );
5655 tree.shortcut_registry_mut().register(
5656 Shortcut::new("app.save")
5657 .primary(KeyStroke::command(Key::S))
5658 .build(),
5659 );
5660 tree.shortcut_registry_mut().register(
5661 Shortcut::new("editor.saveBlock")
5662 .primary(KeyStroke::command(Key::S))
5663 .scope(ShortcutScope::Scoped(editor))
5664 .build(),
5665 );
5666
5667 tree.layout(SizeProposal::exact(200.0, 100.0));
5668
5669 tree.focus(editor_inner);
5671 tree.press_key(Key::S, Modifiers::COMMAND);
5672 assert_eq!(
5673 scoped_fired.get(),
5674 1,
5675 "in-focus scoped must win over global"
5676 );
5677 assert_eq!(
5678 global_fired.get(),
5679 0,
5680 "global must yield to the scoped binding"
5681 );
5682
5683 tree.focus(sidebar);
5685 tree.press_key(Key::S, Modifiers::COMMAND);
5686 assert_eq!(scoped_fired.get(), 1, "scoped stays put outside its scope");
5687 assert_eq!(
5688 global_fired.get(),
5689 1,
5690 "global fires when focus leaves the scope"
5691 );
5692 }
5693
5694 #[test]
5695 fn propagated_action_lets_ancestor_handle() {
5696 use crate::action::Action;
5697 use crate::intent::IntentResponse;
5698 use crate::shortcut::{KeyStroke, Shortcut};
5699 use std::cell::Cell;
5700 use std::rc::Rc;
5701
5702 let inner_seen = Rc::new(Cell::new(false));
5703 let outer_seen = Rc::new(Cell::new(false));
5704 let inner_flag = inner_seen.clone();
5705 let outer_flag = outer_seen.clone();
5706
5707 let mut tree = WidgetTree::new();
5708 let outer = tree.add(FillWidget::new().focusable());
5709 let inner = tree.add_child(outer, FillWidget::new().focusable());
5710
5711 tree.push_action(
5713 inner,
5714 Action::new("app.save").on_invoke_with_response(move |_i, _c| {
5715 inner_flag.set(true);
5716 IntentResponse::Propagated
5717 }),
5718 );
5719 tree.push_action(
5720 outer,
5721 Action::new("app.save").on_invoke(move |_i, _c| {
5722 outer_flag.set(true);
5723 }),
5724 );
5725 tree.shortcut_registry_mut().register(
5726 Shortcut::new("app.save")
5727 .primary(KeyStroke::command(Key::S))
5728 .build(),
5729 );
5730
5731 tree.layout(SizeProposal::exact(100.0, 50.0));
5732 tree.focus(inner);
5733
5734 tree.press_key(Key::S, Modifiers::COMMAND);
5735 assert!(inner_seen.get(), "inner action observed the intent");
5736 assert!(outer_seen.get(), "outer action reached after Propagated");
5737 }
5738
5739 #[test]
5740 fn handled_action_stops_propagation() {
5741 use crate::action::Action;
5742 use crate::shortcut::{KeyStroke, Shortcut};
5743 use std::cell::Cell;
5744 use std::rc::Rc;
5745
5746 let inner_seen = Rc::new(Cell::new(false));
5747 let outer_seen = Rc::new(Cell::new(false));
5748 let inner_flag = inner_seen.clone();
5749 let outer_flag = outer_seen.clone();
5750
5751 let mut tree = WidgetTree::new();
5752 let outer = tree.add(FillWidget::new().focusable());
5753 let inner = tree.add_child(outer, FillWidget::new().focusable());
5754
5755 tree.push_action(
5756 inner,
5757 Action::new("app.save").on_invoke(move |_i, _c| {
5758 inner_flag.set(true);
5759 }),
5760 );
5761 tree.push_action(
5762 outer,
5763 Action::new("app.save").on_invoke(move |_i, _c| {
5764 outer_flag.set(true);
5765 }),
5766 );
5767 tree.shortcut_registry_mut().register(
5768 Shortcut::new("app.save")
5769 .primary(KeyStroke::command(Key::S))
5770 .build(),
5771 );
5772
5773 tree.layout(SizeProposal::exact(100.0, 50.0));
5774 tree.focus(inner);
5775
5776 tree.press_key(Key::S, Modifiers::COMMAND);
5777 assert!(inner_seen.get());
5778 assert!(!outer_seen.get(), "Handled at inner must stop propagation");
5779 }
5780
5781 #[test]
5782 fn disabled_action_propagates_by_default() {
5783 use crate::action::Action;
5784 use crate::shortcut::{KeyStroke, Shortcut};
5785 use crate::signal::Signal;
5786 use std::cell::Cell;
5787 use std::rc::Rc;
5788
5789 let inner_seen = Rc::new(Cell::new(false));
5790 let outer_seen = Rc::new(Cell::new(false));
5791 let inner_flag = inner_seen.clone();
5792 let outer_flag = outer_seen.clone();
5793
5794 let mut tree = WidgetTree::new();
5795 let outer = tree.add(FillWidget::new().focusable());
5796 let inner = tree.add_child(outer, FillWidget::new().focusable());
5797
5798 let enabled = Signal::new(false);
5799 tree.push_action(
5800 inner,
5801 Action::new("app.save")
5802 .enabled_when(enabled.clone())
5803 .on_invoke(move |_i, _c| {
5804 inner_flag.set(true);
5805 }),
5806 );
5807 tree.push_action(
5808 outer,
5809 Action::new("app.save").on_invoke(move |_i, _c| {
5810 outer_flag.set(true);
5811 }),
5812 );
5813 tree.shortcut_registry_mut().register(
5814 Shortcut::new("app.save")
5815 .primary(KeyStroke::command(Key::S))
5816 .build(),
5817 );
5818
5819 tree.layout(SizeProposal::exact(100.0, 50.0));
5820 tree.focus(inner);
5821
5822 tree.press_key(Key::S, Modifiers::COMMAND);
5823 assert!(!inner_seen.get(), "disabled inner must not run");
5824 assert!(
5825 outer_seen.get(),
5826 "intent must propagate past disabled inner"
5827 );
5828 }
5829
5830 #[test]
5831 fn disabled_action_with_non_propagating_shortcut_consumes() {
5832 use crate::action::Action;
5833 use crate::shortcut::{KeyStroke, Shortcut};
5834 use crate::signal::Signal;
5835 use std::cell::Cell;
5836 use std::rc::Rc;
5837
5838 let inner_seen = Rc::new(Cell::new(false));
5839 let outer_seen = Rc::new(Cell::new(false));
5840 let inner_flag = inner_seen.clone();
5841 let outer_flag = outer_seen.clone();
5842
5843 let mut tree = WidgetTree::new();
5844 let outer = tree.add(FillWidget::new().focusable());
5845 let inner = tree.add_child(outer, FillWidget::new().focusable());
5846
5847 let enabled = Signal::new(false);
5848 tree.push_action(
5849 inner,
5850 Action::new("app.save")
5851 .enabled_when(enabled.clone())
5852 .on_invoke(move |_i, _c| {
5853 inner_flag.set(true);
5854 }),
5855 );
5856 tree.push_action(
5857 outer,
5858 Action::new("app.save").on_invoke(move |_i, _c| {
5859 outer_flag.set(true);
5860 }),
5861 );
5862 tree.shortcut_registry_mut().register(
5863 Shortcut::new("app.save")
5864 .primary(KeyStroke::command(Key::S))
5865 .propagate_when_disabled(false)
5866 .build(),
5867 );
5868
5869 tree.layout(SizeProposal::exact(100.0, 50.0));
5870 tree.focus(inner);
5871
5872 tree.press_key(Key::S, Modifiers::COMMAND);
5873 assert!(!inner_seen.get(), "disabled inner still does not run");
5874 assert!(
5875 !outer_seen.get(),
5876 "intent must NOT propagate when shortcut disallows it"
5877 );
5878 }
5879
5880 #[test]
5881 fn send_intent_from_handler_reaches_ancestor_action() {
5882 use crate::action::Action;
5883 use crate::intent::Intent;
5884 use std::cell::Cell;
5885 use std::rc::Rc;
5886
5887 let save_seen = Rc::new(Cell::new(false));
5888 let save_flag = save_seen.clone();
5889
5890 let mut tree = WidgetTree::new();
5891 let root = tree.add(FillWidget::new());
5892 let button = tree.add_child(
5893 root,
5894 FillWidget::new().on_tap(|_pos, ctx| {
5895 ctx.send_intent(Intent::new("app.save"));
5896 }),
5897 );
5898 tree.push_action(
5899 root,
5900 Action::new("app.save").on_invoke(move |_i, _c| {
5901 save_flag.set(true);
5902 }),
5903 );
5904
5905 tree.layout(SizeProposal::exact(100.0, 50.0));
5906 tree.click(button);
5907 assert!(
5908 save_seen.get(),
5909 "ctx.send_intent must reach ancestor action"
5910 );
5911 }
5912
5913 #[test]
5914 fn widget_type_histogram_counts_distinct_types() {
5915 let mut tree = WidgetTree::new();
5920 let _ = tree.add(FillWidget::new());
5921 let _ = tree.add(FillWidget::new());
5922 let _ = tree.add(FillWidget::new());
5923 tree.layout(SizeProposal::exact(100.0, 100.0));
5924 let histogram = tree.widget_type_histogram();
5925 let total: u32 = histogram.values().sum();
5926 assert!(
5927 total >= 3,
5928 "expected at least 3 active widgets, got {total}: {histogram:?}"
5929 );
5930 let fillwidget_entries: u32 = histogram
5931 .iter()
5932 .filter(|(k, _)| k.contains("FillWidget"))
5933 .map(|(_, v)| *v)
5934 .sum();
5935 assert!(
5936 fillwidget_entries >= 3,
5937 "expected ≥3 FillWidget instances; histogram = {histogram:?}"
5938 );
5939 assert_eq!(tree.active_widget_count() as u32, total);
5940 }
5941
5942 #[test]
5943 fn intent_source_tagged_handler_for_tap_activation() {
5944 use crate::action::Action;
5948 use crate::intent::Intent;
5949 use crate::telemetry::IntentSource;
5950 use std::cell::Cell;
5951 use std::rc::Rc;
5952 let captured = Rc::new(Cell::new(IntentSource::Unknown));
5953 let captured_for_action = captured.clone();
5954
5955 let mut tree = WidgetTree::new();
5956 let root = tree.add(FillWidget::new());
5957 let button = tree.add_child(
5958 root,
5959 FillWidget::new().on_tap(|_pos, ctx| {
5960 ctx.send_intent(Intent::new("app.save"));
5961 }),
5962 );
5963 tree.push_action(
5964 root,
5965 Action::new("app.save").on_invoke(move |intent, _c| {
5966 captured_for_action.set(intent.source);
5967 }),
5968 );
5969
5970 tree.layout(SizeProposal::exact(100.0, 50.0));
5971 tree.click(button);
5972 assert_eq!(
5973 captured.get(),
5974 IntentSource::Handler,
5975 "tap-driven intent must tag IntentSource::Handler"
5976 );
5977 }
5978
5979 #[test]
5980 fn intent_source_programmatic_when_no_handler_active() {
5981 use crate::intent::Intent;
5982 use crate::telemetry::IntentSource;
5983 let intent = Intent::new("app.demo");
5984 assert_eq!(intent.source, IntentSource::Programmatic);
5985
5986 let mut ctx = EventContext::new();
5988 ctx.send_intent(Intent::new("app.demo"));
5989 let queued = ctx.pending_intents.first().expect("intent queued");
5990 assert_eq!(queued.source, IntentSource::Programmatic);
5991 }
5992
5993 #[test]
5994 fn with_intent_source_overrides_for_managed_widgets() {
5995 use crate::intent::Intent;
5996 use crate::telemetry::IntentSource;
5997 let mut ctx = EventContext::new();
5998 ctx.with_intent_source(IntentSource::Menu, |ctx| {
5999 ctx.send_intent(Intent::new("app.demo"));
6000 });
6001 let queued = ctx.pending_intents.first().expect("intent queued");
6002 assert_eq!(
6003 queued.source,
6004 IntentSource::Menu,
6005 "with_intent_source(Menu) must tag the dispatched intent"
6006 );
6007
6008 ctx.send_intent(Intent::new("app.next"));
6012 let next = ctx.pending_intents.last().expect("second intent");
6013 assert_eq!(next.source, IntentSource::Programmatic);
6014 }
6015
6016 #[test]
6017 fn disabled_shortcut_falls_through_to_focused_widget() {
6018 use crate::action::Action;
6019 use crate::shortcut::{KeyStroke, Shortcut};
6020 use crate::signal::Signal;
6021 use std::cell::Cell;
6022 use std::rc::Rc;
6023
6024 let action_fired = Rc::new(Cell::new(false));
6025 let on_key_fired = Rc::new(Cell::new(false));
6026 let af = action_fired.clone();
6027 let kf = on_key_fired.clone();
6028
6029 let enabled = Signal::new(false);
6030
6031 let mut tree = WidgetTree::new();
6032 let widget = tree.add(FillWidget::new().focusable().on_key(move |event, _ctx| {
6033 if matches!(
6034 event,
6035 WidgetEvent::KeyDown {
6036 key: Key::S,
6037 modifiers,
6038 ..
6039 } if modifiers.command()
6040 ) {
6041 kf.set(true);
6042 return EventResponse::Handled;
6043 }
6044 EventResponse::Ignored
6045 }));
6046 tree.push_action(
6047 widget,
6048 Action::new("app.save").on_invoke(move |_i, _c| af.set(true)),
6049 );
6050 tree.shortcut_registry_mut().register(
6051 Shortcut::new("app.save")
6052 .primary(KeyStroke::command(Key::S))
6053 .enabled_when(enabled.clone())
6054 .build(),
6055 );
6056
6057 tree.layout(SizeProposal::exact(100.0, 50.0));
6058 tree.focus(widget);
6059
6060 tree.press_key(Key::S, Modifiers::COMMAND);
6062 assert!(
6063 !action_fired.get(),
6064 "disabled shortcut must not invoke its action"
6065 );
6066 assert!(
6067 on_key_fired.get(),
6068 "disabled shortcut must let KeyDown reach the focused widget"
6069 );
6070
6071 on_key_fired.set(false);
6073 enabled.set(true);
6074 tree.press_key(Key::S, Modifiers::COMMAND);
6075 assert!(action_fired.get(), "re-enabled shortcut must dispatch");
6076 assert!(
6077 !on_key_fired.get(),
6078 "enabled shortcut must consume the KeyDown"
6079 );
6080 }
6081
6082 #[test]
6083 fn keyboard_capture_bypasses_shortcut() {
6084 use crate::action::Action;
6085 use crate::shortcut::{KeyStroke, Shortcut};
6086 use std::cell::Cell;
6087 use std::rc::Rc;
6088
6089 fn run(capture: bool) -> (bool, bool) {
6095 let action_fired = Rc::new(Cell::new(false));
6096 let on_key_fired = Rc::new(Cell::new(false));
6097 let af = action_fired.clone();
6098 let kf = on_key_fired.clone();
6099
6100 let mut tree = WidgetTree::new();
6101 let widget = tree.add(
6102 FillWidget::new()
6103 .focusable()
6104 .keyboard_capture(capture)
6105 .on_key(move |event, _ctx| {
6106 if matches!(
6107 event,
6108 WidgetEvent::KeyDown { key: Key::S, modifiers, .. } if modifiers.command()
6109 ) {
6110 kf.set(true);
6111 return EventResponse::Handled;
6112 }
6113 EventResponse::Ignored
6114 }),
6115 );
6116 tree.push_action(
6117 widget,
6118 Action::new("app.save").on_invoke(move |_i, _c| af.set(true)),
6119 );
6120 tree.shortcut_registry_mut().register(
6121 Shortcut::new("app.save")
6122 .primary(KeyStroke::command(Key::S))
6123 .build(),
6124 );
6125
6126 tree.layout(SizeProposal::exact(100.0, 50.0));
6127 tree.focus(widget);
6128 tree.press_key(Key::S, Modifiers::COMMAND);
6129 (action_fired.get(), on_key_fired.get())
6130 }
6131
6132 let (action, on_key) = run(true);
6134 assert!(
6135 !action,
6136 "keyboard_capture must suppress the shortcut action"
6137 );
6138 assert!(on_key, "keyboard_capture must deliver the raw KeyDown");
6139
6140 let (action, on_key) = run(false);
6142 assert!(action, "without capture the shortcut must fire");
6143 assert!(!on_key, "without capture the widget must not see the key");
6144 }
6145
6146 fn key_recorder(
6148 tree: &mut WidgetTree,
6149 ) -> (WidgetId, std::rc::Rc<std::cell::RefCell<Vec<Key>>>) {
6150 let seen = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
6151 let log = seen.clone();
6152 let widget = tree.add(FillWidget::new().focusable().on_key(move |event, _ctx| {
6153 if let WidgetEvent::KeyDown { key, .. } = event {
6154 log.borrow_mut().push(*key);
6155 }
6156 EventResponse::Ignored
6157 }));
6158 tree.layout(SizeProposal::exact(100.0, 50.0));
6159 tree.focus(widget);
6160 (widget, seen)
6161 }
6162
6163 #[test]
6164 fn a_shortcut_no_action_takes_leaves_its_key_to_the_focused_widget() {
6165 use crate::action::Action;
6166 use crate::intent::IntentResponse;
6167 use crate::shortcut::{KeyStroke, Shortcut};
6168
6169 let mut tree = WidgetTree::new();
6170 let (widget, seen) = key_recorder(&mut tree);
6171 tree.shortcut_registry_mut().register(
6172 Shortcut::new("app.save")
6173 .primary(KeyStroke::command(Key::S))
6174 .build(),
6175 );
6176
6177 tree.press_key(Key::S, Modifiers::COMMAND);
6179 assert_eq!(
6180 *seen.borrow(),
6181 vec![Key::S],
6182 "an unhandled intent must not eat the key"
6183 );
6184
6185 tree.push_action(
6187 widget,
6188 Action::new("app.save").on_invoke_with_response(|_i, _c| IntentResponse::Propagated),
6189 );
6190 tree.press_key(Key::S, Modifiers::COMMAND);
6191 assert_eq!(
6192 seen.borrow().len(),
6193 2,
6194 "a propagated intent must leave the key too"
6195 );
6196
6197 let mut tree = WidgetTree::new();
6200 let (widget, seen) = key_recorder(&mut tree);
6201 tree.shortcut_registry_mut().register(
6202 Shortcut::new("app.save")
6203 .primary(KeyStroke::command(Key::S))
6204 .build(),
6205 );
6206 tree.push_action(widget, Action::new("app.save").on_invoke(|_i, _c| {}));
6207 tree.press_key(Key::S, Modifiers::COMMAND);
6208 assert!(
6209 seen.borrow().is_empty(),
6210 "a handled shortcut consumes its key"
6211 );
6212 }
6213
6214 #[test]
6215 fn standard_edit_chords_follow_a_rebind() {
6216 use crate::action::Action;
6217 use crate::shortcut::{KeyStroke, StandardEdit};
6218 use std::cell::Cell;
6219 use std::rc::Rc;
6220
6221 let mut tree = WidgetTree::new();
6222 let (widget, seen) = key_recorder(&mut tree);
6223 let copies = Rc::new(Cell::new(0));
6224 let count = copies.clone();
6225 tree.push_action(
6226 widget,
6227 Action::new(StandardEdit::Copy.id())
6228 .on_invoke(move |_i, _c| count.set(count.get() + 1)),
6229 );
6230
6231 tree.press_key(Key::C, Modifiers::COMMAND);
6233 assert_eq!(copies.get(), 1, "Ctrl+C reaches the edit.copy action");
6234 assert!(seen.borrow().is_empty());
6235
6236 let elsewhere = KeyStroke::new(Key::Character('à'), Modifiers::CTRL);
6239 tree.shortcut_registry_mut()
6240 .rebind_primary(StandardEdit::Copy.id(), Some(elsewhere));
6241 tree.press_key(Key::C, Modifiers::COMMAND);
6242 assert_eq!(copies.get(), 1, "the replaced chord must not copy");
6243 assert_eq!(*seen.borrow(), vec![Key::C]);
6244 tree.press_key(Key::Character('à'), Modifiers::CTRL);
6245 assert_eq!(copies.get(), 2, "the new chord copies");
6246 }
6247
6248 #[test]
6249 fn ctrl_tab_always_escapes_a_keyboard_capture_surface() {
6250 use std::cell::Cell;
6251 use std::rc::Rc;
6252
6253 let saw_key = Rc::new(Cell::new(false));
6259 let sk = saw_key.clone();
6260
6261 let mut tree = WidgetTree::new();
6262 let capture = tree.add(
6263 FillWidget::new()
6264 .focusable()
6265 .keyboard_capture(true)
6266 .on_key(move |_event, _ctx| {
6268 sk.set(true);
6269 EventResponse::Handled
6270 }),
6271 );
6272 let neighbour = tree.add(FillWidget::new().focusable());
6273 tree.layout(SizeProposal::exact(100.0, 50.0));
6274
6275 tree.focus(capture);
6278 tree.press_key(Key::Tab, Modifiers::NONE);
6279 assert!(saw_key.get(), "plain Tab must reach the capture surface");
6280 assert_eq!(
6281 tree.focused(),
6282 Some(capture),
6283 "plain Tab must not move focus off a capture surface"
6284 );
6285
6286 saw_key.set(false);
6288 tree.press_key(Key::Tab, Modifiers::CTRL);
6289 assert!(
6290 !saw_key.get(),
6291 "Ctrl+Tab is reserved and must not reach the capture surface"
6292 );
6293 assert_eq!(
6294 tree.focused(),
6295 Some(neighbour),
6296 "Ctrl+Tab must move focus out of a capture surface"
6297 );
6298
6299 tree.focus(capture);
6301 tree.press_key(Key::Tab, Modifiers::CTRL | Modifiers::SHIFT);
6302 assert_eq!(
6303 tree.focused(),
6304 Some(neighbour),
6305 "Ctrl+Shift+Tab must move focus out of a capture surface"
6306 );
6307 }
6308
6309 #[test]
6310 fn scope_mismatch_does_not_invoke_on_activate() {
6311 use crate::intent::Intent;
6312 use crate::shortcut::{KeyStroke, Shortcut, ShortcutScope};
6313 use std::cell::Cell;
6314 use std::rc::Rc;
6315
6316 let activated = Rc::new(Cell::new(false));
6322 let activated_flag = activated.clone();
6323
6324 let mut tree = WidgetTree::new();
6325 let scope_root = tree.add(FillWidget::new().focusable());
6326 let outside = tree.add(FillWidget::new().focusable());
6327
6328 tree.shortcut_registry_mut().register(
6329 Shortcut::new("editor.find")
6330 .primary(KeyStroke::command(Key::F))
6331 .scope(ShortcutScope::Scoped(scope_root))
6332 .on_activate(move |_ks, _ctx| {
6333 activated_flag.set(true);
6334 Intent::new("editor.find")
6335 })
6336 .build(),
6337 );
6338
6339 tree.layout(SizeProposal::exact(200.0, 100.0));
6340 tree.focus(outside);
6341
6342 tree.press_key(Key::F, Modifiers::COMMAND);
6343 assert!(
6344 !activated.get(),
6345 "on_activate must not run when focus is outside the shortcut's scope"
6346 );
6347 }
6348
6349 #[test]
6350 fn key_capture_runs_callback_and_bypasses_registry() {
6351 use crate::action::Action;
6352 use crate::shortcut::{KeyStroke, Shortcut};
6353 use std::cell::Cell;
6354 use std::rc::Rc;
6355
6356 let action_fired = Rc::new(Cell::new(false));
6357 let af = action_fired.clone();
6358 let captured = Rc::new(Cell::new(None));
6359 let cf = captured.clone();
6360
6361 let mut tree = WidgetTree::new();
6362 let widget = tree.add(FillWidget::new().focusable());
6363 tree.push_action(
6364 widget,
6365 Action::new("app.save").on_invoke(move |_i, _c| af.set(true)),
6366 );
6367 tree.shortcut_registry_mut().register(
6368 Shortcut::new("app.save")
6369 .primary(KeyStroke::command(Key::S))
6370 .build(),
6371 );
6372
6373 tree.layout(SizeProposal::exact(100.0, 50.0));
6374 tree.focus(widget);
6375
6376 let handle = tree.begin_key_capture(move |ks, _reg, _ctx| cf.set(Some(ks)));
6377 assert!(tree.is_capturing_keys());
6378
6379 tree.press_key(Key::S, Modifiers::COMMAND);
6380 assert_eq!(
6381 captured.get(),
6382 Some(KeyStroke::command(Key::S)),
6383 "capture callback must receive the chord"
6384 );
6385 assert!(
6386 !action_fired.get(),
6387 "shortcut action must not fire while capture is armed"
6388 );
6389 assert!(
6390 !tree.is_capturing_keys(),
6391 "capture is one-shot; next KeyDown flows normally"
6392 );
6393 drop(handle);
6394 }
6395
6396 #[test]
6397 fn key_capture_can_rebind_through_registry() {
6398 use crate::shortcut::{KeyStroke, Shortcut};
6399
6400 let mut tree = WidgetTree::new();
6401 let widget = tree.add(FillWidget::new().focusable());
6402 tree.shortcut_registry_mut().register(
6403 Shortcut::new("app.save")
6404 .primary(KeyStroke::command(Key::S))
6405 .build(),
6406 );
6407
6408 tree.layout(SizeProposal::exact(100.0, 50.0));
6409 tree.focus(widget);
6410
6411 let _h = tree.begin_key_capture(|ks, reg, _ctx| {
6413 reg.rebind_primary("app.save", Some(ks));
6414 });
6415
6416 tree.press_key(Key::B, Modifiers::COMMAND | Modifiers::SHIFT);
6417 assert_eq!(
6418 tree.shortcut_registry()
6419 .effective("app.save")
6420 .unwrap()
6421 .primary,
6422 Some(KeyStroke::command_shift(Key::B))
6423 );
6424 }
6425
6426 #[test]
6427 fn dropping_capture_handle_cancels_capture() {
6428 use crate::shortcut::{KeyStroke, Shortcut};
6429 use std::cell::Cell;
6430 use std::rc::Rc;
6431
6432 let action_fired = Rc::new(Cell::new(false));
6433 let af = action_fired.clone();
6434 let capture_fired = Rc::new(Cell::new(false));
6435 let cf = capture_fired.clone();
6436
6437 let mut tree = WidgetTree::new();
6438 let widget = tree.add(FillWidget::new().focusable());
6439 tree.push_action(
6440 widget,
6441 crate::action::Action::new("app.save").on_invoke(move |_i, _c| af.set(true)),
6442 );
6443 tree.shortcut_registry_mut().register(
6444 Shortcut::new("app.save")
6445 .primary(KeyStroke::command(Key::S))
6446 .build(),
6447 );
6448 tree.layout(SizeProposal::exact(100.0, 50.0));
6449 tree.focus(widget);
6450
6451 {
6455 let _h = tree.begin_key_capture(move |_ks, _reg, _ctx| cf.set(true));
6456 assert!(tree.is_capturing_keys());
6457 }
6459 assert!(
6460 !tree.is_capturing_keys(),
6461 "dropping the handle must cancel the capture"
6462 );
6463
6464 tree.press_key(Key::S, Modifiers::COMMAND);
6465 assert!(!capture_fired.get(), "cancelled capture must not fire");
6466 assert!(
6467 action_fired.get(),
6468 "shortcut action runs after capture was cancelled"
6469 );
6470 }
6471
6472 #[test]
6473 fn second_begin_key_capture_does_not_racecancel_first() {
6474 use std::cell::Cell;
6475 use std::rc::Rc;
6476
6477 let first = Rc::new(Cell::new(false));
6478 let second = Rc::new(Cell::new(false));
6479 let f = first.clone();
6480 let s = second.clone();
6481
6482 let mut tree = WidgetTree::new();
6483 let widget = tree.add(FillWidget::new().focusable());
6484 tree.layout(SizeProposal::exact(100.0, 50.0));
6485 tree.focus(widget);
6486
6487 let h1 = tree.begin_key_capture(move |_ks, _reg, _ctx| f.set(true));
6493 let _h2 = tree.begin_key_capture(move |_ks, _reg, _ctx| s.set(true));
6494 drop(h1);
6495
6496 assert!(
6497 tree.is_capturing_keys(),
6498 "dropping the older handle must not cancel the active capture"
6499 );
6500 tree.press_key(Key::K, Modifiers::COMMAND);
6501 assert!(!first.get());
6502 assert!(second.get(), "newest capture wins");
6503 }
6504
6505 #[test]
6506 fn capture_callback_can_send_intent() {
6507 use crate::action::Action;
6508 use crate::intent::Intent;
6509
6510 use std::cell::Cell;
6511 use std::rc::Rc;
6512
6513 let ran = Rc::new(Cell::new(false));
6514 let flag = ran.clone();
6515
6516 let mut tree = WidgetTree::new();
6517 let widget = tree.add(FillWidget::new().focusable());
6518 tree.push_action(
6519 widget,
6520 Action::new("app.save").on_invoke(move |_i, _c| flag.set(true)),
6521 );
6522 tree.layout(SizeProposal::exact(100.0, 50.0));
6523 tree.focus(widget);
6524
6525 let _h = tree.begin_key_capture(|_ks, _reg, ctx| {
6526 ctx.send_intent(Intent::new("app.save"));
6527 });
6528 tree.press_key(Key::X, Modifiers::COMMAND);
6529 assert!(
6530 ran.get(),
6531 "intent queued from capture callback must dispatch"
6532 );
6533 }
6534
6535 #[test]
6536 fn binding_registry_does_not_accumulate_across_rebuilds() {
6537 use crate::binding::BindingLevel;
6538 use crate::signal::Signal;
6539
6540 #[derive(Debug)]
6541 struct BoundLeaf {
6542 tick: Signal<u64>,
6543 }
6544 impl crate::widget::Widget for BoundLeaf {
6545 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
6546 self.tick.bind_to(
6547 ctx.self_id(),
6548 ctx.binding_registry(),
6549 BindingLevel::Relayout,
6550 );
6551 Vec::new()
6552 }
6553 fn layout_response(
6554 &self,
6555 proposal: SizeProposal,
6556 _ctx: &crate::widget::LayoutContext,
6557 ) -> crate::widget::LayoutResponse {
6558 proposal.resolve(10.0, 10.0).into()
6559 }
6560 }
6561
6562 let mut tree = WidgetTree::new();
6563 let tick = Signal::new(0_u64);
6564 let widget = tree.add(BoundLeaf { tick: tick.clone() });
6565 tree.layout(SizeProposal::exact(200.0, 200.0));
6566 let after_first_build = tree.binding_registry().len();
6567 assert!(after_first_build >= 1);
6568
6569 for _ in 0..5 {
6573 tree.arena.mark_needs_rebuild(widget);
6574 tree.layout(SizeProposal::exact(200.0, 200.0));
6575 }
6576 assert_eq!(
6577 tree.binding_registry().len(),
6578 after_first_build,
6579 "bindings must be cleared on rebuild"
6580 );
6581
6582 tree.destroy_subtree(widget);
6583 assert_eq!(
6584 tree.binding_registry().len(),
6585 0,
6586 "bindings must be cleared on destroy"
6587 );
6588 let _ = tick;
6590 }
6591
6592 #[test]
6593 fn ctx_destroy_cancels_animations_and_bindings_via_deferred_path() {
6594 use crate::binding::BindingLevel;
6602 use crate::signal::Signal;
6603 use std::time::{Duration, Instant};
6604 use teksilo_tokens::Easing;
6605
6606 #[derive(Debug)]
6607 struct BoundLeaf {
6608 tick: Signal<u64>,
6609 }
6610 impl crate::widget::Widget for BoundLeaf {
6611 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
6612 self.tick.bind_to(
6613 ctx.self_id(),
6614 ctx.binding_registry(),
6615 BindingLevel::Relayout,
6616 );
6617 Vec::new()
6618 }
6619 fn layout_response(
6620 &self,
6621 proposal: SizeProposal,
6622 _ctx: &crate::widget::LayoutContext,
6623 ) -> crate::widget::LayoutResponse {
6624 proposal.resolve(10.0, 10.0).into()
6625 }
6626 }
6627
6628 let mut tree = WidgetTree::new();
6629 let widget = tree.add(BoundLeaf {
6630 tick: Signal::new(0_u64),
6631 });
6632 tree.layout(SizeProposal::exact(200.0, 200.0));
6633 assert!(tree.binding_registry().len() >= 1);
6634
6635 let anim = Signal::<f32>::new_animated(0.0);
6638 tree.animation_scheduler.animate(
6639 &anim,
6640 widget,
6641 1.0,
6642 Duration::from_secs(10),
6643 Easing::Linear,
6644 Instant::now(),
6645 );
6646 assert_eq!(tree.animation_scheduler.active_count(), 1);
6647
6648 let mut noop = crate::window::NoopWindowOps;
6650 tree.run_with_event_context(&mut noop, |ctx| ctx.destroy(widget));
6651
6652 assert_eq!(
6653 tree.animation_scheduler.active_count(),
6654 0,
6655 "ctx.destroy must cancel animations owned by the destroyed widget"
6656 );
6657 assert_eq!(
6658 tree.binding_registry().len(),
6659 0,
6660 "ctx.destroy must unregister the destroyed widget's bindings"
6661 );
6662 assert!(
6663 tree.arena.get(widget).is_none(),
6664 "node must be removed from the arena"
6665 );
6666 }
6667
6668 #[test]
6669 fn clear_shortcut_override_via_event_context_restores_default() {
6670 use crate::shortcut::{KeyStroke, Shortcut};
6671
6672 let mut tree = WidgetTree::new();
6673 tree.shortcut_registry_mut().register(
6674 Shortcut::new("app.save")
6675 .primary(KeyStroke::command(Key::S))
6676 .build(),
6677 );
6678 tree.shortcut_registry_mut()
6679 .rebind_primary("app.save", Some(KeyStroke::alt(Key::S)));
6680
6681 let source = tree.add(FillWidget::new());
6682 let mut ctx = EventContext::new();
6683 ctx.clear_shortcut_override("app.save");
6684 tree.collect_from_ctx(ctx, source);
6685
6686 assert_eq!(
6687 tree.shortcut_registry()
6688 .effective("app.save")
6689 .unwrap()
6690 .primary,
6691 Some(KeyStroke::command(Key::S))
6692 );
6693 }
6694
6695 #[test]
6696 fn rebind_shortcut_primary_via_event_context() {
6697 use crate::shortcut::{KeyStroke, Shortcut};
6698
6699 let mut tree = WidgetTree::new();
6700 tree.shortcut_registry_mut().register(
6701 Shortcut::new("app.save")
6702 .primary(KeyStroke::command(Key::S))
6703 .build(),
6704 );
6705 let source = tree.add(FillWidget::new());
6706
6707 let mut ctx = EventContext::new();
6708 ctx.rebind_shortcut_primary("app.save", Some(KeyStroke::alt(Key::S)));
6709 tree.collect_from_ctx(ctx, source);
6710
6711 assert_eq!(
6712 tree.shortcut_registry()
6713 .effective("app.save")
6714 .unwrap()
6715 .primary,
6716 Some(KeyStroke::alt(Key::S))
6717 );
6718 }
6719
6720 #[test]
6721 fn unregister_all_for_owner_called_on_destroy() {
6722 use crate::shortcut::{KeyStroke, Shortcut};
6723
6724 let mut tree = WidgetTree::new();
6725 let widget = tree.add(FillWidget::new());
6726 let widget_owner = widget;
6727 tree.shortcut_registry_mut().register_owned(
6728 Shortcut::new("scoped.thing")
6729 .primary(KeyStroke::command(Key::K))
6730 .build(),
6731 widget_owner,
6732 );
6733 assert!(
6734 tree.shortcut_registry()
6735 .get_default("scoped.thing")
6736 .is_some()
6737 );
6738
6739 tree.destroy_subtree(widget);
6740 assert!(
6741 tree.shortcut_registry()
6742 .get_default("scoped.thing")
6743 .is_none(),
6744 "destroying the owner must unregister its shortcut"
6745 );
6746 }
6747
6748 #[test]
6752 fn global_action_reached_from_unrelated_source() {
6753 use crate::action::Action;
6754 use crate::intent::Intent;
6755 use std::cell::Cell;
6756 use std::rc::Rc;
6757
6758 #[derive(Debug)]
6759 struct Registrar(Rc<Cell<bool>>);
6760 impl crate::widget::Widget for Registrar {
6761 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
6762 let flag = self.0.clone();
6763 ctx.register_action_global(
6764 Action::new("test.global").on_invoke(move |_i, _c| flag.set(true)),
6765 );
6766 vec![]
6767 }
6768 fn layout_response(
6769 &self,
6770 _p: teksilo_canvas::SizeProposal,
6771 _c: &crate::widget::LayoutContext,
6772 ) -> crate::widget::LayoutResponse {
6773 teksilo_canvas::Size::new(0.0, 0.0).into()
6774 }
6775 }
6776
6777 let mut tree = WidgetTree::new();
6778 let fired = Rc::new(Cell::new(false));
6779 let registrar = tree.add(Registrar(fired.clone()));
6780 let source = tree.add(FillWidget::new()); let mut ops = crate::window::NoopWindowOps;
6782
6783 tree.dispatch_intent(source, Intent::new("test.global"), true, &mut ops);
6784 assert!(
6785 fired.get(),
6786 "global action must fire from an unrelated source"
6787 );
6788
6789 fired.set(false);
6791 tree.destroy_subtree(registrar);
6792 tree.dispatch_intent(source, Intent::new("test.global"), true, &mut ops);
6793 assert!(
6794 !fired.get(),
6795 "destroying the owner must remove its global action"
6796 );
6797 }
6798
6799 #[test]
6811 fn hit_test_through_translate_scope() {
6812 use crate::test_widgets::StackWidget;
6813 let mut tree = WidgetTree::new();
6814 let child = tree.add(FillWidget::new());
6815 let parent = tree.add(StackWidget::new().child(child));
6816 tree.set_transform(parent, teksilo_canvas::Transform2D::translate(100.0, 0.0));
6818 tree.layout(SizeProposal::exact(100.0, 50.0));
6819
6820 assert_eq!(
6824 tree.hit_test(Point::new(50.0, 25.0)),
6825 None,
6826 "pre-transform area is not visually populated and must not hit"
6827 );
6828 assert_eq!(
6830 tree.hit_test(Point::new(150.0, 25.0)),
6831 Some(child),
6832 "visually-rendered area must hit the child"
6833 );
6834 assert_eq!(tree.hit_test(Point::new(250.0, 25.0)), None);
6836 }
6837
6838 #[test]
6839 fn hit_test_through_scale_scope() {
6840 use crate::test_widgets::StackWidget;
6841 let mut tree = WidgetTree::new();
6842 let child = tree.add(FillWidget::new());
6843 let parent = tree.add(StackWidget::new().child(child));
6844 tree.set_transform(parent, teksilo_canvas::Transform2D::scale(0.5, 0.5));
6847 tree.layout(SizeProposal::exact(100.0, 50.0));
6848
6849 assert_eq!(tree.hit_test(Point::new(25.0, 12.0)), Some(child));
6851 assert_eq!(
6854 tree.hit_test(Point::new(75.0, 25.0)),
6855 None,
6856 "scaled-out region must not hit"
6857 );
6858 }
6859
6860 #[test]
6861 fn hit_test_through_nested_transforms_compose() {
6862 use crate::test_widgets::StackWidget;
6863 let mut tree = WidgetTree::new();
6864 let leaf = tree.add(FillWidget::new());
6865 let inner = tree.add(StackWidget::new().child(leaf));
6866 let outer = tree.add(StackWidget::new().child(inner));
6867 tree.set_transform(outer, teksilo_canvas::Transform2D::translate(100.0, 0.0));
6871 tree.set_transform(inner, teksilo_canvas::Transform2D::scale(2.0, 2.0));
6872 tree.layout(SizeProposal::exact(50.0, 25.0));
6873
6874 assert_eq!(tree.hit_test(Point::new(150.0, 25.0)), Some(leaf));
6878 assert_eq!(tree.hit_test(Point::new(50.0, 25.0)), None);
6879 assert_eq!(tree.hit_test(Point::new(250.0, 25.0)), None);
6880 }
6881
6882 #[test]
6883 fn hit_test_identity_transform_unchanged() {
6884 let mut tree = WidgetTree::new();
6888 let widget = tree.add(FillWidget::new());
6889 tree.set_transform(widget, teksilo_canvas::Transform2D::IDENTITY);
6890 tree.layout(SizeProposal::exact(100.0, 50.0));
6891 assert_eq!(tree.hit_test(Point::new(50.0, 25.0)), Some(widget));
6892 }
6893
6894 #[test]
6895 fn arena_effective_transform_composes_ancestors() {
6896 use crate::test_widgets::StackWidget;
6907 let mut tree = WidgetTree::new();
6908 let leaf = tree.add(FillWidget::new());
6909 let inner = tree.add(StackWidget::new().child(leaf));
6910 let outer = tree.add(StackWidget::new().child(inner));
6911 tree.set_transform(outer, teksilo_canvas::Transform2D::translate(100.0, 0.0));
6912 tree.set_transform(inner, teksilo_canvas::Transform2D::scale(2.0, 2.0));
6913 tree.layout(SizeProposal::exact(50.0, 25.0));
6914
6915 let eff = tree.arena.effective_transform(leaf);
6916 let expected = teksilo_canvas::Transform2D::scale(2.0, 2.0)
6917 .then(&teksilo_canvas::Transform2D::translate(100.0, 0.0));
6918 for (a, b) in eff.m.iter().zip(expected.m.iter()) {
6919 assert!(
6920 (a - b).abs() < 1e-5,
6921 "effective_transform mismatch: got {:?}, want {:?}",
6922 eff.m,
6923 expected.m
6924 );
6925 }
6926
6927 let screen_origin = eff.apply_point(Point::new(0.0, 0.0));
6933 assert!((screen_origin.x - 100.0).abs() < 1e-5);
6934 assert!((screen_origin.y - 0.0).abs() < 1e-5);
6935 let screen_corner = eff.apply_point(Point::new(50.0, 25.0));
6938 assert!((screen_corner.x - 200.0).abs() < 1e-5);
6939 assert!((screen_corner.y - 50.0).abs() < 1e-5);
6940 }
6941
6942 #[derive(Debug)]
6947 struct StubMenu;
6948 impl crate::widget::Widget for StubMenu {
6949 fn layout_response(
6950 &self,
6951 _proposal: SizeProposal,
6952 _ctx: &crate::widget::LayoutContext,
6953 ) -> crate::widget::LayoutResponse {
6954 teksilo_canvas::Size::new(100.0, 40.0).into()
6955 }
6956 }
6957
6958 #[derive(Debug)]
6970 struct NominatingWidget {
6971 row: std::cell::Cell<Option<WidgetId>>,
6972 }
6973
6974 impl crate::widget::Widget for NominatingWidget {
6975 fn layout_response(
6976 &self,
6977 proposal: SizeProposal,
6978 _ctx: &LayoutContext,
6979 ) -> crate::widget::LayoutResponse {
6980 proposal.resolve(50.0, 20.0).into()
6981 }
6982
6983 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
6984 ctx.apply_self_handlers(crate::widget_builder::HandlerSet::new().focusable(true));
6985 Vec::new()
6986 }
6987
6988 fn context_menu_key_target(&self) -> Option<WidgetId> {
6989 self.row.get()
6990 }
6991 }
6992
6993 fn press(tree: &mut WidgetTree, key: Key, modifiers: Modifiers) {
6994 tree.dispatch_event(WidgetEvent::KeyDown {
6995 key,
6996 modifiers,
6997 text: None,
6998 });
6999 }
7000
7001 #[test]
7002 fn the_context_menu_key_opens_the_focused_widget_menu() {
7003 use std::cell::Cell;
7004 use std::rc::Rc;
7005
7006 let opened = Rc::new(Cell::new(false));
7007 let flag = opened.clone();
7008 let mut tree = WidgetTree::new();
7009 let widget = tree.add(
7010 FillWidget::new()
7011 .focusable()
7012 .context_menu(move |_pos, _ctx| {
7013 flag.set(true);
7014 Some(Box::new(StubMenu) as Box<dyn crate::widget::Widget>)
7015 }),
7016 );
7017 tree.layout(SizeProposal::exact(200.0, 100.0));
7018 tree.focus(widget);
7019
7020 press(&mut tree, Key::ContextMenu, Modifiers::NONE);
7021 assert!(opened.get(), "the dedicated Menu key must open the menu");
7022 }
7023
7024 #[test]
7027 fn shift_f10_opens_the_focused_widget_menu() {
7028 use std::cell::Cell;
7029 use std::rc::Rc;
7030
7031 let opened = Rc::new(Cell::new(false));
7032 let flag = opened.clone();
7033 let mut tree = WidgetTree::new();
7034 let widget = tree.add(
7035 FillWidget::new()
7036 .focusable()
7037 .context_menu(move |_pos, _ctx| {
7038 flag.set(true);
7039 Some(Box::new(StubMenu) as Box<dyn crate::widget::Widget>)
7040 }),
7041 );
7042 tree.layout(SizeProposal::exact(200.0, 100.0));
7043 tree.focus(widget);
7044
7045 press(&mut tree, Key::F10, Modifiers::SHIFT);
7046 assert!(opened.get(), "Shift+F10 must open the menu");
7047 }
7048
7049 #[test]
7052 fn a_near_miss_chord_is_not_a_context_menu_request() {
7053 use std::cell::Cell;
7054 use std::rc::Rc;
7055
7056 let opened = Rc::new(Cell::new(false));
7057 let flag = opened.clone();
7058 let mut tree = WidgetTree::new();
7059 let widget = tree.add(
7060 FillWidget::new()
7061 .focusable()
7062 .context_menu(move |_pos, _ctx| {
7063 flag.set(true);
7064 Some(Box::new(StubMenu) as Box<dyn crate::widget::Widget>)
7065 }),
7066 );
7067 tree.layout(SizeProposal::exact(200.0, 100.0));
7068 tree.focus(widget);
7069
7070 press(&mut tree, Key::F10, Modifiers::SHIFT | Modifiers::CTRL);
7071 press(&mut tree, Key::F10, Modifiers::NONE);
7072 assert!(!opened.get(), "only Shift+F10 exactly asks for a menu");
7073 }
7074
7075 #[test]
7079 fn the_keyboard_target_can_be_a_row_rather_than_the_focused_container() {
7080 use std::cell::Cell;
7081 use std::rc::Rc;
7082
7083 let menu_owner = Rc::new(Cell::new(None::<&'static str>));
7084
7085 let row_flag = menu_owner.clone();
7086 let container_flag = menu_owner.clone();
7087
7088 let mut tree = WidgetTree::new();
7089 let row = tree.add(FillWidget::new().context_menu(move |_pos, _ctx| {
7090 row_flag.set(Some("row"));
7091 Some(Box::new(StubMenu) as Box<dyn crate::widget::Widget>)
7092 }));
7093 let container = tree.add(
7094 crate::test_widgets::StackWidget::new()
7095 .child(row)
7096 .context_menu(move |_pos, _ctx| {
7097 container_flag.set(Some("container"));
7098 Some(Box::new(StubMenu) as Box<dyn crate::widget::Widget>)
7099 }),
7100 );
7101 tree.layout(SizeProposal::exact(200.0, 100.0));
7102
7103 let nominator = tree.add(NominatingWidget {
7105 row: std::cell::Cell::new(Some(row)),
7106 });
7107 tree.layout(SizeProposal::exact(200.0, 100.0));
7108 tree.focus(nominator);
7109 let _ = container;
7110
7111 press(&mut tree, Key::ContextMenu, Modifiers::NONE);
7112 assert_eq!(
7113 menu_owner.get(),
7114 Some("row"),
7115 "the nominated row's factory must be the one that runs"
7116 );
7117 }
7118
7119 #[test]
7122 fn the_chord_falls_through_when_there_is_no_menu_to_show() {
7123 use std::cell::Cell;
7124 use std::rc::Rc;
7125
7126 let saw_key = Rc::new(Cell::new(false));
7127 let flag = saw_key.clone();
7128 let mut tree = WidgetTree::new();
7129 let widget = tree.add(FillWidget::new().focusable().on_key(move |ev, _ctx| {
7130 if matches!(ev, WidgetEvent::KeyDown { key: Key::F10, .. }) {
7131 flag.set(true);
7132 }
7133 crate::event::EventResponse::Ignored
7134 }));
7135 tree.layout(SizeProposal::exact(200.0, 100.0));
7136 tree.focus(widget);
7137
7138 press(&mut tree, Key::F10, Modifiers::SHIFT);
7139 assert!(
7140 saw_key.get(),
7141 "with no factory anywhere, the key must reach the widget"
7142 );
7143 }
7144
7145 #[test]
7151 fn each_route_to_a_menu_tells_the_factory_what_asked_for_it() {
7152 use crate::widget_builder::ContextMenuTrigger;
7153 use std::cell::RefCell;
7154 use std::rc::Rc;
7155
7156 let seen = Rc::new(RefCell::new(Vec::new()));
7157 let log = seen.clone();
7158 let mut tree = WidgetTree::new();
7159 let widget = tree.add(
7160 FillWidget::new()
7161 .focusable()
7162 .context_menu(move |_pos, ctx| {
7163 log.borrow_mut().push(ctx.context_menu_trigger());
7164 Some(Box::new(StubMenu) as Box<dyn crate::widget::Widget>)
7165 }),
7166 );
7167 tree.layout(SizeProposal::exact(200.0, 100.0));
7168 tree.focus(widget);
7169 let inside = tree.bounds(widget).center();
7170
7171 press(&mut tree, Key::F10, Modifiers::SHIFT);
7172 press(&mut tree, Key::Escape, Modifiers::NONE);
7173 press(&mut tree, Key::ContextMenu, Modifiers::NONE);
7174 press(&mut tree, Key::Escape, Modifiers::NONE);
7175 tree.dispatch_event(WidgetEvent::pointer_down(
7176 inside,
7177 crate::event::PointerButton::Secondary,
7178 Modifiers::NONE,
7179 ));
7180 tree.dispatch_event(WidgetEvent::pointer_up(
7181 inside,
7182 crate::event::PointerButton::Secondary,
7183 Modifiers::NONE,
7184 ));
7185 press(&mut tree, Key::Escape, Modifiers::NONE);
7186 tree.dispatch_event(WidgetEvent::AccessAction {
7187 action: accesskit::Action::ShowContextMenu,
7188 target: Some(widget),
7189 target_node: crate::accessibility::widget_id_to_node_id(widget),
7190 data: None,
7191 });
7192 press(&mut tree, Key::Escape, Modifiers::NONE);
7193 tree.long_press_at(teksilo_tokens::PointerKind::Touch, inside);
7194
7195 assert_eq!(
7196 *seen.borrow(),
7197 vec![
7198 Some(ContextMenuTrigger::Keyboard),
7199 Some(ContextMenuTrigger::Keyboard),
7200 Some(ContextMenuTrigger::Pointer),
7201 Some(ContextMenuTrigger::Accessibility),
7202 Some(ContextMenuTrigger::Pointer),
7203 ],
7204 "Shift+F10, the Menu key, a right-click, the assistive action and a \
7205 hold, in that order"
7206 );
7207 }
7208
7209 #[test]
7210 fn context_menu_factory_receives_click_position() {
7211 use crate::event::{Modifiers, PointerButton};
7212 use std::cell::Cell;
7213 use std::rc::Rc;
7214
7215 let captured_position = Rc::new(Cell::new(None::<Point>));
7216 let cap = captured_position.clone();
7217 let mut tree = WidgetTree::new();
7218 let widget = tree.add(FillWidget::new().context_menu(move |pos, _ctx| {
7219 cap.set(Some(pos));
7220 Some(Box::new(StubMenu) as Box<dyn crate::widget::Widget>)
7221 }));
7222 tree.layout(SizeProposal::exact(200.0, 100.0));
7223
7224 let click = Point::new(73.0, 42.0);
7225 tree.dispatch_event(WidgetEvent::pointer_down(
7226 click,
7227 PointerButton::Secondary,
7228 Modifiers::NONE,
7229 ));
7230
7231 let got = captured_position.get();
7232 assert_eq!(
7233 got,
7234 Some(click),
7235 "factory must receive the click position; got {:?}",
7236 got
7237 );
7238 let _ = widget;
7239 }
7240
7241 #[test]
7242 fn context_menu_factory_returning_none_falls_through_to_parent() {
7243 use crate::event::{Modifiers, PointerButton};
7244 use crate::test_widgets::StackWidget;
7245 use std::cell::Cell;
7246 use std::rc::Rc;
7247
7248 let outer_called = Rc::new(Cell::new(0_u32));
7252 let outer_flag = outer_called.clone();
7253 let mut tree = WidgetTree::new();
7254 let inner = tree.add(FillWidget::new().context_menu(|_pos, _ctx| None));
7255 let _outer = tree.add(
7256 StackWidget::new()
7257 .child(inner)
7258 .context_menu(move |_pos, _ctx| {
7259 outer_flag.set(outer_flag.get() + 1);
7260 Some(Box::new(StubMenu) as Box<dyn crate::widget::Widget>)
7261 }),
7262 );
7263 tree.layout(SizeProposal::exact(200.0, 100.0));
7264
7265 tree.dispatch_event(WidgetEvent::pointer_down(
7266 Point::new(50.0, 25.0),
7267 PointerButton::Secondary,
7268 Modifiers::NONE,
7269 ));
7270
7271 assert_eq!(
7272 outer_called.get(),
7273 1,
7274 "inner returning None must fall through to the outer factory"
7275 );
7276 }
7277
7278 #[test]
7279 fn context_menu_factory_none_throughout_chain_does_not_show_overlay() {
7280 use crate::event::{Modifiers, PointerButton};
7281
7282 let mut tree = WidgetTree::new();
7284 tree.add(FillWidget::new().context_menu(|_pos, _ctx| None));
7285 tree.layout(SizeProposal::exact(200.0, 100.0));
7286
7287 let overlay_count_before = tree.overlay_manager.len();
7288 tree.dispatch_event(WidgetEvent::pointer_down(
7289 Point::new(50.0, 25.0),
7290 PointerButton::Secondary,
7291 Modifiers::NONE,
7292 ));
7293 let overlay_count_after = tree.overlay_manager.len();
7294 assert_eq!(
7295 overlay_count_before, overlay_count_after,
7296 "a factory returning None must not mount any overlay"
7297 );
7298 }
7299
7300 #[derive(Debug)]
7311 struct FreshChildHost {
7312 preserve: bool,
7313 }
7314 impl Widget for FreshChildHost {
7315 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
7316 vec![ctx.add(FillWidget::new())]
7317 }
7318 fn layout_response(
7319 &self,
7320 p: SizeProposal,
7321 _c: &LayoutContext,
7322 ) -> crate::widget::LayoutResponse {
7323 p.resolve(10.0, 10.0).into()
7324 }
7325 fn preserves_children_on_rebuild(&self) -> bool {
7326 self.preserve
7327 }
7328 }
7329
7330 #[test]
7331 fn reconcile_reaps_dropped_children_no_leak() {
7332 for preserve in [false, true] {
7337 let mut tree = WidgetTree::new();
7338 let host = tree.add(FreshChildHost { preserve });
7339 tree.layout(SizeProposal::exact(100.0, 100.0));
7340 let total0 = tree.arena.len();
7341 let active0 = tree.active_widget_count();
7342 for _ in 0..5 {
7343 tree.arena_mark_needs_rebuild_for_testing(host);
7344 tree.layout(SizeProposal::exact(100.0, 100.0));
7345 }
7346 assert_eq!(
7347 tree.arena.len(),
7348 total0,
7349 "preserve={preserve}: dropped children must be reaped, not leaked"
7350 );
7351 assert_eq!(
7352 tree.active_widget_count(),
7353 active0,
7354 "preserve={preserve}: no stranded still-active orphans"
7355 );
7356 }
7357 }
7358
7359 #[derive(Debug)]
7365 struct DetachedContentHost {
7366 preserve: bool,
7367 }
7368 impl Widget for DetachedContentHost {
7369 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
7370 let popup = ctx.add_detached(FillWidget::new());
7371 ctx.set_dormant(popup);
7372 vec![ctx.add(FillWidget::new())]
7373 }
7374 fn layout_response(
7375 &self,
7376 p: SizeProposal,
7377 _c: &LayoutContext,
7378 ) -> crate::widget::LayoutResponse {
7379 p.resolve(10.0, 10.0).into()
7380 }
7381 fn preserves_children_on_rebuild(&self) -> bool {
7382 self.preserve
7383 }
7384 }
7385
7386 #[test]
7387 fn rebuilding_reaps_detached_content_no_leak() {
7388 for preserve in [false, true] {
7394 let mut tree = WidgetTree::new();
7395 let host = tree.add(DetachedContentHost { preserve });
7396 tree.layout(SizeProposal::exact(100.0, 100.0));
7397 let total0 = tree.arena.len();
7398 for _ in 0..5 {
7399 tree.arena_mark_needs_rebuild_for_testing(host);
7400 tree.layout(SizeProposal::exact(100.0, 100.0));
7401 }
7402 assert_eq!(
7403 tree.arena.len(),
7404 total0,
7405 "preserve={preserve}: the previous build's detached content must be reaped"
7406 );
7407 }
7408 }
7409
7410 #[test]
7411 fn destroying_a_host_reaps_its_detached_content() {
7412 let mut tree = WidgetTree::new();
7413 let outer = tree.add(FillWidget::new());
7414 tree.layout(SizeProposal::exact(100.0, 100.0));
7415 let empty = tree.arena.len();
7416
7417 let host = tree.add_child(outer, DetachedContentHost { preserve: false });
7418 tree.layout(SizeProposal::exact(100.0, 100.0));
7419 assert!(tree.arena.len() > empty);
7420
7421 tree.destroy_subtree(host);
7422 assert_eq!(
7423 tree.arena.len(),
7424 empty,
7425 "the popup must die with the widget that built it"
7426 );
7427 }
7428
7429 #[derive(Debug)]
7431 struct StableChildHost {
7432 child: Option<WidgetId>,
7433 probe: std::rc::Rc<std::cell::Cell<Option<WidgetId>>>,
7434 }
7435 impl Widget for StableChildHost {
7436 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
7437 let id = match self.child {
7438 Some(id) => id,
7439 None => {
7440 let id = ctx.add(FillWidget::new());
7441 self.child = Some(id);
7442 self.probe.set(Some(id));
7443 id
7444 }
7445 };
7446 vec![id]
7447 }
7448 fn layout_response(
7449 &self,
7450 p: SizeProposal,
7451 _c: &LayoutContext,
7452 ) -> crate::widget::LayoutResponse {
7453 p.resolve(10.0, 10.0).into()
7454 }
7455 fn preserves_children_on_rebuild(&self) -> bool {
7456 true
7457 }
7458 }
7459
7460 #[test]
7461 fn reconcile_preserves_reattached_child() {
7462 let probe = std::rc::Rc::new(std::cell::Cell::new(None));
7463 let mut tree = WidgetTree::new();
7464 let host = tree.add(StableChildHost {
7465 child: None,
7466 probe: probe.clone(),
7467 });
7468 tree.layout(SizeProposal::exact(100.0, 100.0));
7469 let child = probe.get().expect("child mounted");
7470 let total0 = tree.arena.len();
7471 for _ in 0..5 {
7472 tree.arena_mark_needs_rebuild_for_testing(host);
7473 tree.layout(SizeProposal::exact(100.0, 100.0));
7474 }
7475 assert!(
7476 tree.arena.is_active(child),
7477 "the re-attached child must survive every rebuild"
7478 );
7479 assert_eq!(tree.arena.len(), total0, "no growth — same child reused");
7480 }
7481
7482 #[derive(Debug)]
7484 struct Wrapper {
7485 child: WidgetId,
7486 }
7487 impl Widget for Wrapper {
7488 fn build(&mut self, _ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
7489 vec![self.child]
7490 }
7491 fn layout_response(
7492 &self,
7493 p: SizeProposal,
7494 _c: &LayoutContext,
7495 ) -> crate::widget::LayoutResponse {
7496 p.resolve(10.0, 10.0).into()
7497 }
7498 }
7499
7500 #[derive(Debug)]
7504 struct ReparentHost {
7505 body: Option<WidgetId>,
7506 probe: std::rc::Rc<std::cell::Cell<Option<WidgetId>>>,
7507 }
7508 impl Widget for ReparentHost {
7509 fn build(&mut self, ctx: &mut crate::build_context::BuildContext) -> Vec<WidgetId> {
7510 let body = match self.body {
7511 Some(id) => id,
7512 None => {
7513 let id = ctx.add(FillWidget::new());
7514 self.body = Some(id);
7515 self.probe.set(Some(id));
7516 id
7517 }
7518 };
7519 vec![ctx.add(Wrapper { child: body })]
7520 }
7521 fn layout_response(
7522 &self,
7523 p: SizeProposal,
7524 _c: &LayoutContext,
7525 ) -> crate::widget::LayoutResponse {
7526 p.resolve(10.0, 10.0).into()
7527 }
7528 fn preserves_children_on_rebuild(&self) -> bool {
7529 true
7530 }
7531 }
7532
7533 #[test]
7534 fn reconcile_spares_reparented_survivor() {
7535 let probe = std::rc::Rc::new(std::cell::Cell::new(None));
7542 let mut tree = WidgetTree::new();
7543 let host = tree.add(ReparentHost {
7544 body: None,
7545 probe: probe.clone(),
7546 });
7547 tree.layout(SizeProposal::exact(100.0, 100.0));
7548 let body = probe.get().expect("body mounted");
7549 let total0 = tree.arena.len();
7550 for _ in 0..5 {
7551 tree.arena_mark_needs_rebuild_for_testing(host);
7552 tree.layout(SizeProposal::exact(100.0, 100.0));
7553 }
7554 assert!(
7555 tree.arena.is_active(body),
7556 "the re-parented body must survive — it was moved into the new tree, \
7557 not swept with the dropped wrapper"
7558 );
7559 assert_eq!(
7560 tree.arena.len(),
7561 total0,
7562 "dropped wrappers reaped — no per-rebuild leak"
7563 );
7564 }
7565
7566 #[derive(Debug)]
7576 struct BelowContainer {
7577 child: Option<WidgetId>,
7578 offset: f32,
7579 }
7580
7581 impl crate::widget::Widget for BelowContainer {
7582 fn layout_response(
7583 &self,
7584 proposal: SizeProposal,
7585 _ctx: &crate::widget::LayoutContext,
7586 ) -> crate::widget::LayoutResponse {
7587 proposal.resolve(0.0, 0.0).into()
7588 }
7589 fn place_children(
7590 &self,
7591 bounds: Rect,
7592 _proposal: SizeProposal,
7593 children: &mut [crate::widget::WidgetPlacement],
7594 _ctx: &crate::widget::LayoutContext,
7595 ) {
7596 for c in children.iter_mut() {
7597 c.origin = Point::new(bounds.x, bounds.y + self.offset);
7598 c.size = bounds.size();
7599 }
7600 }
7601 fn children(&self) -> Vec<WidgetId> {
7602 self.child.into_iter().collect()
7603 }
7604 }
7605
7606 fn recording_scroll_container(
7609 tree: &mut WidgetTree,
7610 child: WidgetId,
7611 recorded: std::rc::Rc<std::cell::Cell<Option<Rect>>>,
7612 ) -> WidgetId {
7613 use crate::test_widgets::StackWidget;
7614 tree.add(
7615 StackWidget::new()
7616 .child(child)
7617 .on_scroll(move |ev, _ctx| match ev {
7618 WidgetEvent::ScrollIntoView { target_bounds, .. } => {
7619 recorded.set(Some(*target_bounds));
7620 EventResponse::Handled
7621 }
7622 _ => EventResponse::Ignored,
7623 })
7624 .clips_children(true),
7625 )
7626 }
7627
7628 #[test]
7629 fn ensure_visible_dispatches_scroll_into_view_to_clipping_ancestor() {
7630 use std::cell::Cell;
7631 use std::rc::Rc;
7632 let recorded: Rc<Cell<Option<Rect>>> = Rc::new(Cell::new(None));
7633 let mut tree = WidgetTree::new();
7634 let actor = tree.add(FillWidget::new());
7635 let _container = recording_scroll_container(&mut tree, actor, recorded.clone());
7636 tree.layout(SizeProposal::exact(100.0, 100.0));
7637
7638 let target = Rect::new(10.0, 500.0, 20.0, 15.0);
7641 let mut ctx = EventContext::new();
7642 ctx.ensure_visible(target);
7643 tree.collect_from_ctx(ctx, actor);
7644
7645 assert_eq!(
7646 recorded.get(),
7647 Some(target),
7648 "ensure_visible(rect) must dispatch ScrollIntoView with the exact rect \
7649 to the clips_children ancestor"
7650 );
7651 }
7652
7653 #[test]
7654 fn ensure_visible_is_noop_when_rect_already_visible() {
7655 use std::cell::Cell;
7656 use std::rc::Rc;
7657 let recorded: Rc<Cell<Option<Rect>>> = Rc::new(Cell::new(None));
7658 let mut tree = WidgetTree::new();
7659 let actor = tree.add(FillWidget::new());
7660 let _container = recording_scroll_container(&mut tree, actor, recorded.clone());
7661 tree.layout(SizeProposal::exact(100.0, 100.0));
7662
7663 let mut ctx = EventContext::new();
7666 ctx.ensure_visible(Rect::new(10.0, 10.0, 20.0, 15.0));
7667 tree.collect_from_ctx(ctx, actor);
7668
7669 assert_eq!(
7670 recorded.get(),
7671 None,
7672 "a rect already inside the viewport must not trigger a scroll"
7673 );
7674 }
7675
7676 #[test]
7677 fn ensure_visible_margin_forces_scroll_near_edge() {
7678 use std::cell::Cell;
7679 use std::rc::Rc;
7680 let recorded: Rc<Cell<Option<Rect>>> = Rc::new(Cell::new(None));
7681 let mut tree = WidgetTree::new();
7682 let actor = tree.add(FillWidget::new());
7683 let _container = recording_scroll_container(&mut tree, actor, recorded.clone());
7684 tree.layout(SizeProposal::exact(100.0, 100.0));
7685
7686 let rect = Rect::new(10.0, 95.0, 20.0, 4.0);
7689 let mut ctx = EventContext::new();
7690 ctx.ensure_visible_with_margin(rect, 10.0);
7691 tree.collect_from_ctx(ctx, actor);
7692
7693 assert_eq!(
7694 recorded.get(),
7695 Some(rect),
7696 "the margin must widen the visibility test so a near-edge rect scrolls"
7697 );
7698 }
7699
7700 fn recording_align_container(
7703 tree: &mut WidgetTree,
7704 child: WidgetId,
7705 recorded: std::rc::Rc<
7706 std::cell::Cell<Option<(crate::event::ScrollAlign, crate::event::ScrollMotion)>>,
7707 >,
7708 ) -> WidgetId {
7709 use crate::test_widgets::StackWidget;
7710 tree.add(
7711 StackWidget::new()
7712 .child(child)
7713 .on_scroll(move |ev, _ctx| match ev {
7714 WidgetEvent::ScrollIntoView { align, motion, .. } => {
7715 recorded.set(Some((*align, *motion)));
7716 EventResponse::Handled
7717 }
7718 _ => EventResponse::Ignored,
7719 })
7720 .clips_children(true),
7721 )
7722 }
7723
7724 #[test]
7725 fn ensure_visible_aligned_scrolls_even_when_already_visible() {
7726 use std::cell::Cell;
7727 use std::rc::Rc;
7728 let recorded: Rc<Cell<Option<Rect>>> = Rc::new(Cell::new(None));
7729 let mut tree = WidgetTree::new();
7730 let actor = tree.add(FillWidget::new());
7731 let _container = recording_scroll_container(&mut tree, actor, recorded.clone());
7732 tree.layout(SizeProposal::exact(100.0, 100.0));
7733
7734 let target = Rect::new(10.0, 10.0, 20.0, 15.0);
7739 let mut ctx = EventContext::new();
7740 ctx.ensure_visible_aligned(target, 0.5, crate::event::ScrollMotion::Instant);
7741 tree.collect_from_ctx(ctx, actor);
7742
7743 assert_eq!(
7744 recorded.get(),
7745 Some(target),
7746 "an aligned reveal must dispatch even when the rect is already visible"
7747 );
7748 }
7749
7750 #[test]
7751 fn ensure_visible_aligned_forwards_fraction_and_motion() {
7752 use std::cell::Cell;
7753 use std::rc::Rc;
7754 let recorded: Rc<Cell<Option<(crate::event::ScrollAlign, crate::event::ScrollMotion)>>> =
7755 Rc::new(Cell::new(None));
7756 let mut tree = WidgetTree::new();
7757 let actor = tree.add(FillWidget::new());
7758 let _container = recording_align_container(&mut tree, actor, recorded.clone());
7759 tree.layout(SizeProposal::exact(100.0, 100.0));
7760
7761 let mut ctx = EventContext::new();
7762 ctx.ensure_visible_aligned(
7763 Rect::new(10.0, 10.0, 20.0, 15.0),
7764 0.25,
7765 crate::event::ScrollMotion::Smooth,
7766 );
7767 tree.collect_from_ctx(ctx, actor);
7768
7769 assert_eq!(
7770 recorded.get(),
7771 Some((
7772 crate::event::ScrollAlign::Fraction(0.25),
7773 crate::event::ScrollMotion::Smooth
7774 )),
7775 "the container must receive the requested fraction and motion verbatim"
7776 );
7777 }
7778
7779 #[test]
7780 fn ensure_visible_aligned_clamps_the_fraction() {
7781 use std::cell::Cell;
7782 use std::rc::Rc;
7783 let recorded: Rc<Cell<Option<(crate::event::ScrollAlign, crate::event::ScrollMotion)>>> =
7784 Rc::new(Cell::new(None));
7785 let mut tree = WidgetTree::new();
7786 let actor = tree.add(FillWidget::new());
7787 let _container = recording_align_container(&mut tree, actor, recorded.clone());
7788 tree.layout(SizeProposal::exact(100.0, 100.0));
7789
7790 let mut ctx = EventContext::new();
7791 ctx.ensure_visible_aligned(
7792 Rect::new(10.0, 10.0, 20.0, 15.0),
7793 4.2,
7794 crate::event::ScrollMotion::Instant,
7795 );
7796 tree.collect_from_ctx(ctx, actor);
7797
7798 assert_eq!(
7799 recorded.get().map(|(a, _)| a),
7800 Some(crate::event::ScrollAlign::Fraction(1.0)),
7801 "an out-of-range fraction must clamp rather than aim the pin off-screen"
7802 );
7803 }
7804
7805 #[test]
7806 fn plain_ensure_visible_requests_minimal_alignment() {
7807 use std::cell::Cell;
7808 use std::rc::Rc;
7809 let recorded: Rc<Cell<Option<(crate::event::ScrollAlign, crate::event::ScrollMotion)>>> =
7810 Rc::new(Cell::new(None));
7811 let mut tree = WidgetTree::new();
7812 let actor = tree.add(FillWidget::new());
7813 let _container = recording_align_container(&mut tree, actor, recorded.clone());
7814 tree.layout(SizeProposal::exact(100.0, 100.0));
7815
7816 let mut ctx = EventContext::new();
7817 ctx.ensure_visible(Rect::new(10.0, 500.0, 20.0, 15.0));
7818 tree.collect_from_ctx(ctx, actor);
7819
7820 assert_eq!(
7821 recorded.get(),
7822 Some((
7823 crate::event::ScrollAlign::Minimal,
7824 crate::event::ScrollMotion::Instant
7825 )),
7826 "the pre-existing reveal API must keep its exact semantics"
7827 );
7828 }
7829
7830 #[test]
7831 fn only_the_innermost_container_aligns() {
7832 use std::cell::Cell;
7833 use std::rc::Rc;
7834 let inner_rec: Rc<Cell<Option<(crate::event::ScrollAlign, crate::event::ScrollMotion)>>> =
7835 Rc::new(Cell::new(None));
7836 let outer_rec: Rc<Cell<Option<(crate::event::ScrollAlign, crate::event::ScrollMotion)>>> =
7837 Rc::new(Cell::new(None));
7838
7839 let mut tree = WidgetTree::new();
7840 let actor = tree.add(FillWidget::new());
7841 let inner = recording_align_container(&mut tree, actor, inner_rec.clone());
7842 let _outer = recording_align_container(&mut tree, inner, outer_rec.clone());
7843 tree.layout(SizeProposal::exact(100.0, 100.0));
7844
7845 let mut ctx = EventContext::new();
7848 ctx.ensure_visible_aligned(
7849 Rect::new(10.0, 500.0, 20.0, 15.0),
7850 0.5,
7851 crate::event::ScrollMotion::Instant,
7852 );
7853 tree.collect_from_ctx(ctx, actor);
7854
7855 assert_eq!(
7856 inner_rec.get().map(|(a, _)| a),
7857 Some(crate::event::ScrollAlign::Fraction(0.5)),
7858 "the innermost clipping ancestor owns the pin"
7859 );
7860 assert_eq!(
7861 outer_rec.get().map(|(a, _)| a),
7862 Some(crate::event::ScrollAlign::Minimal),
7863 "an outer container must only bring the inner viewport into view — a \
7864 fraction names a height in one viewport, not in every ancestor's"
7865 );
7866 }
7867
7868 #[test]
7869 fn a_clipper_that_does_not_scroll_passes_the_pin_on() {
7870 use crate::test_widgets::StackWidget;
7877 use std::cell::Cell;
7878 use std::rc::Rc;
7879 let outer_rec: Rc<Cell<Option<(crate::event::ScrollAlign, crate::event::ScrollMotion)>>> =
7880 Rc::new(Cell::new(None));
7881
7882 let mut tree = WidgetTree::new();
7883 let actor = tree.add(FillWidget::new());
7884 let clipper = tree.add(StackWidget::new().child(actor).clips_children_on(true));
7885 let _scroller = recording_align_container(&mut tree, clipper, outer_rec.clone());
7886 tree.layout(SizeProposal::exact(100.0, 100.0));
7887
7888 let mut ctx = EventContext::new();
7891 ctx.ensure_visible_aligned(
7892 Rect::new(10.0, 10.0, 20.0, 15.0),
7893 0.5,
7894 crate::event::ScrollMotion::Instant,
7895 );
7896 tree.collect_from_ctx(ctx, actor);
7897
7898 assert_eq!(
7899 outer_rec.get().map(|(a, _)| a),
7900 Some(crate::event::ScrollAlign::Fraction(0.5)),
7901 "a clipping wrapper with no scroll handler must pass the pin through \
7902 to the scroll container above it"
7903 );
7904 }
7905
7906 #[test]
7907 fn a_scroller_that_declines_to_move_still_holds_the_pin() {
7908 use crate::test_widgets::StackWidget;
7913 use std::cell::Cell;
7914 use std::rc::Rc;
7915 let inner_rec: Rc<Cell<Option<crate::event::ScrollAlign>>> = Rc::new(Cell::new(None));
7916 let outer_rec: Rc<Cell<Option<(crate::event::ScrollAlign, crate::event::ScrollMotion)>>> =
7917 Rc::new(Cell::new(None));
7918
7919 let mut tree = WidgetTree::new();
7920 let actor = tree.add(FillWidget::new());
7921 let rec = inner_rec.clone();
7922 let inner = tree.add(
7923 StackWidget::new()
7924 .child(actor)
7925 .on_scroll(move |ev, _ctx| match ev {
7926 WidgetEvent::ScrollIntoView { align, .. } => {
7927 rec.set(Some(*align));
7928 EventResponse::Ignored
7929 }
7930 _ => EventResponse::Ignored,
7931 })
7932 .clips_children(true),
7933 );
7934 let _outer = recording_align_container(&mut tree, inner, outer_rec.clone());
7935 tree.layout(SizeProposal::exact(100.0, 100.0));
7936
7937 let mut ctx = EventContext::new();
7939 ctx.ensure_visible_aligned(
7940 Rect::new(10.0, 500.0, 20.0, 15.0),
7941 0.5,
7942 crate::event::ScrollMotion::Instant,
7943 );
7944 tree.collect_from_ctx(ctx, actor);
7945
7946 assert_eq!(
7947 inner_rec.get(),
7948 Some(crate::event::ScrollAlign::Fraction(0.5)),
7949 "the innermost scroller is offered the pin"
7950 );
7951 assert_eq!(
7952 outer_rec.get().map(|(a, _)| a),
7953 Some(crate::event::ScrollAlign::Minimal),
7954 "declining to move must not pass the pin outward"
7955 );
7956 }
7957
7958 #[test]
7959 fn ensure_widget_visible_uses_target_arena_bounds() {
7960 use std::cell::Cell;
7961 use std::rc::Rc;
7962 let recorded: Rc<Cell<Option<Rect>>> = Rc::new(Cell::new(None));
7963 let mut tree = WidgetTree::new();
7964 let target = tree.add(FillWidget::new());
7966 let rec = recorded.clone();
7967 let container = tree.add(
7968 BelowContainer {
7969 child: Some(target),
7970 offset: 500.0,
7971 }
7972 .on_scroll(move |ev, _ctx| match ev {
7973 WidgetEvent::ScrollIntoView { target_bounds, .. } => {
7974 rec.set(Some(*target_bounds));
7975 EventResponse::Handled
7976 }
7977 _ => EventResponse::Ignored,
7978 })
7979 .clips_children(true),
7980 );
7981 tree.layout(SizeProposal::exact(100.0, 100.0));
7982
7983 let expected = tree.bounds(target);
7984 assert!(
7985 expected.y > 100.0,
7986 "fixture sanity: the target must sit below the viewport (y={})",
7987 expected.y
7988 );
7989
7990 let mut ctx = EventContext::new();
7993 ctx.ensure_widget_visible(target);
7994 tree.collect_from_ctx(ctx, container);
7995
7996 assert_eq!(
7997 recorded.get(),
7998 Some(expected),
7999 "ensure_widget_visible(id) must dispatch ScrollIntoView with the \
8000 target's current arena bounds"
8001 );
8002 }
8003
8004 #[test]
8005 fn ensure_widget_visible_ignores_missing_widget() {
8006 use std::cell::Cell;
8008 use std::rc::Rc;
8009 let recorded: Rc<Cell<Option<Rect>>> = Rc::new(Cell::new(None));
8010 let mut tree = WidgetTree::new();
8011 let actor = tree.add(FillWidget::new());
8012 let _container = recording_scroll_container(&mut tree, actor, recorded.clone());
8013 tree.layout(SizeProposal::exact(100.0, 100.0));
8014
8015 let mut ctx = EventContext::new();
8016 ctx.ensure_widget_visible(WidgetId::default());
8017 tree.collect_from_ctx(ctx, actor); assert_eq!(
8020 recorded.get(),
8021 None,
8022 "an unmounted id must not trigger a scroll"
8023 );
8024 }
8025
8026 #[test]
8027 fn context_menu_inside_a_modal_keeps_the_modal() {
8028 use crate::event::{Modifiers, PointerButton, WidgetEvent};
8032 use crate::overlay::{DismissBehavior, OverlayPlacement, OverlayRequest};
8033 use crate::test_widgets::{FillWidget, StackWidget};
8034
8035 let mut tree = WidgetTree::new();
8036 let modal_content = tree.add(StackWidget::new());
8039 let _editor = tree.add_child(
8040 modal_content,
8041 FillWidget::new()
8042 .context_menu(|_pos, _ctx| Some(Box::new(FillWidget::new()) as Box<dyn Widget>)),
8043 );
8044 tree.layout(SizeProposal::exact(200.0, 100.0));
8045
8046 let modal = tree.overlay_manager.show(OverlayRequest::new(
8047 modal_content,
8048 modal_content,
8049 OverlayPlacement::Centered,
8050 DismissBehavior::EscapeKey,
8051 ));
8052 tree.overlay_manager
8054 .stack
8055 .iter_mut()
8056 .find(|o| o.id == modal)
8057 .unwrap()
8058 .bounds = Rect::new(0.0, 0.0, 200.0, 100.0);
8059 assert_eq!(tree.overlay_manager.len(), 1);
8060
8061 tree.dispatch_event(WidgetEvent::pointer_down(
8063 Point::new(50.0, 25.0),
8064 PointerButton::Secondary,
8065 Modifiers::NONE,
8066 ));
8067
8068 assert!(
8069 tree.overlay_manager.active_ids().contains(&modal),
8070 "the modal must survive opening a context menu inside it"
8071 );
8072 assert_eq!(
8073 tree.overlay_manager.len(),
8074 2,
8075 "the context menu should now be open on top of the surviving modal"
8076 );
8077 }
8078}
8079
8080#[cfg(test)]
8083mod input_ingress_tests {
8084 use super::*;
8085 use crate::event::{EventResponse, Modifiers, PointerButton, ScrollDelta};
8086 use crate::pointer::{
8087 EventTime, PointerId, PointerInfo, PointerPhase, PointerSample, ScrollPhase, ScrollSample,
8088 ScrollSource,
8089 };
8090 use crate::test_widgets::FillWidget;
8091 use crate::widget::{LayoutContext, WidgetPlacement};
8092 use crate::widget_builder::WidgetBuilder;
8093 use std::cell::RefCell;
8094 use std::rc::Rc;
8095
8096 #[derive(Debug)]
8103 struct RowWidget {
8104 children: Vec<WidgetId>,
8105 }
8106
8107 impl crate::widget::Widget for RowWidget {
8108 fn layout_response(
8109 &self,
8110 proposal: SizeProposal,
8111 _ctx: &LayoutContext,
8112 ) -> crate::widget::LayoutResponse {
8113 proposal.resolve(0.0, 0.0).into()
8114 }
8115
8116 fn place_children(
8117 &self,
8118 bounds: Rect,
8119 _proposal: SizeProposal,
8120 children: &mut [WidgetPlacement],
8121 _ctx: &LayoutContext,
8122 ) {
8123 let n = children.len().max(1) as f32;
8124 let w = bounds.width / n;
8125 for (i, child) in children.iter_mut().enumerate() {
8126 child.origin = Point::new(bounds.x + w * i as f32, bounds.y);
8127 child.size = teksilo_canvas::Size::new(w, bounds.height);
8128 }
8129 }
8130
8131 fn children(&self) -> Vec<WidgetId> {
8132 self.children.clone()
8133 }
8134 }
8135
8136 fn record(drive: impl FnOnce(&mut WidgetTree)) -> Vec<String> {
8139 let log: Rc<RefCell<Vec<String>>> = Rc::new(RefCell::new(Vec::new()));
8140
8141 let mut tree = WidgetTree::new();
8142 let pointer_log = log.clone();
8143 let hover_log = log.clone();
8144 tree.add(
8145 FillWidget::new()
8146 .on_pointer_event(move |event, _ctx| {
8147 pointer_log.borrow_mut().push(format!("{event:?}"));
8148 EventResponse::Ignored
8149 })
8150 .on_hover(move |entered, _ctx| {
8151 hover_log.borrow_mut().push(format!("hover({entered})"));
8152 }),
8153 );
8154 tree.layout(SizeProposal::exact(100.0, 100.0));
8155
8156 drive(&mut tree);
8157 log.borrow().clone()
8158 }
8159
8160 #[test]
8166 fn a_mouse_sample_reproduces_todays_event_stream() {
8167 let inside = Point::new(40.0, 40.0);
8168 let moved = Point::new(60.0, 55.0);
8169 let outside = Point::new(400.0, 400.0);
8170
8171 let legacy = record(|tree| {
8172 tree.dispatch_event(WidgetEvent::pointer_move(inside));
8173 tree.dispatch_event(WidgetEvent::pointer_down(
8174 inside,
8175 PointerButton::Primary,
8176 Modifiers::NONE,
8177 ));
8178 tree.dispatch_event(WidgetEvent::pointer_move(moved));
8179 tree.dispatch_event(WidgetEvent::pointer_up(
8180 moved,
8181 PointerButton::Primary,
8182 Modifiers::NONE,
8183 ));
8184 tree.dispatch_event(WidgetEvent::pointer_move(outside));
8185 });
8186
8187 let sampled = record(|tree| {
8188 let t = EventTime::ZERO;
8189 tree.dispatch_pointer(PointerSample::mouse(PointerPhase::Move, inside, t));
8190 tree.dispatch_pointer(
8191 PointerSample::mouse(PointerPhase::Down, inside, t)
8192 .with_button(PointerButton::Primary),
8193 );
8194 tree.dispatch_pointer(PointerSample::mouse(PointerPhase::Move, moved, t));
8195 tree.dispatch_pointer(
8196 PointerSample::mouse(PointerPhase::Up, moved, t)
8197 .with_button(PointerButton::Primary),
8198 );
8199 tree.dispatch_pointer(PointerSample::mouse(PointerPhase::Move, outside, t));
8200 });
8201
8202 assert_eq!(legacy, sampled);
8203 assert!(
8204 legacy.contains(&"hover(true)".to_string())
8205 && legacy.contains(&"hover(false)".to_string()),
8206 "the fixture must actually exercise enter and leave: {legacy:?}"
8207 );
8208 }
8209
8210 #[test]
8214 fn a_buttonless_press_lowers_to_primary() {
8215 let events = record(|tree| {
8216 tree.dispatch_pointer(PointerSample::mouse(
8217 PointerPhase::Down,
8218 Point::new(20.0, 20.0),
8219 EventTime::ZERO,
8220 ));
8221 });
8222 assert!(
8223 events.iter().any(|e| e.contains("button: Primary")),
8224 "{events:?}"
8225 );
8226 }
8227
8228 #[test]
8234 fn a_sampled_press_and_release_form_a_tap() {
8235 let taps = Rc::new(std::cell::Cell::new(0));
8236 let seen = taps.clone();
8237 let mut tree = WidgetTree::new();
8238 tree.add(FillWidget::new().on_tap(move |_event, _ctx| seen.set(seen.get() + 1)));
8239 tree.layout(SizeProposal::exact(100.0, 100.0));
8240
8241 let at = Point::new(50.0, 50.0);
8242 tree.dispatch_pointer(PointerSample::mouse(
8243 PointerPhase::Down,
8244 at,
8245 EventTime::from_millis(0),
8246 ));
8247 tree.dispatch_pointer(PointerSample::mouse(
8248 PointerPhase::Up,
8249 at,
8250 EventTime::from_millis(5),
8251 ));
8252
8253 assert_eq!(taps.get(), 1);
8254 }
8255
8256 fn scroll_fixture() -> (WidgetTree, Rc<RefCell<Vec<&'static str>>>) {
8261 let hits: Rc<RefCell<Vec<&'static str>>> = Rc::new(RefCell::new(Vec::new()));
8262 let mut tree = WidgetTree::new();
8263
8264 let leading_hits = hits.clone();
8265 let trailing_hits = hits.clone();
8266 let leading = tree.add(FillWidget::new().on_scroll(move |_event, _ctx| {
8267 leading_hits.borrow_mut().push("leading");
8268 EventResponse::Handled
8269 }));
8270 let trailing = tree.add(FillWidget::new().on_scroll(move |_event, _ctx| {
8271 trailing_hits.borrow_mut().push("trailing");
8272 EventResponse::Handled
8273 }));
8274 tree.add(RowWidget {
8275 children: vec![leading, trailing],
8276 });
8277 tree.layout(SizeProposal::exact(200.0, 100.0));
8278 (tree, hits)
8279 }
8280
8281 fn notch() -> ScrollDelta {
8282 ScrollDelta::Lines { x: 0.0, y: -1.0 }
8283 }
8284
8285 #[test]
8288 fn a_positionless_scroll_routes_by_hover() {
8289 let (mut tree, hits) = scroll_fixture();
8290
8291 tree.pointer_move(Point::new(150.0, 50.0)); tree.dispatch_event(WidgetEvent::scroll(notch(), Modifiers::NONE));
8293 assert_eq!(*hits.borrow(), vec!["trailing"]);
8294
8295 tree.pointer_move(Point::new(50.0, 50.0)); tree.dispatch_scroll(ScrollSample::wheel(
8297 notch(),
8298 Modifiers::NONE,
8299 EventTime::ZERO,
8300 ));
8301 assert_eq!(*hits.borrow(), vec!["trailing", "leading"]);
8302 }
8303
8304 #[test]
8309 fn a_positioned_scroll_routes_by_hit_test() {
8310 let (mut tree, hits) = scroll_fixture();
8311 tree.pointer_move(Point::new(150.0, 50.0)); tree.dispatch_event(WidgetEvent::scroll_at(
8314 notch(),
8315 Modifiers::NONE,
8316 Point::new(50.0, 50.0), ));
8318 assert_eq!(*hits.borrow(), vec!["leading"]);
8319
8320 tree.dispatch_scroll(
8321 ScrollSample::wheel(notch(), Modifiers::NONE, EventTime::ZERO)
8322 .at(Point::new(150.0, 50.0)),
8323 );
8324 assert_eq!(*hits.borrow(), vec!["leading", "trailing"]);
8325 }
8326
8327 #[test]
8331 fn a_positionless_scroll_with_no_hover_goes_nowhere() {
8332 let (mut tree, hits) = scroll_fixture();
8333 tree.dispatch_event(WidgetEvent::scroll(notch(), Modifiers::NONE));
8334 assert!(hits.borrow().is_empty());
8335 }
8336
8337 #[test]
8342 fn a_handler_sees_the_sample_it_is_serving() {
8343 let seen: Rc<RefCell<Vec<(ScrollPhase, ScrollSource, Option<Point>)>>> =
8344 Rc::new(RefCell::new(Vec::new()));
8345 let sink = seen.clone();
8346
8347 let mut tree = WidgetTree::new();
8348 tree.add(
8355 FillWidget::new()
8356 .scroll_container(crate::pointer::touch_action::PanAxes::BOTH)
8357 .on_scroll(move |_event, ctx| {
8358 sink.borrow_mut().push((
8359 ctx.scroll_phase(),
8360 ctx.scroll_source(),
8361 ctx.pointer_position(),
8362 ));
8363 EventResponse::Handled
8364 }),
8365 );
8366 tree.layout(SizeProposal::exact(100.0, 100.0));
8367
8368 tree.dispatch_scroll(ScrollSample {
8369 delta: notch(),
8370 position: Some(Point::new(50.0, 50.0)),
8371 phase: ScrollPhase::Momentum,
8372 source: ScrollSource::TouchPan,
8373 pointer: PointerInfo::mouse(EventTime::from_millis(12)),
8374 modifiers: Modifiers::NONE,
8375 });
8376
8377 assert_eq!(
8378 *seen.borrow(),
8379 vec![(
8380 ScrollPhase::Momentum,
8381 ScrollSource::TouchPan,
8382 Some(Point::new(50.0, 50.0))
8383 )]
8384 );
8385 }
8386
8387 #[test]
8390 fn a_legacy_event_reports_the_mouse_at_the_epoch() {
8391 let seen: Rc<RefCell<Option<(PointerId, ScrollPhase)>>> = Rc::new(RefCell::new(None));
8392 let sink = seen.clone();
8393
8394 let mut tree = WidgetTree::new();
8395 tree.add(FillWidget::new().on_pointer_event(move |_event, ctx| {
8396 *sink.borrow_mut() = Some((ctx.pointer().id, ctx.scroll_phase()));
8397 EventResponse::Ignored
8398 }));
8399 tree.layout(SizeProposal::exact(100.0, 100.0));
8400 tree.dispatch_event(WidgetEvent::pointer_move(Point::new(50.0, 50.0)));
8401
8402 assert_eq!(
8403 *seen.borrow(),
8404 Some((PointerId::MOUSE, ScrollPhase::Discrete))
8405 );
8406 }
8407
8408 #[test]
8412 fn the_snapshot_is_restored_after_a_dispatch() {
8413 let mut tree = WidgetTree::new();
8414 tree.add(FillWidget::new());
8415 tree.layout(SizeProposal::exact(100.0, 100.0));
8416
8417 let before = tree.current_input.clone();
8418 tree.dispatch_scroll(
8419 ScrollSample::wheel(notch(), Modifiers::NONE, EventTime::ZERO)
8420 .at(Point::new(10.0, 10.0)),
8421 );
8422 assert_eq!(tree.current_input, before);
8423 }
8424}
8425
8426#[cfg(test)]
8427mod press_and_focus_tests {
8428 use std::cell::{Cell, RefCell};
8433 use std::rc::Rc;
8434 use teksilo_canvas::{Point, SizeProposal};
8435
8436 use crate::WidgetId;
8437 use crate::event::{EventResponse, Key, Modifiers, PointerButton, WidgetEvent};
8438 use crate::focus::FocusOrigin;
8439 use crate::pointer::clock::ManualClock;
8440 use crate::pointer::touch_action::PanClaim;
8441 use crate::pointer::{
8442 BackendDeviceKey, EventTime, PointerId, PointerIdAllocator, PointerInfo, PointerPhase,
8443 PointerSample,
8444 };
8445 use crate::test_widgets::{FillWidget, StackWidget};
8446 use crate::widget_builder::WidgetBuilder;
8447 use crate::widget_tree::WidgetTree;
8448
8449 fn contact_id() -> PointerId {
8455 use std::sync::atomic::{AtomicU64, Ordering};
8456 static NEXT: AtomicU64 = AtomicU64::new(1);
8457 PointerIdAllocator::global().begin(
8458 BackendDeviceKey::new(0x0B11),
8459 NEXT.fetch_add(1, Ordering::Relaxed),
8460 )
8461 }
8462
8463 fn contact(id: PointerId, phase: PointerPhase, at: Point, t: EventTime) -> PointerSample {
8464 PointerSample {
8465 pointer: PointerInfo::touch(id, t),
8466 phase,
8467 position: at,
8468 button: None,
8469 modifiers: Modifiers::NONE,
8470 coalesced: Vec::new(),
8471 }
8472 }
8473
8474 fn tree_on_a_clock() -> (WidgetTree, Rc<ManualClock>) {
8477 let mut tree = WidgetTree::new();
8478 let clock = Rc::new(ManualClock::new(EventTime::ZERO));
8479 tree.set_input_clock(clock.clone());
8480 (tree, clock)
8481 }
8482
8483 fn tappable(tree: &mut WidgetTree) -> (WidgetId, crate::signal::Signal<bool>) {
8490 let id = tree.add(FillWidget::new().focusable().on_tap(|_e, _c| {}));
8491 let signal = tree.pressed_signal(id);
8492 (id, signal)
8493 }
8494
8495 #[test]
8502 fn a_pointer_origin_names_its_device() {
8503 use teksilo_tokens::{PenKind, PointerKind};
8504
8505 assert!(FocusOrigin::Pointer(PointerKind::Touch).is_pointer());
8506 assert!(FocusOrigin::Pointer(PointerKind::Pen(PenKind::Pen)).is_pointer());
8507 assert!(FocusOrigin::POINTER.is_pointer());
8508 assert!(!FocusOrigin::Keyboard.is_pointer());
8509 assert!(!FocusOrigin::Programmatic.is_pointer());
8510 assert!(!FocusOrigin::Accessibility.is_pointer());
8511
8512 assert_eq!(
8513 FocusOrigin::Pointer(PointerKind::Touch).pointer_kind(),
8514 Some(PointerKind::Touch),
8515 );
8516 assert_eq!(FocusOrigin::Keyboard.pointer_kind(), None);
8517 assert_eq!(
8518 FocusOrigin::POINTER.pointer_kind(),
8519 Some(PointerKind::Unknown),
8520 "a widget deriving its own origin says so rather than naming a device it never saw",
8521 );
8522 }
8523
8524 #[test]
8528 fn only_a_real_navigation_declares_a_modality() {
8529 use teksilo_tokens::PointerKind;
8530
8531 assert_eq!(FocusOrigin::Keyboard.focus_visible(), Some(true));
8532 assert_eq!(FocusOrigin::Accessibility.focus_visible(), Some(true));
8533 assert_eq!(
8534 FocusOrigin::Pointer(PointerKind::Touch).focus_visible(),
8535 Some(false),
8536 );
8537 assert_eq!(FocusOrigin::Programmatic.focus_visible(), None);
8538 }
8539
8540 #[test]
8543 fn the_tier_three_configs_are_unchanged() {
8544 let origin: crate::signal::Signal<Option<FocusOrigin>> =
8545 crate::signal::Signal::new(Some(FocusOrigin::Keyboard));
8546 let slider: crate::signal::Signal<Option<FocusOrigin>> = origin.clone();
8547 let splitter: crate::signal::Signal<Option<FocusOrigin>> = origin.clone();
8548 let segmented: crate::signal::Signal<Option<FocusOrigin>> = origin.clone();
8549 for field in [slider, splitter, segmented] {
8550 assert_eq!(field.get(), Some(FocusOrigin::Keyboard));
8551 }
8552 origin.set(Some(FocusOrigin::POINTER));
8553 assert_ne!(
8554 origin.get(),
8555 Some(FocusOrigin::Keyboard),
8556 "the `== Some(Keyboard)` test every consumer makes still discriminates",
8557 );
8558 }
8559
8560 #[test]
8571 fn a_touch_tap_after_keyboard_focus_leaves_no_ring() {
8572 let (mut tree, _clock) = tree_on_a_clock();
8573 let a = tree.add(FillWidget::new().focusable());
8574 let b = tree.add(FillWidget::new().focusable());
8575 let root = tree.add(SideBySide {
8576 children: vec![a, b],
8577 });
8578 tree.layout(SizeProposal::exact(200.0, 100.0));
8579 let _ = root;
8580
8581 let visible = tree.focus_visible_signal();
8582 tree.press_key(Key::Tab, Modifiers::NONE);
8583 assert_eq!(tree.focused(), Some(a));
8584 assert!(visible.get(), "keyboard navigation reveals the ring");
8585
8586 let id = contact_id();
8587 let at = tree.bounds(b).center();
8588 tree.dispatch_pointer(contact(id, PointerPhase::Down, at, EventTime::ZERO));
8589 tree.dispatch_pointer(contact(
8590 id,
8591 PointerPhase::Up,
8592 at,
8593 EventTime::from_millis(30),
8594 ));
8595
8596 assert_eq!(tree.focused(), Some(b), "the release moved focus");
8597 assert!(!visible.get(), "and the ring did not come with it");
8598 assert_eq!(
8599 tree.focus_origin(),
8600 Some(FocusOrigin::Pointer(teksilo_tokens::PointerKind::Touch)),
8601 );
8602 }
8603
8604 #[test]
8609 fn an_assistive_focus_reveals_the_ring() {
8610 let mut tree = WidgetTree::new();
8611 let a = tree.add(FillWidget::new().focusable());
8612 let b = tree.add(FillWidget::new().focusable());
8613 let root = tree.add(SideBySide {
8614 children: vec![a, b],
8615 });
8616 tree.layout(SizeProposal::exact(200.0, 50.0));
8617 let _ = root;
8618 let visible = tree.focus_visible_signal();
8619
8620 tree.click(a);
8621 assert_eq!(tree.focused(), Some(a));
8622 assert!(!visible.get(), "the click hid it");
8623
8624 tree.dispatch_event(WidgetEvent::AccessAction {
8625 target: Some(b),
8626 action: accesskit::Action::Focus,
8627 target_node: crate::accessibility::widget_id_to_node_id(b),
8628 data: None,
8629 });
8630 assert_eq!(tree.focused(), Some(b));
8631 assert!(visible.get(), "an assistive move is a navigation");
8632 assert_eq!(tree.focus_origin(), Some(FocusOrigin::Accessibility));
8633 }
8634
8635 struct ItemFocusFixture {
8639 tree: WidgetTree,
8640 other: WidgetId,
8641 group: WidgetId,
8643 owner: WidgetId,
8644 refused: WidgetId,
8647 taken: WidgetId,
8648 label: WidgetId,
8650 cursor: Rc<Cell<Option<accesskit::NodeId>>>,
8651 catch_all: Rc<Cell<u32>>,
8652 }
8653
8654 fn item_focus_fixture() -> ItemFocusFixture {
8655 let advertises_focus = |b: &mut crate::accessibility::AccessNodeBuilder| {
8656 b.add_action(accesskit::Action::Focus)
8657 };
8658 let mut tree = WidgetTree::new();
8659 let other = tree.add(FillWidget::new().focusable());
8660 let refused = tree.add(FillWidget::new().access_customize(advertises_focus));
8661 let taken = tree.add(FillWidget::new().access_customize(advertises_focus));
8662 let label = tree.add(FillWidget::new());
8663 let cursor: Rc<Cell<Option<accesskit::NodeId>>> = Rc::new(Cell::new(None));
8664 let owner_slot: Rc<Cell<Option<WidgetId>>> = Rc::new(Cell::new(None));
8665 let taken_node = crate::accessibility::widget_id_to_node_id(taken);
8666 let owner = tree.add(
8667 SideBySide {
8668 children: vec![refused, taken],
8669 }
8670 .focusable(true)
8671 .on_access_action_request({
8672 let cursor = cursor.clone();
8673 let owner_slot = owner_slot.clone();
8674 move |action, node, _data, ctx| {
8675 if action != accesskit::Action::Focus || node != taken_node {
8676 return EventResponse::Ignored;
8677 }
8678 cursor.set(Some(node));
8679 if let Some(owner) = owner_slot.get() {
8680 ctx.request_focus(owner);
8681 }
8682 EventResponse::Handled
8683 }
8684 }),
8685 );
8686 owner_slot.set(Some(owner));
8687 let group = tree.add(SideBySide {
8689 children: vec![owner],
8690 });
8691 let catch_all = Rc::new(Cell::new(0));
8692 let card = tree.add(
8693 SideBySide {
8694 children: vec![group, label],
8695 }
8696 .focusable(true)
8697 .on_access_action({
8698 let catch_all = catch_all.clone();
8699 move |action, _ctx| {
8700 if action != accesskit::Action::Focus {
8701 return EventResponse::Ignored;
8702 }
8703 catch_all.set(catch_all.get() + 1);
8704 EventResponse::Handled
8705 }
8706 }),
8707 );
8708 tree.add(SideBySide {
8709 children: vec![other, card],
8710 });
8711 tree.layout(SizeProposal::exact(400.0, 50.0));
8712 ItemFocusFixture {
8713 tree,
8714 other,
8715 group,
8716 owner,
8717 refused,
8718 taken,
8719 label,
8720 cursor,
8721 catch_all,
8722 }
8723 }
8724
8725 fn assistive_focus(tree: &mut WidgetTree, id: WidgetId) -> bool {
8726 tree.dispatch_access_action(
8727 crate::accessibility::widget_id_to_node_id(id),
8728 accesskit::Action::Focus,
8729 None,
8730 &mut crate::window::NoopWindowOps,
8731 )
8732 }
8733
8734 #[test]
8741 fn an_assistive_focus_on_an_item_goes_to_the_widget_that_points_at_it() {
8742 let mut f = item_focus_fixture();
8743 let visible = f.tree.focus_visible_signal();
8744 f.tree.click(f.other);
8745 assert!(!visible.get());
8746
8747 assert!(
8748 assistive_focus(&mut f.tree, f.taken),
8749 "the widget that points at the item took it"
8750 );
8751 let item = crate::accessibility::widget_id_to_node_id(f.taken);
8752 assert_eq!(f.cursor.get(), Some(item), "its cursor moved to the item");
8753 assert_eq!(
8754 f.tree.focused(),
8755 Some(f.owner),
8756 "the keyboard is on the widget, not on the item"
8757 );
8758 assert!(visible.get(), "an assistive move is a navigation");
8759 assert_eq!(f.tree.focus_origin(), Some(FocusOrigin::Accessibility));
8760 assert_eq!(
8761 f.catch_all.get(),
8762 0,
8763 "no ancestor above the owner was asked"
8764 );
8765 }
8766
8767 #[test]
8771 fn an_item_its_owner_refuses_takes_no_assistive_focus() {
8772 let mut f = item_focus_fixture();
8773 f.tree.click(f.other);
8774 assert!(!assistive_focus(&mut f.tree, f.refused));
8775 assert_eq!(f.tree.focused(), Some(f.other), "focus did not move");
8776 assert_eq!(f.cursor.get(), None);
8777 assert_eq!(f.catch_all.get(), 0);
8778 }
8779
8780 #[test]
8783 fn a_node_that_offers_no_focus_takes_no_assistive_focus() {
8784 let mut f = item_focus_fixture();
8785 f.tree.click(f.other);
8786 assert!(!assistive_focus(&mut f.tree, f.label));
8787 assert_eq!(f.tree.focused(), Some(f.other));
8788 assert_eq!(f.catch_all.get(), 0);
8789 }
8790
8791 #[test]
8795 fn a_greyed_item_reaches_its_owner_and_a_disabled_container_takes_nothing() {
8796 let mut f = item_focus_fixture();
8797 let item_enabled = crate::signal::Signal::new(false);
8798 f.tree.enabled_when(f.taken, item_enabled.clone());
8799 f.tree.layout(SizeProposal::exact(400.0, 50.0));
8800 f.tree.click(f.other);
8801 assert!(assistive_focus(&mut f.tree, f.taken), "a greyed item");
8802 assert_eq!(f.tree.focused(), Some(f.owner));
8803
8804 let mut f = item_focus_fixture();
8805 f.tree
8806 .enabled_when(f.group, crate::signal::Signal::new(false));
8807 f.tree.layout(SizeProposal::exact(400.0, 50.0));
8808 f.tree.click(f.other);
8809 assert!(
8810 !assistive_focus(&mut f.tree, f.taken),
8811 "a disabled container"
8812 );
8813 assert_eq!(f.tree.focused(), Some(f.other));
8814 assert_eq!(f.cursor.get(), None);
8815 assert_eq!(f.catch_all.get(), 0);
8816 }
8817
8818 #[test]
8822 fn a_composite_in_a_catch_all_ancestor_gets_its_stop() {
8823 let mut tree = WidgetTree::new();
8824 let other = tree.add(FillWidget::new().focusable());
8825 let leaf = tree.add(FillWidget::new().focusable());
8826 let composite = tree.add(
8827 SideBySide {
8828 children: vec![leaf],
8829 }
8830 .access_customize(|b| b.add_action(accesskit::Action::Focus)),
8831 );
8832 let catch_all = Rc::new(Cell::new(0));
8833 let card = tree.add(
8834 SideBySide {
8835 children: vec![composite],
8836 }
8837 .focusable(true)
8838 .on_access_action({
8839 let catch_all = catch_all.clone();
8840 move |action, _ctx| {
8841 if action == accesskit::Action::Focus {
8842 catch_all.set(catch_all.get() + 1);
8843 return EventResponse::Handled;
8844 }
8845 EventResponse::Ignored
8846 }
8847 }),
8848 );
8849 tree.add(SideBySide {
8850 children: vec![other, card],
8851 });
8852 tree.layout(SizeProposal::exact(400.0, 50.0));
8853 tree.click(other);
8854 assert!(assistive_focus(&mut tree, composite));
8855 assert_eq!(tree.focused(), Some(leaf), "the keyboard is on its stop");
8856 assert_eq!(catch_all.get(), 0);
8857 }
8858
8859 #[derive(Debug)]
8862 struct SyntheticOwner {
8863 advertises: bool,
8864 }
8865
8866 impl crate::widget::Widget for SyntheticOwner {
8867 fn layout_response(
8868 &self,
8869 proposal: SizeProposal,
8870 _ctx: &crate::widget::LayoutContext,
8871 ) -> crate::widget::LayoutResponse {
8872 proposal.resolve(0.0, 0.0).into()
8873 }
8874
8875 fn accessibility(&self, builder: &mut crate::accessibility::AccessNodeBuilder) {
8876 let advertises = self.advertises;
8877 builder.push_scene_child(1, crate::accessibility::SyntheticKind::ChartMark, |child| {
8878 child.set_role(accesskit::Role::GraphicsObject);
8879 if advertises {
8880 child.add_action(accesskit::Action::Focus);
8881 }
8882 });
8883 }
8884 }
8885
8886 fn catch_all_card(tree: &mut WidgetTree, child: WidgetId) -> (WidgetId, Rc<Cell<u32>>) {
8888 let catch_all = Rc::new(Cell::new(0));
8889 let card = tree.add(
8890 SideBySide {
8891 children: vec![child],
8892 }
8893 .focusable(true)
8894 .on_access_action({
8895 let catch_all = catch_all.clone();
8896 move |action, _ctx| {
8897 if action == accesskit::Action::Focus {
8898 catch_all.set(catch_all.get() + 1);
8899 return EventResponse::Handled;
8900 }
8901 EventResponse::Ignored
8902 }
8903 }),
8904 );
8905 (card, catch_all)
8906 }
8907
8908 #[test]
8912 fn a_disabled_synthetic_owner_or_composite_offers_nothing_upward() {
8913 let mut tree = WidgetTree::new();
8914 let other = tree.add(FillWidget::new().focusable());
8915 let owner = tree.add(SyntheticOwner { advertises: true }.focusable(true));
8916 let leaf = tree.add(FillWidget::new().focusable());
8917 let composite = tree.add(
8918 SideBySide {
8919 children: vec![leaf],
8920 }
8921 .access_customize(|b| b.add_action(accesskit::Action::Focus)),
8922 );
8923 let group = tree.add(SideBySide {
8924 children: vec![owner, composite],
8925 });
8926 let (card, catch_all) = catch_all_card(&mut tree, group);
8927 tree.add(SideBySide {
8928 children: vec![other, card],
8929 });
8930 tree.layout(SizeProposal::exact(400.0, 50.0));
8931 let _ = tree.sync_accessibility();
8932 tree.enabled_when(owner, crate::signal::Signal::new(false));
8933 tree.enabled_when(composite, crate::signal::Signal::new(false));
8934 tree.layout(SizeProposal::exact(400.0, 50.0));
8935 tree.click(other);
8936
8937 let mark = crate::accessibility::synthetic_node_id(
8938 owner,
8939 1,
8940 crate::accessibility::SyntheticKind::ChartMark,
8941 );
8942 let handled = tree.dispatch_access_action(
8943 mark,
8944 accesskit::Action::Focus,
8945 None,
8946 &mut crate::window::NoopWindowOps,
8947 );
8948 assert!(!handled, "a disabled owner's item");
8949 assert!(
8950 !assistive_focus(&mut tree, composite),
8951 "a disabled composite"
8952 );
8953 assert_eq!(tree.focused(), Some(other));
8954 assert_eq!(catch_all.get(), 0, "no ancestor was asked");
8955 }
8956
8957 #[test]
8960 fn a_synthetic_node_that_offers_no_focus_is_offered_to_no_one() {
8961 let mut tree = WidgetTree::new();
8962 let other = tree.add(FillWidget::new().focusable());
8963 let owner = tree.add(SyntheticOwner { advertises: false });
8965 let (card, catch_all) = catch_all_card(&mut tree, owner);
8966 tree.add(SideBySide {
8967 children: vec![other, card],
8968 });
8969 tree.layout(SizeProposal::exact(400.0, 50.0));
8970 let _ = tree.sync_accessibility();
8971 tree.click(other);
8972 let mark = crate::accessibility::synthetic_node_id(
8973 owner,
8974 1,
8975 crate::accessibility::SyntheticKind::ChartMark,
8976 );
8977 let _ = tree.dispatch_access_action(
8978 mark,
8979 accesskit::Action::Focus,
8980 None,
8981 &mut crate::window::NoopWindowOps,
8982 );
8983 assert_eq!(catch_all.get(), 0, "no handler was asked");
8984 }
8985
8986 #[test]
8990 fn an_answer_that_moves_no_focus_is_no_success() {
8991 let mut tree = WidgetTree::new();
8992 let other = tree.add(FillWidget::new().focusable());
8993 let item = tree
8994 .add(FillWidget::new().access_customize(|b| b.add_action(accesskit::Action::Focus)));
8995 let owner = tree.add(
8996 SideBySide {
8997 children: vec![item],
8998 }
8999 .focusable(true)
9000 .on_access_action(|action, _ctx| {
9001 if action == accesskit::Action::Focus {
9002 EventResponse::Handled
9003 } else {
9004 EventResponse::Ignored
9005 }
9006 }),
9007 );
9008 tree.add(SideBySide {
9009 children: vec![other, owner],
9010 });
9011 tree.layout(SizeProposal::exact(400.0, 50.0));
9012 let visible = tree.focus_visible_signal();
9013 tree.click(other);
9014 assert!(!assistive_focus(&mut tree, item), "reported unhandled");
9015 assert_eq!(tree.focused(), Some(other));
9016 assert!(!visible.get(), "no ring on the mouse-focused control");
9017 }
9018
9019 #[test]
9024 fn a_programmatic_focus_leaves_the_modality_alone() {
9025 let mut tree = WidgetTree::new();
9026 let a = tree.add(FillWidget::new().focusable());
9027 let b = tree.add(FillWidget::new().focusable());
9028 let root = tree.add(SideBySide {
9029 children: vec![a, b],
9030 });
9031 tree.layout(SizeProposal::exact(200.0, 100.0));
9032 let _ = root;
9033 let visible = tree.focus_visible_signal();
9034
9035 tree.press_key(Key::Tab, Modifiers::NONE);
9036 assert_eq!(tree.focused(), Some(a));
9037 assert!(visible.get());
9038 tree.focus(b);
9039 assert!(
9040 visible.get(),
9041 "a scripted focus does not hide a keyboard ring"
9042 );
9043
9044 tree.click(a);
9045 assert!(!visible.get());
9046 tree.focus(b);
9047 assert!(
9048 !visible.get(),
9049 "and does not reveal one after a click either",
9050 );
9051 }
9052
9053 #[test]
9059 fn a_mouse_still_focuses_on_press() {
9060 let mut tree = WidgetTree::new();
9061 let w = tree.add(FillWidget::new().focusable());
9062 tree.layout(SizeProposal::exact(100.0, 50.0));
9063 let center = tree.bounds(w).center();
9064
9065 tree.dispatch_event(WidgetEvent::pointer_down(
9066 center,
9067 PointerButton::Primary,
9068 Modifiers::NONE,
9069 ));
9070 assert_eq!(
9071 tree.focused(),
9072 Some(w),
9073 "focus lands on the press for an indirect pointer",
9074 );
9075 }
9076
9077 #[test]
9079 fn a_finger_focuses_on_release() {
9080 let (mut tree, _clock) = tree_on_a_clock();
9081 let w = tree.add(FillWidget::new().focusable());
9082 tree.layout(SizeProposal::exact(100.0, 50.0));
9083 let center = tree.bounds(w).center();
9084
9085 let id = contact_id();
9086 tree.dispatch_pointer(contact(id, PointerPhase::Down, center, EventTime::ZERO));
9087 assert_eq!(
9088 tree.focused(),
9089 None,
9090 "a finger that has only landed has chosen nothing yet",
9091 );
9092
9093 tree.dispatch_pointer(contact(
9094 id,
9095 PointerPhase::Up,
9096 center,
9097 EventTime::from_millis(40),
9098 ));
9099 assert_eq!(tree.focused(), Some(w));
9100 assert_eq!(
9101 tree.focus_origin().and_then(FocusOrigin::pointer_kind),
9102 Some(teksilo_tokens::PointerKind::Touch),
9103 "the origin names the device that delivered it",
9104 );
9105 }
9106
9107 #[test]
9111 fn a_release_on_a_different_focusable_moves_no_focus() {
9112 let (mut tree, _clock) = tree_on_a_clock();
9113 let a = tree.add(FillWidget::new().focusable());
9114 let b = tree.add(FillWidget::new().focusable());
9115 let root = tree.add(SideBySide {
9116 children: vec![a, b],
9117 });
9118 tree.layout(SizeProposal::exact(200.0, 50.0));
9119 let _ = root;
9120
9121 let on_a = tree.bounds(a).center();
9122 let on_b = tree.bounds(b).center();
9123 let id = contact_id();
9124 tree.dispatch_pointer(contact(id, PointerPhase::Down, on_a, EventTime::ZERO));
9125 tree.dispatch_pointer(contact(
9126 id,
9127 PointerPhase::Move,
9128 on_b,
9129 EventTime::from_millis(20),
9130 ));
9131 tree.dispatch_pointer(contact(
9132 id,
9133 PointerPhase::Up,
9134 on_b,
9135 EventTime::from_millis(40),
9136 ));
9137
9138 assert_eq!(
9139 tree.focused(),
9140 None,
9141 "the guard is `the release landed on the same focusable as the press`",
9142 );
9143 }
9144
9145 #[test]
9152 fn a_mouse_press_visual_is_unchanged() {
9153 let mut tree = WidgetTree::new();
9154 let (w, pressed) = tappable(&mut tree);
9155 tree.layout(SizeProposal::exact(100.0, 50.0));
9156 let center = tree.bounds(w).center();
9157
9158 assert!(!pressed.get(), "not pressed at rest");
9159 tree.dispatch_event(WidgetEvent::pointer_down(
9160 center,
9161 PointerButton::Primary,
9162 Modifiers::NONE,
9163 ));
9164 assert!(pressed.get(), "an indirect pointer lights up on the press");
9165 assert!(
9166 !tree.press_pending(w),
9167 "and never waits: a mouse opens no pan session, so there is no \
9168 ambiguity to wait out",
9169 );
9170 assert_eq!(tree.pressed_by(w), Some(PointerId::MOUSE));
9171
9172 tree.dispatch_event(WidgetEvent::pointer_up(
9173 center,
9174 PointerButton::Primary,
9175 Modifiers::NONE,
9176 ));
9177 assert!(!pressed.get(), "the release clears it");
9178 assert_eq!(tree.pressed_by(w), None);
9179 }
9180
9181 #[test]
9185 fn a_slide_off_clears_the_visual_and_re_entry_restores_it() {
9186 let (mut tree, _clock) = tree_on_a_clock();
9187 let (w, pressed) = tappable(&mut tree);
9188 tree.layout(SizeProposal::exact(100.0, 200.0));
9189 let inside = tree.bounds(w).center();
9190 let outside = Point::new(inside.x, inside.y + 400.0);
9191
9192 let id = contact_id();
9193 tree.dispatch_pointer(contact(id, PointerPhase::Down, inside, EventTime::ZERO));
9194 assert!(
9195 pressed.get(),
9196 "nothing here claims a pan, so no delay applies"
9197 );
9198
9199 tree.dispatch_pointer(contact(
9200 id,
9201 PointerPhase::Move,
9202 outside,
9203 EventTime::from_millis(20),
9204 ));
9205 assert!(!pressed.get(), "the press has left its target");
9206 assert!(!tree.press_is_inside(w));
9207 assert_eq!(
9208 tree.pressed_by(w),
9209 Some(id),
9210 "the contact still holds the press — it is the *visual* that is off",
9211 );
9212
9213 tree.dispatch_pointer(contact(
9214 id,
9215 PointerPhase::Move,
9216 inside,
9217 EventTime::from_millis(40),
9218 ));
9219 assert!(pressed.get(), "sliding back on restores it");
9220
9221 tree.dispatch_pointer(contact(
9222 id,
9223 PointerPhase::Up,
9224 inside,
9225 EventTime::from_millis(60),
9226 ));
9227 assert!(!pressed.get());
9228 }
9229
9230 #[test]
9233 fn a_second_contact_cannot_clear_the_first_visual() {
9234 let (mut tree, _clock) = tree_on_a_clock();
9235 let (w, pressed) = tappable(&mut tree);
9236 tree.layout(SizeProposal::exact(100.0, 50.0));
9237 let bounds = tree.bounds(w);
9238 let first_at = Point::new(bounds.x + 20.0, bounds.y + 25.0);
9239 let second_at = Point::new(bounds.x + 70.0, bounds.y + 25.0);
9240
9241 let first = contact_id();
9242 let second = contact_id();
9243 tree.dispatch_pointer(contact(
9244 first,
9245 PointerPhase::Down,
9246 first_at,
9247 EventTime::ZERO,
9248 ));
9249 assert!(pressed.get());
9250 assert_eq!(tree.pressed_by(w), Some(first));
9251
9252 tree.dispatch_pointer(contact(
9253 second,
9254 PointerPhase::Down,
9255 second_at,
9256 EventTime::from_millis(10),
9257 ));
9258 assert_eq!(
9259 tree.pressed_by(w),
9260 Some(first),
9261 "under `MultiContact::First` the second contact is terminated before \
9262 it reaches the arena at all",
9263 );
9264
9265 tree.dispatch_pointer(contact(
9266 second,
9267 PointerPhase::Up,
9268 second_at,
9269 EventTime::from_millis(20),
9270 ));
9271 assert!(
9272 pressed.get(),
9273 "so the second contact's release cannot clear a visual it never owned",
9274 );
9275 assert_eq!(tree.pressed_by(w), Some(first));
9276
9277 tree.dispatch_pointer(contact(
9278 first,
9279 PointerPhase::Up,
9280 first_at,
9281 EventTime::from_millis(30),
9282 ));
9283 assert!(!pressed.get(), "the owner's release does clear it");
9284 }
9285
9286 #[test]
9289 fn a_cancel_clears_the_visual() {
9290 let (mut tree, _clock) = tree_on_a_clock();
9291 let (w, pressed) = tappable(&mut tree);
9292 tree.layout(SizeProposal::exact(100.0, 50.0));
9293 let center = tree.bounds(w).center();
9294
9295 let id = contact_id();
9296 tree.dispatch_pointer(contact(id, PointerPhase::Down, center, EventTime::ZERO));
9297 assert!(pressed.get());
9298
9299 tree.dispatch_pointer(contact(
9300 id,
9301 PointerPhase::Cancel,
9302 center,
9303 EventTime::from_millis(20),
9304 ));
9305 assert!(!pressed.get(), "a press that was taken away is not painted");
9306 assert_eq!(tree.pressed_by(w), None);
9307 }
9308
9309 #[test]
9312 fn a_pan_claim_clears_the_visual() {
9313 let (mut tree, clock) = tree_on_a_clock();
9314 let (row, pressed) = tappable(&mut tree);
9315 let list = tree.add(
9316 StackWidget::new()
9317 .child(row)
9318 .pan_claim(PanClaim::vertical())
9319 .on_scroll(|_e, _c| EventResponse::Handled),
9320 );
9321 tree.layout(SizeProposal::exact(200.0, 400.0));
9322 let _ = list;
9323 let start = Point::new(100.0, 200.0);
9324
9325 let id = contact_id();
9326 tree.dispatch_pointer(contact(id, PointerPhase::Down, start, EventTime::ZERO));
9327 assert!(tree.press_pending(row));
9329 clock.set(EventTime::from_millis(100));
9330 tree.tick_gestures(std::time::Instant::now());
9331 assert!(pressed.get(), "…and appears once the delay has elapsed");
9332
9333 tree.dispatch_pointer(contact(
9335 id,
9336 PointerPhase::Move,
9337 Point::new(100.0, 260.0),
9338 EventTime::from_millis(120),
9339 ));
9340 assert!(
9341 !pressed.get(),
9342 "the row lost the press to the list and must stop advertising it",
9343 );
9344 assert_eq!(tree.pressed_by(row), None);
9345 }
9346
9347 #[test]
9356 fn a_button_the_control_cannot_act_on_raises_no_visual() {
9357 let taps = Rc::new(Cell::new(0u32));
9358 let count = taps.clone();
9359 let mut tree = WidgetTree::new();
9360 let w = tree.add(FillWidget::new().focusable().on_tap(move |_e, _c| {
9361 count.set(count.get() + 1);
9362 }));
9363 let pressed = tree.pressed_signal(w);
9364 tree.layout(SizeProposal::exact(100.0, 50.0));
9365 let center = tree.bounds(w).center();
9366
9367 for button in [
9368 PointerButton::Middle,
9369 PointerButton::Back,
9370 PointerButton::Forward,
9371 ] {
9372 tree.dispatch_event(WidgetEvent::pointer_down(center, button, Modifiers::NONE));
9373 assert!(
9374 !pressed.get(),
9375 "{button:?} cannot activate an `on_tap` node, so it must not light one up",
9376 );
9377 assert_eq!(tree.pressed_by(w), None, "and owns no visual to clear");
9378 tree.dispatch_event(WidgetEvent::pointer_up(center, button, Modifiers::NONE));
9379 assert_eq!(
9380 taps.get(),
9381 0,
9382 "the tap recognizer refuses {button:?} too — that is the point",
9383 );
9384 }
9385
9386 tree.dispatch_event(WidgetEvent::pointer_down(
9388 center,
9389 PointerButton::Primary,
9390 Modifiers::NONE,
9391 ));
9392 assert!(pressed.get(), "a primary press lights up as it always has");
9393 assert_eq!(tree.pressed_by(w), Some(PointerId::MOUSE));
9394 tree.dispatch_event(WidgetEvent::pointer_up(
9395 center,
9396 PointerButton::Primary,
9397 Modifiers::NONE,
9398 ));
9399 assert!(!pressed.get());
9400 assert_eq!(taps.get(), 1);
9401 }
9402
9403 #[test]
9407 fn a_secondary_press_with_no_context_menu_raises_no_visual() {
9408 let mut tree = WidgetTree::new();
9409 let (w, pressed) = tappable(&mut tree);
9410 tree.layout(SizeProposal::exact(100.0, 50.0));
9411 let center = tree.bounds(w).center();
9412
9413 tree.dispatch_event(WidgetEvent::pointer_down(
9414 center,
9415 PointerButton::Secondary,
9416 Modifiers::NONE,
9417 ));
9418 assert!(
9419 !pressed.get(),
9420 "nothing opened, and nothing may look pressed either",
9421 );
9422 assert_eq!(tree.pressed_by(w), None);
9423 assert!(!tree.press_is_inside(w));
9424 }
9425
9426 #[test]
9430 fn a_widened_mask_widens_the_visual_with_it() {
9431 use crate::event::ButtonMask;
9432
9433 let mut tree = WidgetTree::new();
9434 let w = tree.add(
9435 FillWidget::new()
9436 .on_tap(|_e, _c| {})
9437 .accept_tap_buttons(ButtonMask::PRIMARY | ButtonMask::MIDDLE),
9438 );
9439 let pressed = tree.pressed_signal(w);
9440 tree.layout(SizeProposal::exact(100.0, 50.0));
9441 let center = tree.bounds(w).center();
9442
9443 tree.dispatch_event(WidgetEvent::pointer_down(
9444 center,
9445 PointerButton::Middle,
9446 Modifiers::NONE,
9447 ));
9448 assert!(pressed.get(), "this node really does act on a middle-click");
9449
9450 tree.dispatch_event(WidgetEvent::pointer_up(
9451 center,
9452 PointerButton::Middle,
9453 Modifiers::NONE,
9454 ));
9455 assert!(!pressed.get());
9456 }
9457
9458 #[test]
9464 fn a_press_that_raises_no_visual_still_defers_its_focus() {
9465 use teksilo_tokens::{PenKind, PointerKind};
9466
9467 let (mut tree, _clock) = tree_on_a_clock();
9468 let (w, pressed) = tappable(&mut tree);
9469 tree.layout(SizeProposal::exact(100.0, 50.0));
9470 let center = tree.bounds(w).center();
9471
9472 let id = contact_id();
9473 let barrel = |phase, t| PointerSample {
9474 pointer: PointerInfo {
9475 kind: PointerKind::Pen(PenKind::Pen),
9476 ..PointerInfo::touch(id, t)
9477 },
9478 phase,
9479 position: center,
9480 button: Some(PointerButton::Secondary),
9481 modifiers: Modifiers::NONE,
9482 coalesced: Vec::new(),
9483 };
9484
9485 tree.dispatch_pointer(barrel(PointerPhase::Down, EventTime::ZERO));
9486 assert!(!pressed.get(), "the barrel button activates nothing here");
9487 assert_eq!(tree.pressed_by(w), None);
9488 assert_eq!(
9489 tree.focused(),
9490 None,
9491 "a direct pointer has chosen nothing until it lifts",
9492 );
9493
9494 tree.dispatch_pointer(barrel(PointerPhase::Up, EventTime::from_millis(40)));
9495 assert_eq!(
9496 tree.focused(),
9497 Some(w),
9498 "the deferral is not button-gated: the release landed where the press did",
9499 );
9500 assert_eq!(
9501 tree.focus_origin().and_then(FocusOrigin::pointer_kind),
9502 Some(PointerKind::Pen(PenKind::Pen)),
9503 );
9504 }
9505
9506 #[test]
9513 fn the_feedback_delay_applies_only_inside_a_claimant() {
9514 let (mut tree, _clock) = tree_on_a_clock();
9516 let (w, pressed) = tappable(&mut tree);
9517 tree.layout(SizeProposal::exact(200.0, 400.0));
9518 let id = contact_id();
9519 let at = tree.bounds(w).center();
9520 tree.dispatch_pointer(contact(id, PointerPhase::Down, at, EventTime::ZERO));
9521 assert!(
9522 !tree.press_pending(w),
9523 "no claimant above it, so nothing to rule out",
9524 );
9525 assert!(pressed.get());
9526
9527 let (mut tree, clock) = tree_on_a_clock();
9529 let (row, pressed) = tappable(&mut tree);
9530 let list = tree.add(
9531 StackWidget::new()
9532 .child(row)
9533 .pan_claim(PanClaim::vertical())
9534 .on_scroll(|_e, _c| EventResponse::Handled),
9535 );
9536 tree.layout(SizeProposal::exact(200.0, 400.0));
9537 let _ = list;
9538 let id = contact_id();
9539 let at = Point::new(100.0, 200.0);
9540 tree.dispatch_pointer(contact(id, PointerPhase::Down, at, EventTime::ZERO));
9541 assert!(tree.press_pending(row), "a finger might be about to scroll");
9542 assert!(!pressed.get(), "so the row does not flash");
9543 assert!(
9544 tree.press_is_inside(row),
9545 "the press is real; only its visual is being withheld",
9546 );
9547
9548 clock.set(EventTime::from_millis(99));
9549 tree.tick_gestures(std::time::Instant::now());
9550 assert!(!pressed.get(), "99 ms is under the 100 ms delay");
9551
9552 clock.set(EventTime::from_millis(100));
9553 tree.tick_gestures(std::time::Instant::now());
9554 assert!(pressed.get(), "and 100 ms is it");
9555 assert!(!tree.press_pending(row));
9556 }
9557
9558 #[test]
9561 fn a_mouse_inside_a_claimant_never_waits() {
9562 let mut tree = WidgetTree::new();
9563 let (row, pressed) = tappable(&mut tree);
9564 let list = tree.add(
9565 StackWidget::new()
9566 .child(row)
9567 .pan_claim(PanClaim::vertical())
9568 .on_scroll(|_e, _c| EventResponse::Handled),
9569 );
9570 tree.layout(SizeProposal::exact(200.0, 400.0));
9571 let _ = list;
9572
9573 tree.dispatch_event(WidgetEvent::pointer_down(
9574 Point::new(100.0, 200.0),
9575 PointerButton::Primary,
9576 Modifiers::NONE,
9577 ));
9578 assert!(!tree.press_pending(row));
9579 assert!(pressed.get(), "Compact with a mouse is exactly as it was");
9580 }
9581
9582 #[test]
9589 fn a_handler_can_read_the_press_it_is_inside() {
9590 let (mut tree, _clock) = tree_on_a_clock();
9591 let seen: Rc<RefCell<Vec<(bool, bool, bool)>>> = Rc::new(RefCell::new(Vec::new()));
9592 let log = seen.clone();
9593 let row = tree.add(FillWidget::new().on_tap(|_e, _c| {}).on_pointer_event(
9594 move |event, ctx| {
9595 if matches!(event, WidgetEvent::PointerUp { .. }) {
9596 log.borrow_mut().push((
9597 ctx.is_pressed(),
9598 ctx.press_is_inside(),
9599 ctx.press_pending(),
9600 ));
9601 }
9602 EventResponse::Ignored
9603 },
9604 ));
9605 let list = tree.add(
9606 StackWidget::new()
9607 .child(row)
9608 .pan_claim(PanClaim::vertical())
9609 .on_scroll(|_e, _c| EventResponse::Handled),
9610 );
9611 tree.layout(SizeProposal::exact(200.0, 400.0));
9612 let _ = list;
9613
9614 let id = contact_id();
9615 let at = Point::new(100.0, 200.0);
9616 tree.dispatch_pointer(contact(id, PointerPhase::Down, at, EventTime::ZERO));
9617 tree.dispatch_pointer(contact(
9618 id,
9619 PointerPhase::Up,
9620 at,
9621 EventTime::from_millis(30),
9622 ));
9623
9624 assert_eq!(
9625 seen.borrow().as_slice(),
9626 &[(false, true, true)],
9627 "released inside the claimant before the delay elapsed: inside, \
9628 pending, and therefore not yet showing",
9629 );
9630 }
9631
9632 #[test]
9635 fn a_handler_outside_a_press_reads_nothing() {
9636 let mut tree = WidgetTree::new();
9637 let asked = Rc::new(Cell::new(false));
9638 let flag = asked.clone();
9639 let w = tree.add(FillWidget::new().focusable().on_key(move |_e, ctx| {
9640 flag.set(ctx.is_pressed() || ctx.press_is_inside() || ctx.press_pending());
9641 EventResponse::Ignored
9642 }));
9643 tree.layout(SizeProposal::exact(100.0, 50.0));
9644 tree.focus(w);
9645 tree.press_key(Key::ArrowDown, Modifiers::NONE);
9646 assert!(!asked.get());
9647 }
9648
9649 #[test]
9653 fn a_completed_press_leaves_the_detector_clean() {
9654 let (mut tree, _clock) = tree_on_a_clock();
9655 let (w, pressed) = tappable(&mut tree);
9656 tree.layout(SizeProposal::exact(100.0, 50.0));
9657 let at = tree.bounds(w).center();
9658
9659 let id = contact_id();
9660 tree.dispatch_pointer(contact(id, PointerPhase::Down, at, EventTime::ZERO));
9661 assert!(pressed.get());
9662 tree.dispatch_pointer(contact(
9663 id,
9664 PointerPhase::Up,
9665 at,
9666 EventTime::from_millis(30),
9667 ));
9668 tree.assert_no_leaked_pointer_state();
9669 }
9670
9671 #[test]
9675 fn the_detector_reports_a_press_still_held() {
9676 let (mut tree, _clock) = tree_on_a_clock();
9677 let (w, _pressed) = tappable(&mut tree);
9678 tree.layout(SizeProposal::exact(100.0, 50.0));
9679 let at = tree.bounds(w).center();
9680
9681 let id = contact_id();
9682 tree.dispatch_pointer(contact(id, PointerPhase::Down, at, EventTime::ZERO));
9683 let held = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
9684 tree.assert_no_leaked_pointer_state()
9685 }));
9686 let message = *held
9687 .expect_err("a live press is leaked state")
9688 .downcast::<String>()
9689 .expect("the detector panics with a message");
9690 assert!(
9691 message.contains("is still pressed by"),
9692 "the press is named in the report, got: {message}",
9693 );
9694 }
9695
9696 #[derive(Debug)]
9700 struct SideBySide {
9701 children: Vec<WidgetId>,
9702 }
9703
9704 impl crate::widget::Widget for SideBySide {
9705 fn layout_response(
9706 &self,
9707 proposal: SizeProposal,
9708 _ctx: &crate::widget::LayoutContext,
9709 ) -> crate::widget::LayoutResponse {
9710 proposal.resolve(0.0, 0.0).into()
9711 }
9712
9713 fn place_children(
9714 &self,
9715 bounds: teksilo_canvas::Rect,
9716 _proposal: SizeProposal,
9717 children: &mut [crate::widget::WidgetPlacement],
9718 _ctx: &crate::widget::LayoutContext,
9719 ) {
9720 let n = children.len().max(1) as f32;
9721 let w = bounds.width / n;
9722 for (i, child) in children.iter_mut().enumerate() {
9723 child.origin = Point::new(bounds.x + w * i as f32, bounds.y);
9724 child.size = teksilo_canvas::Size::new(w, bounds.height);
9725 }
9726 }
9727
9728 fn children(&self) -> Vec<WidgetId> {
9729 self.children.clone()
9730 }
9731 }
9732}
9733
9734#[cfg(test)]
9735mod overlay_release_dismissal_tests {
9736 use std::cell::Cell;
9746 use std::rc::Rc;
9747
9748 use teksilo_canvas::{Point, Rect, Size, SizeProposal};
9749
9750 use crate::WidgetId;
9751 use crate::event::{Modifiers, PointerButton, WidgetEvent};
9752 use crate::overlay::{DismissBehavior, OverlayPlacement, OverlayRequest};
9753 use crate::pointer::{
9754 BackendDeviceKey, EventTime, PointerId, PointerIdAllocator, PointerInfo, PointerPhase,
9755 PointerSample,
9756 };
9757 use crate::test_widgets::FillWidget;
9758 use crate::widget::{LayoutContext, LayoutResponse, Widget};
9759 use crate::widget_builder::WidgetBuilder;
9760 use crate::widget_tree::WidgetTree;
9761
9762 #[derive(Debug)]
9769 struct Panel(Size);
9770
9771 impl Widget for Panel {
9772 fn layout_response(&self, _proposal: SizeProposal, _ctx: &LayoutContext) -> LayoutResponse {
9773 self.0.into()
9774 }
9775 }
9776
9777 #[derive(Debug)]
9785 struct PageAndTrigger {
9786 children: Vec<WidgetId>,
9787 }
9788
9789 impl Widget for PageAndTrigger {
9790 fn layout_response(&self, proposal: SizeProposal, _ctx: &LayoutContext) -> LayoutResponse {
9791 proposal.resolve(0.0, 0.0).into()
9792 }
9793
9794 fn place_children(
9795 &self,
9796 bounds: Rect,
9797 _proposal: SizeProposal,
9798 children: &mut [crate::widget::WidgetPlacement],
9799 _ctx: &LayoutContext,
9800 ) {
9801 if let Some(page) = children.get_mut(0) {
9802 page.origin = bounds.origin();
9803 page.size = bounds.size();
9804 }
9805 if let Some(trigger) = children.get_mut(1) {
9806 trigger.origin = bounds.origin();
9807 trigger.size = Size::new(10.0, 10.0);
9808 }
9809 }
9810
9811 fn children(&self) -> Vec<WidgetId> {
9812 self.children.clone()
9813 }
9814 }
9815
9816 fn contact_id(n: u64) -> PointerId {
9817 PointerIdAllocator::global().begin(BackendDeviceKey::new(0x0FA2), n)
9818 }
9819
9820 fn touch(id: PointerId, phase: PointerPhase, at: Point) -> PointerSample {
9821 PointerSample {
9822 pointer: PointerInfo::touch(id, EventTime::ZERO),
9823 phase,
9824 position: at,
9825 button: None,
9826 modifiers: Modifiers::NONE,
9827 coalesced: Vec::new(),
9828 }
9829 }
9830
9831 fn page_with_a_menu() -> (WidgetTree, WidgetId, Rc<Cell<u32>>) {
9838 let mut tree = WidgetTree::new();
9839 let taps = Rc::new(Cell::new(0u32));
9840 let counter = taps.clone();
9841 let page = tree.add(
9842 FillWidget::new()
9843 .focusable()
9844 .on_tap(move |_e, _c| counter.set(counter.get() + 1)),
9845 );
9846 let trigger = tree.add(Panel(Size::new(10.0, 10.0)));
9849 let _root = tree.add(PageAndTrigger {
9850 children: vec![page, trigger],
9851 });
9852 let menu = tree.add(Panel(Size::new(200.0, 200.0)));
9853 tree.show_overlay(OverlayRequest::new(
9854 menu,
9855 trigger,
9856 OverlayPlacement::AtPointer(Point::new(100.0, 100.0)),
9857 DismissBehavior::ClickOutside,
9858 ));
9859 tree.layout(SizeProposal::exact(800.0, 600.0));
9860 assert_eq!(tree.active_overlays().len(), 1, "the menu is open");
9861 (tree, page, taps)
9862 }
9863
9864 fn outside() -> Point {
9865 Point::new(600.0, 500.0)
9866 }
9867
9868 fn inside_menu() -> Point {
9869 Point::new(150.0, 150.0)
9870 }
9871
9872 #[test]
9879 fn the_suppressed_down_leaves_nothing_pressed_or_captured_beneath() {
9880 let (mut tree, page, taps) = page_with_a_menu();
9881 let finger = contact_id(1);
9882 tree.dispatch_pointer(touch(finger, PointerPhase::Down, outside()));
9883
9884 assert_eq!(
9885 tree.active_overlays().len(),
9886 1,
9887 "the press does not close the menu; the release does"
9888 );
9889 assert_eq!(tree.pressed_by(page), None, "nothing beneath is pressed");
9890 let entry = tree.pointers.get(finger).expect("the contact is live");
9891 assert_eq!(entry.captured_by, None, "nothing beneath captured it");
9892 assert!(entry.sequence.is_none(), "no arbitration was opened");
9893 assert_eq!(taps.get(), 0);
9894 }
9895
9896 #[test]
9898 fn a_touch_tap_outside_a_menu_closes_it_and_actuates_nothing() {
9899 let (mut tree, page, taps) = page_with_a_menu();
9900 let finger = contact_id(2);
9901 tree.dispatch_pointer(touch(finger, PointerPhase::Down, outside()));
9902 tree.dispatch_pointer(touch(finger, PointerPhase::Up, outside()));
9903
9904 assert!(tree.active_overlays().is_empty(), "the menu closed");
9905 assert_eq!(taps.get(), 0, "the page beneath was never tapped");
9906 assert_eq!(tree.pressed_by(page), None);
9907 tree.assert_no_leaked_pointer_state();
9908 }
9909
9910 #[test]
9913 fn a_cancelled_press_aborts_the_arm() {
9914 let (mut tree, page, taps) = page_with_a_menu();
9915 let finger = contact_id(3);
9916 tree.dispatch_pointer(touch(finger, PointerPhase::Down, outside()));
9917 tree.dispatch_pointer(touch(finger, PointerPhase::Cancel, outside()));
9918
9919 assert_eq!(tree.active_overlays().len(), 1, "the menu survives");
9920 assert_eq!(taps.get(), 0);
9921 assert_eq!(tree.pressed_by(page), None);
9922 tree.assert_no_leaked_pointer_state();
9923 }
9924
9925 #[test]
9929 fn a_press_slid_onto_the_menu_dismisses_nothing() {
9930 let (mut tree, _page, taps) = page_with_a_menu();
9931 let finger = contact_id(4);
9932 tree.dispatch_pointer(touch(finger, PointerPhase::Down, outside()));
9933 tree.dispatch_pointer(touch(finger, PointerPhase::Move, inside_menu()));
9934 tree.dispatch_pointer(touch(finger, PointerPhase::Up, inside_menu()));
9935
9936 assert_eq!(tree.active_overlays().len(), 1, "the menu survives");
9937 assert_eq!(taps.get(), 0);
9938 tree.assert_no_leaked_pointer_state();
9939 }
9940
9941 #[test]
9944 fn a_second_contact_cannot_dismiss_what_the_first_is_manipulating() {
9945 let (mut tree, _page, _taps) = page_with_a_menu();
9946 let first = contact_id(5);
9947 let second = contact_id(6);
9948
9949 tree.dispatch_pointer(touch(first, PointerPhase::Down, inside_menu()));
9950 assert!(
9951 tree.pointers
9952 .get(first)
9953 .is_some_and(|e| e.sequence.is_some()),
9954 "the first contact holds a live press inside the menu"
9955 );
9956
9957 tree.dispatch_pointer(touch(second, PointerPhase::Down, outside()));
9958 tree.dispatch_pointer(touch(second, PointerPhase::Up, outside()));
9959 assert_eq!(
9960 tree.active_overlays().len(),
9961 1,
9962 "the menu the first finger is holding must not close under it"
9963 );
9964
9965 tree.dispatch_pointer(touch(first, PointerPhase::Up, inside_menu()));
9968 let third = contact_id(7);
9969 tree.dispatch_pointer(touch(third, PointerPhase::Down, outside()));
9970 tree.dispatch_pointer(touch(third, PointerPhase::Up, outside()));
9971 assert!(tree.active_overlays().is_empty());
9972 tree.assert_no_leaked_pointer_state();
9973 }
9974
9975 #[test]
9979 fn an_arm_is_not_itself_a_press_that_blocks_another_contact() {
9980 let (mut tree, _page, _taps) = page_with_a_menu();
9981 let first = contact_id(8);
9982 let second = contact_id(9);
9983
9984 tree.dispatch_pointer(touch(first, PointerPhase::Down, outside()));
9985 assert!(
9986 tree.overlay_manager().has_armed_dismiss(first),
9987 "the first contact armed"
9988 );
9989 assert!(tree.busy_press_points(second).is_empty());
9991
9992 tree.dispatch_pointer(touch(second, PointerPhase::Down, outside()));
9993 assert!(tree.overlay_manager().has_armed_dismiss(second));
9994 tree.dispatch_pointer(touch(second, PointerPhase::Up, outside()));
9995 assert!(tree.active_overlays().is_empty());
9996
9997 tree.dispatch_pointer(touch(first, PointerPhase::Up, outside()));
10000 tree.assert_no_leaked_pointer_state();
10001 }
10002
10003 #[test]
10006 fn a_touch_inside_the_menu_arms_nothing() {
10007 let (mut tree, _page, _taps) = page_with_a_menu();
10008 let finger = contact_id(10);
10009 tree.dispatch_pointer(touch(finger, PointerPhase::Down, inside_menu()));
10010 assert!(!tree.overlay_manager().has_armed_dismiss(finger));
10011 tree.dispatch_pointer(touch(finger, PointerPhase::Up, inside_menu()));
10012 assert_eq!(tree.active_overlays().len(), 1);
10013 tree.assert_no_leaked_pointer_state();
10014 }
10015
10016 #[test]
10026 fn a_contact_with_no_press_still_ends_when_the_platform_revokes_it() {
10027 let mut tree = WidgetTree::new();
10028 tree.layout(SizeProposal::exact(800.0, 600.0));
10029 let finger = contact_id(99);
10030 tree.dispatch_pointer(touch(finger, PointerPhase::Down, outside()));
10031 tree.dispatch_pointer(touch(finger, PointerPhase::Cancel, outside()));
10032 tree.assert_no_leaked_pointer_state();
10033 }
10034
10035 #[test]
10042 fn a_mouse_click_outside_a_menu_dismisses_on_the_press_and_falls_through() {
10043 let (mut tree, _page, taps) = page_with_a_menu();
10044 tree.dispatch_event(WidgetEvent::pointer_down(
10045 outside(),
10046 PointerButton::Primary,
10047 Modifiers::NONE,
10048 ));
10049 assert!(
10050 tree.active_overlays().is_empty(),
10051 "the mouse still dismisses on the press"
10052 );
10053 assert!(
10054 tree.pointers
10055 .get(PointerId::MOUSE)
10056 .is_some_and(|e| e.sequence.is_some()),
10057 "and the press still reaches the page beneath"
10058 );
10059 tree.dispatch_event(WidgetEvent::pointer_up(
10060 outside(),
10061 PointerButton::Primary,
10062 Modifiers::NONE,
10063 ));
10064 assert_eq!(taps.get(), 1, "the control beneath activated");
10065 assert!(
10066 !tree.overlay_manager().has_armed_dismiss(PointerId::MOUSE),
10067 "a mouse never arms"
10068 );
10069 tree.assert_no_leaked_pointer_state();
10070 }
10071
10072 #[test]
10079 fn a_context_menu_avoids_the_contact_that_opened_it() {
10080 fn menu_bounds(pointer: PointerInfo, at: Point) -> Rect {
10081 let mut tree = WidgetTree::new();
10082 let page = tree.add(
10083 FillWidget::new()
10084 .focusable()
10085 .context_menu(|_p, _ctx| Some(Box::new(Panel(Size::new(200.0, 160.0))))),
10086 );
10087 let _ = page;
10088 tree.layout(SizeProposal::exact(800.0, 600.0));
10089 tree.dispatch_pointer(PointerSample {
10090 pointer,
10091 phase: PointerPhase::Down,
10092 position: at,
10093 button: Some(PointerButton::Secondary),
10094 modifiers: Modifiers::NONE,
10095 coalesced: Vec::new(),
10096 });
10097 tree.layout(SizeProposal::exact(800.0, 600.0));
10098 let id = *tree
10099 .active_overlays()
10100 .first()
10101 .expect("the context menu opened");
10102 tree.overlay_manager().bounds_for(id).expect("bounds")
10103 }
10104
10105 let at = Point::new(400.0, 300.0);
10106 let finger = menu_bounds(PointerInfo::touch(contact_id(11), EventTime::ZERO), at);
10107 let contact = crate::overlay::rect_centred_on(at, crate::overlay::ASSUMED_CONTACT_PATCH);
10108 assert!(
10109 finger.x < contact.x && finger.right() <= contact.x,
10110 "a touch menu clears the contact patch: {finger:?} vs {contact:?}"
10111 );
10112
10113 let mouse = menu_bounds(PointerInfo::mouse(EventTime::ZERO), at);
10114 assert_eq!(
10115 (mouse.x, mouse.y),
10116 (at.x, at.y),
10117 "a mouse menu still opens with its corner on the pointer"
10118 );
10119 }
10120}
10121
10122#[cfg(test)]
10138mod pass_through_overlay_tests {
10139 use teksilo_canvas::{Point, Rect, SizeProposal};
10140
10141 use crate::WidgetId;
10142 use crate::overlay::{DismissBehavior, OverlayPlacement, OverlayRequest};
10143 use crate::test_widgets::FillWidget;
10144 use crate::widget::{LayoutContext, LayoutResponse, Widget};
10145 use crate::widget_builder::WidgetBuilder;
10146 use crate::widget_tree::WidgetTree;
10147
10148 #[derive(Debug)]
10151 struct HandleLayer {
10152 handle: WidgetId,
10153 at: Rect,
10154 }
10155
10156 impl Widget for HandleLayer {
10157 fn layout_response(&self, proposal: SizeProposal, _ctx: &LayoutContext) -> LayoutResponse {
10158 proposal.resolve(0.0, 0.0).into()
10159 }
10160
10161 fn place_children(
10162 &self,
10163 _bounds: Rect,
10164 _proposal: SizeProposal,
10165 children: &mut [crate::widget::WidgetPlacement],
10166 _ctx: &LayoutContext,
10167 ) {
10168 if let Some(child) = children.get_mut(0) {
10169 child.origin = self.at.origin();
10170 child.size = self.at.size();
10171 }
10172 }
10173
10174 fn children(&self) -> Vec<WidgetId> {
10175 vec![self.handle]
10176 }
10177 }
10178
10179 const HANDLE: Rect = Rect {
10180 x: 10.0,
10181 y: 10.0,
10182 width: 20.0,
10183 height: 20.0,
10184 };
10185
10186 #[derive(Clone, Copy, PartialEq)]
10188 enum RootFlag {
10189 PassThrough,
10191 HitTransparent,
10194 }
10195
10196 fn field_under_a_layer(flag: RootFlag) -> (WidgetTree, WidgetId, WidgetId) {
10202 let mut tree = WidgetTree::new();
10203 let field = tree.add(FillWidget::new());
10204 let handle = tree.add(FillWidget::new());
10205 let layer = HandleLayer { handle, at: HANDLE };
10206 let layer = match flag {
10207 RootFlag::PassThrough => tree.add(layer.event_pass_through(true)),
10208 RootFlag::HitTransparent => tree.add(layer.hit_transparent(true)),
10209 };
10210 tree.show_overlay(OverlayRequest::new(
10211 layer,
10212 field,
10213 OverlayPlacement::FullViewport,
10214 DismissBehavior::Manual,
10215 ));
10216 tree.layout(SizeProposal::exact(400.0, 200.0));
10217 assert_eq!(tree.active_overlays().len(), 1, "the layer is up");
10218 (tree, field, handle)
10219 }
10220
10221 #[test]
10223 fn a_pass_through_layer_hands_back_what_it_did_not_claim() {
10224 let (tree, field, handle) = field_under_a_layer(RootFlag::PassThrough);
10225
10226 assert_eq!(
10227 tree.hit_test(Point::new(15.0, 15.0)),
10228 Some(handle),
10229 "the layer must still win the point its own child covers"
10230 );
10231 assert_eq!(
10232 tree.hit_test(Point::new(200.0, 100.0)),
10233 Some(field),
10234 "a press the layer did not claim must reach the surface beneath it"
10235 );
10236 }
10237
10238 #[test]
10249 fn a_pass_through_root_still_hears_a_press_that_landed_on_its_child() {
10250 use std::cell::Cell;
10251 use std::rc::Rc;
10252
10253 let seen = Rc::new(Cell::new(0u32));
10254 let counter = seen.clone();
10255 let mut tree = WidgetTree::new();
10256 let field = tree.add(FillWidget::new());
10257 let handle = tree.add(FillWidget::new().on_tap(|_e, _c| {}));
10258 let layer = tree.add(
10259 HandleLayer { handle, at: HANDLE }
10260 .event_pass_through(true)
10261 .on_pointer_event(move |_event, _ctx| {
10262 counter.set(counter.get() + 1);
10263 crate::event::EventResponse::Ignored
10264 }),
10265 );
10266 tree.show_overlay(OverlayRequest::new(
10267 layer,
10268 field,
10269 OverlayPlacement::FullViewport,
10270 DismissBehavior::Manual,
10271 ));
10272 tree.layout(SizeProposal::exact(400.0, 200.0));
10273
10274 tree.pointer_down_button(Point::new(15.0, 15.0), crate::event::PointerButton::Primary);
10275 assert!(
10276 seen.get() > 0,
10277 "a pass-through root heard nothing about a press on its own child"
10278 );
10279
10280 let after_child = seen.get();
10281 tree.pointer_up_button(Point::new(15.0, 15.0), crate::event::PointerButton::Primary);
10282 tree.pointer_down_button(
10285 Point::new(200.0, 100.0),
10286 crate::event::PointerButton::Primary,
10287 );
10288 assert_eq!(
10289 seen.get(),
10290 after_child + 1,
10291 "the press-and-lift on the child accounts for the count, and the \
10292 press on the surface beneath added nothing"
10293 );
10294 }
10295
10296 #[test]
10310 fn a_hit_transparent_root_does_not_get_the_fall_through() {
10311 let (tree, field, _handle) = field_under_a_layer(RootFlag::HitTransparent);
10312
10313 assert_eq!(
10315 tree.hit_test(Point::new(15.0, 15.0)),
10316 None,
10317 "hit_transparent must exclude the subtree, or this fixture is not \
10318 testing the gate"
10319 );
10320 assert_eq!(
10321 tree.hit_test(Point::new(200.0, 100.0)),
10322 None,
10323 "the fall-through reached past an overlay that did not ask for it"
10324 );
10325 let _ = field;
10326 }
10327}
10328
10329fn note_refused_section(owner: WidgetId) {
10333 #[cfg(debug_assertions)]
10334 {
10335 thread_local! {
10336 static NOTED: std::cell::RefCell<std::collections::HashSet<WidgetId>> =
10337 std::cell::RefCell::new(std::collections::HashSet::new());
10338 }
10339 if NOTED.with(|noted| noted.borrow_mut().insert(owner)) {
10340 eprintln!(
10341 "teksilo: the context menu of {owner:?} takes no section \
10342 (Widget::append_context_menu_section), so a contribution was left out"
10343 );
10344 }
10345 }
10346 #[cfg(not(debug_assertions))]
10347 let _ = owner;
10348}
10349
10350fn logical_key_identity(key: Key) -> u64 {
10355 use std::hash::{Hash, Hasher};
10356 let key = match key {
10357 Key::Character(c) => Key::Character(c.to_ascii_lowercase()),
10358 other => other,
10359 };
10360 let mut hasher = std::collections::hash_map::DefaultHasher::new();
10361 key.hash(&mut hasher);
10362 hasher.finish()
10363}