1use crate::anim::Trigger;
34use crate::component::{Component, ComponentId};
35use crate::event::{EventArgs, EventCtx, Key, KeyEvent, PointerButton, PointerEvent, PointerKind, WheelEvent};
36use crate::geometry::{PointF, RectF, SizeF};
37use crate::platform::CursorShape;
38use crate::ui::Ui;
39
40const DOUBLE_CLICK_TIME: f64 = 0.5;
42const DOUBLE_CLICK_DISTANCE: f32 = 4.0;
44pub const DRAG_START: f32 = 5.0;
46
47pub const FORM_DRAG: &str = "aylis-form:";
50const TOUCH_SLOP: f32 = 8.0;
52const SWIPE_DISTANCE: f32 = 32.0;
55const SWIPE_SPEED: f32 = 250.0;
56const SWIPE_SCROLLED: f32 = 4.0;
57const EDGE_SWIPE: f32 = 32.0;
60const FLING_MIN_SPEED: f32 = 40.0;
62const FLING_DECAY: f32 = 3.5;
64
65#[derive(Clone, Copy, Debug)]
67struct Touch {
68 id: u64,
69 target: Option<ComponentId>,
72 start: PointF,
73 last: PointF,
74 time: f64,
75 panning: bool,
76 velocity: PointF,
77 scrolled: PointF,
80}
81
82#[derive(Clone, Copy, Debug)]
84struct Press {
85 target: ComponentId,
86 position: PointF,
88 time: f64,
89 touch: bool,
90 fired: bool,
92 menu: bool,
95}
96
97#[derive(Clone, Copy, Debug)]
99struct Fling {
100 target: Option<ComponentId>,
101 position: PointF,
102 velocity: PointF,
103 time: f64,
104}
105
106fn speed(v: PointF) -> f32 {
107 (v.x * v.x + v.y * v.y).sqrt()
108}
109
110#[derive(Clone, Debug, Default)]
112pub(crate) struct InputState {
113 pub(crate) file_hover: Option<ComponentId>,
115 drop_at: Option<PointF>,
117 hovered: Option<ComponentId>,
118 captured: Option<ComponentId>,
119 focused: Option<ComponentId>,
120 pointer_focus: bool,
123 last_click: Option<(ComponentId, f64, PointF, u8)>,
125 touch: Option<Touch>,
126 fling: Option<Fling>,
127 press: Option<Press>,
128 pub(crate) hint: Option<HintState>,
129 fingers: Vec<(u64, PointF)>,
131 pinch: Option<Pinch>,
132 after_pinch: bool,
134 pub(crate) drag: Option<Drag>,
136 pub(crate) pointer: Option<PointF>,
138 pub(crate) holding: bool,
141 pub(crate) held: std::collections::VecDeque<crate::keyflow::Held>,
142 pub(crate) draining: bool,
144 pub(crate) refused_press: bool,
146}
147
148#[derive(Clone, Debug)]
151pub(crate) struct Drag {
152 pub(crate) source: ComponentId,
153 pub(crate) data: String,
154 pub(crate) label: String,
155 pub(crate) position: PointF,
157 pub(crate) target: Option<ComponentId>,
158 pub(crate) accepted: bool,
159 pub(crate) starting: Option<u64>,
161 pub(crate) over: Option<(ComponentId, u64)>,
163 pub(crate) dropped: bool,
165 pub(crate) visual: Option<DragVisual>,
167 pub(crate) target_position: PointF,
169}
170
171#[derive(Clone, Copy, Debug, PartialEq, Eq)]
174pub enum DragEnd {
175 Dropped,
177 Nowhere,
179 Cancelled,
181}
182
183#[derive(Clone, Copy, Debug, Default, PartialEq)]
186pub struct ScreenPointer {
187 pub x: i32,
188 pub y: i32,
189 pub scale: f32,
190}
191
192#[derive(Clone, Debug, PartialEq)]
197pub struct DragVisual {
198 pub image: crate::Image,
199 pub size: SizeF,
201 pub hotspot: PointF,
203 pub opacity: f32,
205}
206
207impl DragVisual {
208 pub fn new(image: crate::Image, size: SizeF) -> Self {
211 Self { image, size, hotspot: PointF::new(size.width / 2.0, size.height * 0.6), opacity: 0.8 }
212 }
213}
214
215#[derive(Clone, Copy, Debug)]
217struct Pinch {
218 target: ComponentId,
219 ids: (u64, u64),
220 start_distance: f32,
221 start_angle: f32,
222 last_distance: f32,
223 last_angle: f32,
224 last_center: PointF,
225}
226
227fn finger_geometry(a: PointF, b: PointF) -> (f32, f32, PointF) {
229 let d = b - a;
230 ((d.x * d.x + d.y * d.y).sqrt().max(1.0), d.y.atan2(d.x), PointF::new((a.x + b.x) / 2.0, (a.y + b.y) / 2.0))
231}
232
233#[derive(Clone, Copy, Debug, PartialEq)]
235pub(crate) struct HintState {
236 pub(crate) target: ComponentId,
237 pub(crate) since: f64,
238 pub(crate) position: PointF,
240 pub(crate) shown: bool,
241}
242
243pub const HINT_DELAY: f64 = 1.0;
246
247const HINT_STILL: f32 = 3.0;
249
250impl InputState {
251 pub(crate) fn hint_due(&self, delay: f64) -> Option<f64> {
253 self.hint.filter(|h| !h.shown).map(|h| h.since + delay)
254 }
255
256 pub(crate) fn long_press_due(&self) -> Option<f64> {
259 self.press.filter(|p| !p.fired && p.touch).map(|p| p.time + crate::timers::LONG_PRESS_TIME)
260 }
261
262 pub(crate) fn take_long_press(&mut self, now: f64) -> Option<(ComponentId, PointF, bool)> {
264 let p = self.press.as_mut()?;
265 if p.fired || !p.touch || now < p.time + crate::timers::LONG_PRESS_TIME {
266 return None;
267 }
268 p.fired = true;
269 Some((p.target, p.position, p.touch))
271 }
272
273 pub(crate) fn forget(&mut self, freed: &[ComponentId]) {
275 let gone = |id: &mut Option<ComponentId>| {
276 if id.is_some_and(|i| freed.contains(&i)) {
277 *id = None;
278 }
279 };
280 gone(&mut self.hovered);
281 gone(&mut self.captured);
282 gone(&mut self.focused);
283 if let Some(t) = &mut self.touch {
284 gone(&mut t.target);
285 }
286 if let Some(f) = &mut self.fling {
287 gone(&mut f.target);
288 }
289 if self.press.is_some_and(|p| freed.contains(&p.target)) {
290 self.press = None;
291 }
292 if self.last_click.is_some_and(|(i, ..)| freed.contains(&i)) {
293 self.last_click = None;
294 }
295 }
296}
297
298impl Ui {
299 fn input_state(&mut self, root: ComponentId) -> &mut InputState {
300 self.input.entry(root).or_default()
301 }
302
303 pub(crate) fn focus_from_pointer(&self, root: ComponentId) -> bool {
305 self.input.get(&root).is_some_and(|s| s.pointer_focus)
306 }
307
308 pub fn focus_visible(&self, form: ComponentId) -> bool {
311 !self.focus_from_pointer(self.root_of(form))
312 }
313
314 pub fn open_popups(&self, form: ComponentId) -> Vec<ComponentId> {
318 let root = self.root_of(form);
319 self.children(root).iter().copied().filter(|&c| self.component(c).and_then(|c| c.popup()).is_some_and(|p| p.closes_on_outside_press() || p.dies_with().is_some())).collect()
320 }
321
322 pub fn drop_files(&mut self, root: ComponentId, pos: PointF, paths: Vec<String>) -> bool {
335 let mut target = self.hit_test(root, pos);
336 let mut tried = Vec::new();
338 while let Some(id) = target {
339 if self.with_component(id, |c, ctx| c.platform_hooks_mut().is_some_and(|h| h.files_dropped(ctx, &paths))).unwrap_or(false) {
340 self.process_events();
341 return true;
342 }
343 tried.push(id);
344 target = self.parent(id);
345 }
346 if !paths.is_empty() && self.listens(root, "on_files_drop") {
347 self.input_state(root).drop_at = Some(pos);
348 self.fire(root, "on_files_drop", &EventArgs::Text(paths.join(";")));
349 self.process_events();
350 return true;
351 }
352 let mut stack = vec![root];
353 while let Some(id) = stack.pop() {
354 if self.cb(id).is_some_and(|cb| !cb.visible() || !cb.enabled()) {
355 continue;
356 }
357 if tried.contains(&id) {
358 stack.extend(self.children(id).iter().rev().copied());
359 continue;
360 }
361 if self.with_component(id, |c, ctx| c.platform_hooks_mut().is_some_and(|h| h.files_dropped(ctx, &paths))).unwrap_or(false) {
362 self.process_events();
363 return true;
364 }
365 stack.extend(self.children(id).iter().rev().copied());
366 }
367 self.process_events();
369 false
370 }
371
372 pub fn files_hover(&mut self, root: ComponentId, pos: PointF, paths: Option<Vec<String>>) {
376 let previous = self.input_state(root).file_hover.take();
377 let Some(paths) = paths else {
378 if let Some(old) = previous.filter(|&o| self.contains(o)) {
379 self.with_component(old, |c, ctx| c.platform_hooks_mut().map(|h| h.files_hovering(ctx, None)));
380 self.process_events();
381 }
382 return;
383 };
384 let mut found = None;
385 let mut target = self.hit_test(root, pos);
386 while let Some(id) = target {
387 if self.with_component(id, |c, ctx| c.platform_hooks_mut().is_some_and(|h| h.files_hovering(ctx, Some(&paths)))).unwrap_or(false) {
388 found = Some(id);
389 break;
390 }
391 target = self.parent(id);
392 }
393 if let Some(old) = previous.filter(|&o| Some(o) != found && self.contains(o)) {
394 self.with_component(old, |c, ctx| c.platform_hooks_mut().map(|h| h.files_hovering(ctx, None)));
395 }
396 self.input_state(root).file_hover = found;
397 self.process_events();
398 }
399
400 pub fn hit_test(&self, root: ComponentId, pos: PointF) -> Option<ComponentId> {
402 self.hit_node(root, pos)
403 }
404
405 fn hit_node(&self, id: ComponentId, pos_in_parent: PointF) -> Option<ComponentId> {
406 let cb = self.cb(id)?;
407 if !cb.visible() || (cb.design_only && !self.design_mode) {
408 return None;
409 }
410 let b = cb.bounds();
411 let local = unscale(cb, unrotate(cb, pos_in_parent - b.origin() - cb.translate()));
415 let b = RectF::from_size(cb.inner_size());
416 let inside = local.x >= 0.0 && local.y >= 0.0 && local.x < b.width && local.y < b.height;
417 if cb.clip_children() && !inside {
418 return None;
419 }
420 if let Some(hit) = self.children(id).iter().rev().find_map(|&c| self.hit_node(c, local)) {
421 return Some(hit);
422 }
423 let shape = || self.component(id).is_none_or(|c| c.contains_point(local, SizeF::new(b.width, b.height)));
424 let near = || {
426 let m = self.component(id).map_or(0.0, |c| c.hit_slop());
427 m > 0.0 && local.x >= -m && local.y >= -m && local.x < b.width + m && local.y < b.height + m
428 };
429 let hit = cb.hit_test() || cb.draggable() || cb.accepts_drops();
433 ((inside || near()) && hit && shape()).then_some(id)
434 }
435
436 pub fn is_effectively_enabled(&self, id: ComponentId) -> bool {
438 let mut current = Some(id);
439 while let Some(c) = current {
440 if let Some(cb) = self.cb(c) {
441 if !cb.enabled() || !cb.visible() {
442 return false;
443 }
444 }
445 current = self.parent(c);
446 }
447 self.contains(id)
448 }
449
450 pub fn hovered(&self, root: ComponentId) -> Option<ComponentId> {
452 self.input.get(&root)?.hovered
453 }
454
455 pub fn files_drop_position(&self, root: ComponentId) -> Option<PointF> {
457 self.input.get(&root)?.drop_at
458 }
459
460 pub fn hover_within(&self, id: ComponentId) -> (bool, bool) {
463 let Some(mut cur) = self.hovered(self.root_of(id)) else { return (false, false) };
464 let pressed = self.cb(cur).is_some_and(|cb| cb.state().pressed);
465 loop {
466 if cur == id {
467 return (true, pressed);
468 }
469 match self.parent(cur) {
470 Some(p) => cur = p,
471 None => return (false, false),
472 }
473 }
474 }
475
476 pub fn focused(&self, root: ComponentId) -> Option<ComponentId> {
478 self.input.get(&root)?.focused
479 }
480
481 pub fn cursor(&self, root: ComponentId) -> CursorShape {
484 if self.busy_cursor() {
486 return CursorShape::Wait;
487 }
488 let mut current = self.hovered(root);
489 while let Some(c) = current {
490 if let Some(cb) = self.cb(c) {
491 if cb.cursor() != CursorShape::Default {
492 return cb.cursor();
493 }
494 }
495 current = self.parent(c);
496 }
497 CursorShape::Default
498 }
499
500 pub fn pointer_position(&self, root: ComponentId) -> Option<PointF> {
502 self.input.get(&root).and_then(|s| s.pointer)
503 }
504
505 pub(crate) fn reveal_moved(&mut self, root: ComponentId, before: Option<PointF>, after: Option<PointF>) {
509 if before == after || self.reveal_ids.borrow().is_empty() {
510 return;
511 }
512 let ids: Vec<(ComponentId, f32)> = self.reveal_ids.borrow().iter().map(|(id, r)| (*id, *r)).collect();
513 for (id, radius) in ids {
514 let Some(cb) = self.cb(id) else {
515 self.reveal_ids.borrow_mut().remove(&id);
516 continue;
517 };
518 let size = cb.inner_size();
519 if self.root_of(id) != root {
520 continue;
521 }
522 let rect = RectF::new(0.0, 0.0, size.width, size.height);
523 for p in [before, after].into_iter().flatten() {
524 let local = self.local_point(id, p);
525 let light = RectF::new(local.x - radius, local.y - radius, radius * 2.0, radius * 2.0);
526 let part = rect.inflate(2.0).intersect(light);
527 if let Some(part) = part.filter(|r| r.width > 0.0 && r.height > 0.0) {
528 self.damage_part(id, part);
529 }
530 }
531 }
532 }
533
534 pub fn local_point(&self, id: ComponentId, pos: PointF) -> PointF {
537 let mut chain = vec![id];
538 let mut parent = self.parent(id);
539 while let Some(p) = parent {
540 chain.push(p);
541 parent = self.parent(p);
542 }
543 let local = chain.iter().rev().fold(pos, |pt, &c| match self.cb(c) {
544 Some(cb) => unscale(cb, unrotate(cb, pt - cb.bounds().origin() - cb.translate())),
545 None => pt,
546 });
547 match self.cb(id).filter(|_| self.flips_content(id)) {
549 Some(cb) => PointF::new(cb.inner_size().width - local.x, local.y),
550 None => local,
551 }
552 }
553
554 fn enabled_hit(&self, root: ComponentId, pos: PointF) -> Option<ComponentId> {
555 self.hit_test(root, pos).filter(|&id| self.is_effectively_enabled(id))
556 }
557
558 pub fn set_checked_state(&mut self, id: ComponentId, checked: bool) {
563 self.set_state_flag(id, Trigger::Checked, checked);
564 }
565
566 pub fn set_checked_state_instant(&mut self, id: ComponentId, checked: bool) {
570 self.set_state_flag_with(id, Trigger::Checked, checked, false);
571 }
572
573 pub(crate) fn deliver(&mut self, id: ComponentId, f: impl FnOnce(&mut dyn Component, &mut EventCtx<'_>)) -> bool {
574 self.with_component(id, |c, ctx| {
575 f(c, ctx);
576 ctx.handled()
577 })
578 .unwrap_or(false)
579 }
580
581 fn set_state_flag(&mut self, id: ComponentId, trigger: Trigger, value: bool) {
582 self.set_state_flag_with(id, trigger, value, true);
583 }
584
585 fn set_state_flag_with(&mut self, id: ComponentId, trigger: Trigger, value: bool, animate: bool) {
586 let Some(cb) = self.cb_mut(id) else { return };
587 let state = cb.state_mut();
588 let flag = match trigger {
589 Trigger::Hover => &mut state.hover,
590 Trigger::Pressed => &mut state.pressed,
591 Trigger::Focused => &mut state.focused,
592 Trigger::Checked => &mut state.checked,
593 Trigger::None | Trigger::Appear | Trigger::HoverWithin => return,
594 };
595 if *flag != value {
596 *flag = value;
597 let heirs = self.children(id).iter().any(|&c| self.cb(c).is_some_and(|cb| cb.inherit_state()));
601 if heirs || !self.drawing_unchanged(id) {
602 self.damage(id);
603 }
604 if animate {
605 self.run_triggers(id, trigger, value);
606 } else {
607 self.settle_triggers(id, trigger, value);
608 }
609 }
610 }
611
612 fn set_hover(&mut self, root: ComponentId, new: Option<ComponentId>) {
617 let old = self.input_state(root).hovered;
618 if old == new {
619 return;
620 }
621 self.input_state(root).hovered = new;
622 let chain = |ui: &Self, from: Option<ComponentId>| {
625 let mut out = Vec::new();
626 let mut cur = from.filter(|&c| ui.contains(c));
627 while let Some(c) = cur {
628 if ui.cb(c).is_some_and(|cb| cb.hover_within()) {
629 out.push(c);
630 }
631 cur = ui.parent(c);
632 }
633 out
634 };
635 let (left, entered) = (chain(self, old), chain(self, new));
636 for c in left.iter().filter(|c| !entered.contains(c)).chain(entered.iter().filter(|c| !left.contains(c))) {
637 self.damage(*c);
638 }
639 if !self.hover_within_hosts().is_empty() {
642 let hosts = self.hover_within_hosts().to_vec();
643 let ancestors = |ui: &Self, from: Option<ComponentId>| {
644 let mut out = Vec::new();
645 let mut cur = from.filter(|&c| ui.contains(c));
646 while let Some(c) = cur {
647 if hosts.contains(&c) {
648 out.push(c);
649 }
650 cur = ui.parent(c);
651 }
652 out
653 };
654 let (left, entered) = (ancestors(self, old), ancestors(self, new));
655 for &c in left.iter().filter(|c| !entered.contains(c)) {
656 self.run_triggers(c, Trigger::HoverWithin, false);
657 }
658 for &c in entered.iter().filter(|c| !left.contains(c)) {
659 self.run_triggers(c, Trigger::HoverWithin, true);
660 }
661 }
662 if let Some(old) = old.filter(|&o| self.contains(o)) {
663 self.set_state_flag(old, Trigger::Hover, false);
664 self.fire(old, "on_pointer_leave", &EventArgs::None);
665 self.deliver(old, |c, ctx| c.pointer_leave(ctx));
666 }
667 if let Some(new) = new {
668 self.set_state_flag(new, Trigger::Hover, true);
669 self.fire(new, "on_pointer_enter", &EventArgs::None);
670 self.deliver(new, |c, ctx| c.pointer_enter(ctx));
671 }
672 }
673
674 pub fn pointer_move(&mut self, root: ComponentId, event: PointerEvent) {
676 self.report(&crate::activity::Activity::PointerMove { form: root, event });
677 if self.input_blocked(root) {
678 return; }
680 self.update_layout();
681 if event.kind == PointerKind::Touch && (self.finger_move(root, event) || self.touch_pan(root, event)) {
682 return;
683 }
684 if self.drag_move(root, event) {
685 return;
686 }
687 let state = self.input_state(root);
688 if state.press.is_some_and(|p| !p.fired && ((p.position.x - event.position.x).abs() > TOUCH_SLOP || (p.position.y - event.position.y).abs() > TOUCH_SLOP)) {
689 state.press = None;
690 }
691 let hit = self.enabled_hit(root, event.position);
692 self.set_hover(root, hit);
693 self.update_hint(root, hit, event.position, event.kind == PointerKind::Touch);
694 let at = (event.kind != PointerKind::Touch).then_some(event.position);
695 let before = std::mem::replace(&mut self.input_state(root).pointer, at);
696 self.reveal_moved(root, before, at);
697 let target = self.input_state(root).captured.or(hit);
698 if let Some(target) = target {
699 let e = PointerEvent { position: self.local_point(target, event.position), ..event };
700 self.fire(target, "on_pointer_move", &EventArgs::Pointer(e));
701 self.deliver(target, |c, ctx| c.pointer_move(ctx, &e));
702 }
703 }
704
705 fn update_hint(&mut self, root: ComponentId, hit: Option<ComponentId>, position: PointF, touch: bool) {
707 let mut target = None;
708 let mut cur = hit;
709 while let Some(c) = cur.filter(|_| !touch) {
710 if self.cb(c).is_some_and(|cb| !cb.hint().is_empty()) {
711 target = Some(c);
712 break;
713 }
714 if c == root {
715 break;
716 }
717 cur = self.parent(c);
718 }
719 let now = self.time;
720 let state = self.input_state(root);
721 let old = state.hint;
722 match (old, target) {
723 (Some(h), Some(t)) if h.target == t => {
724 if !h.shown {
728 let d = position - h.position;
729 let moved = d.x.abs() > HINT_STILL || d.y.abs() > HINT_STILL;
730 state.hint = Some(if moved { HintState { position, since: now, ..h } } else { h });
731 }
732 return;
733 }
734 (_, Some(t)) => state.hint = Some(HintState { target: t, since: now, position, shown: false }),
735 (_, None) => state.hint = None,
736 }
737 if old.is_some_and(|h| h.shown) {
738 self.request_repaint();
739 }
740 }
741
742 pub(crate) fn hide_hint(&mut self, root: ComponentId) {
744 if let Some(h) = self.input_state(root).hint.take() {
745 if h.shown {
746 self.request_repaint();
747 }
748 }
749 }
750
751 pub fn visible_hint(&self, root: ComponentId) -> Option<(String, PointF)> {
753 let h = self.input.get(&root)?.hint.filter(|h| h.shown)?;
754 let text = self.cb(h.target)?.hint().to_string();
755 Some((text, h.position))
756 }
757
758 pub fn pointer_down(&mut self, root: ComponentId, event: PointerEvent) {
760 self.report(&crate::activity::Activity::PointerDown { form: root, event });
761 if let Some(modal) = self.blocking_modal(root) {
765 self.window_command(modal, crate::WindowCommand::Show);
766 self.window_command(modal, crate::WindowCommand::RequestAttention(false));
767 return;
768 }
769 if self.busy_blocks_input() {
771 self.input_state(root).refused_press = true;
772 return;
773 }
774 if matches!(event.button, PointerButton::Back | PointerButton::Forward) && self.navigate(root, event.button == PointerButton::Forward) {
777 return;
778 }
779 self.hide_hint(root);
780 self.update_layout();
781 let hit = self.enabled_hit(root, event.position);
782 self.dismiss_popups(root, hit);
783 let touch = event.kind == PointerKind::Touch;
784 if touch {
785 if self.finger_down(root, event) {
786 return;
787 }
788 let now = self.time;
789 let state = self.input_state(root);
790 if state.touch.is_some_and(|t| t.id != event.pointer_id) {
791 return;
792 }
793 state.fling = None;
795 let p = event.position;
796 state.touch = Some(Touch { id: event.pointer_id, target: hit, start: p, last: p, time: now, panning: false, velocity: PointF::ZERO, scrolled: PointF::ZERO });
797 }
798 self.set_hover(root, hit);
799 let Some(target) = hit else { return };
800
801 let now = self.time;
802 let state = self.input_state(root);
803 let click_count = match state.last_click {
804 Some((id, time, pos, count))
805 if id == target
806 && now - time <= DOUBLE_CLICK_TIME
807 && (pos.x - event.position.x).abs() <= DOUBLE_CLICK_DISTANCE
808 && (pos.y - event.position.y).abs() <= DOUBLE_CLICK_DISTANCE =>
809 {
810 count.saturating_add(1)
811 }
812 _ => 1,
813 };
814 state.last_click = Some((target, now, event.position, click_count));
815 if event.button == PointerButton::Primary {
816 state.captured = Some(target);
817 state.press = Some(Press { target, position: event.position, time: now, touch, fired: false, menu: false });
818 }
819
820 if event.button == PointerButton::Primary {
821 self.set_state_flag(target, Trigger::Pressed, true);
822 }
823 if !touch {
824 if let Some(focusable) = self.focusable_ancestor(target) {
825 self.input_state(root).pointer_focus = true;
826 self.set_focus(focusable);
827 }
828 }
829
830 let e = PointerEvent { position: self.local_point(target, event.position), click_count, ..event };
831 self.fire(target, "on_pointer_down", &EventArgs::Pointer(e));
832 if click_count == 2 && event.button == PointerButton::Primary {
833 self.fire(target, "on_dbl_click", &EventArgs::Pointer(e));
834 }
835 self.deliver(target, |c, ctx| c.pointer_down(ctx, &e));
836 if event.button == PointerButton::Primary {
837 self.tell_ancestors(target, |c, ctx| c.child_pressed(ctx, target, &e));
838 }
839 }
840
841 fn tell_ancestors(&mut self, target: ComponentId, f: impl Fn(&mut dyn crate::ChildPointer, &mut EventCtx<'_>)) {
843 let mut current = self.parent(target);
844 while let Some(id) = current {
845 self.with_component(id, |c, ctx| {
846 if let Some(watch) = c.child_pointer_mut() {
847 f(watch, ctx);
848 }
849 });
850 current = self.parent(id);
851 }
852 }
853
854 fn dismiss_popups(&mut self, root: ComponentId, hit: Option<ComponentId>) {
860 let inside = |ui: &Ui, area: ComponentId| {
862 let mut current = hit;
863 while let Some(c) = current {
864 if c == area {
865 return true;
866 }
867 current = ui.parent(c);
868 }
869 false
870 };
871 let doomed: Vec<(ComponentId, Option<ComponentId>)> = self
872 .children(root)
873 .iter()
874 .filter(|&&c| self.cb(c).is_none_or(|cb| cb.visible()))
875 .filter_map(|&c| self.component(c).and_then(|c| c.popup()).filter(|p| p.closes_on_outside_press()).map(|p| (c, p.dies_with())))
876 .filter(|&(popup, owner)| !inside(self, popup) && !owner.is_some_and(|o| inside(self, o)))
877 .collect();
878 for (popup, owner) in doomed {
879 let mut focused = self.input_state(root).focused;
880 while let Some(f) = focused.filter(|&f| f != popup) {
881 focused = self.parent(f);
882 }
883 if focused.is_some() {
884 self.clear_focus(root);
885 }
886 let kept = self.with_component(popup, |c, ctx| c.popup_mut().is_some_and(|p| p.dismissed(ctx))).unwrap_or(false);
887 if !kept {
888 self.free(popup);
889 }
890 if let Some(owner) = owner.filter(|&o| self.contains(o)) {
891 self.damage(owner);
892 }
893 }
894 }
895
896 pub fn pointer_up(&mut self, root: ComponentId, event: PointerEvent) {
899 self.report(&crate::activity::Activity::PointerUp { form: root, event });
900 if self.input_blocked(root) {
901 return; }
903 if std::mem::take(&mut self.input_state(root).refused_press) {
906 return;
907 }
908 self.update_layout();
909 if event.kind == PointerKind::Touch && self.finger_up(root, event) {
910 return;
911 }
912 if event.kind == PointerKind::Touch {
913 if self.input_state(root).touch.is_some_and(|t| t.id == event.pointer_id && t.panning && t.last != event.position) {
915 self.touch_pan(root, event);
916 }
917 let now = self.time;
918 if self.overscroll_active() {
920 self.overscroll_release();
921 }
922 let state = self.input_state(root);
923 match state.touch {
924 Some(t) if t.id != event.pointer_id => return,
925 Some(t) => {
926 state.touch = None;
927 if t.panning {
928 let moving = now - t.time < 0.1;
930 if moving && speed(t.velocity) >= FLING_MIN_SPEED {
931 state.fling = Some(Fling { target: t.target, position: t.start, velocity: t.velocity, time: now });
932 self.request_repaint();
933 }
934 if moving {
935 self.swipe_check(root, t);
936 }
937 let mut current = t.target.filter(|&c| self.contains(c));
939 while let Some(id) = current {
940 self.with_component(id, |c, ctx| c.touch_end(ctx));
941 current = self.parent(id);
942 }
943 return;
944 }
945 }
946 None => {}
947 }
948 }
949 if event.button == PointerButton::Primary && self.drag_drop(root) {
950 return;
951 }
952 let press = if event.button == PointerButton::Primary { self.input_state(root).press.take() } else { None };
953 let long_pressed = press.is_some_and(|p| p.fired);
954 if press.is_some_and(|p| p.menu) {
956 let state = self.input_state(root);
957 state.captured = None;
958 state.touch = None;
959 return;
960 }
961 let captured = if event.button == PointerButton::Primary {
962 self.input_state(root).captured.take()
963 } else {
964 None
965 };
966 let hit = self.enabled_hit(root, event.position);
967 let Some(target) = captured.or(hit).filter(|&t| self.contains(t)) else { return };
968
969 if event.button == PointerButton::Primary {
970 self.set_state_flag(target, Trigger::Pressed, false);
971 }
972 if event.kind == PointerKind::Touch && captured.is_some() {
974 if let Some(focusable) = self.focusable_ancestor(target) {
975 self.input_state(root).pointer_focus = true;
976 self.set_focus(focusable);
977 }
978 }
979 let e = PointerEvent { position: self.local_point(target, event.position), ..event };
980 self.fire(target, "on_pointer_up", &EventArgs::Pointer(e));
981 let pointer = crate::ClickPointer {
984 position: e.position,
985 form_position: event.position,
986 button: event.button,
987 modifiers: event.modifiers,
988 kind: event.kind,
989 click_count: event.click_count,
990 };
991 let outer = self.click_source.replace((target, pointer));
992 self.deliver(target, |c, ctx| c.pointer_up(ctx, &e));
993
994 if event.button == PointerButton::Primary && hit == Some(target) && self.is_effectively_enabled(target) && !long_pressed {
995 self.with_component(target, |c, ctx| c.click(ctx));
996 if self.contains(target) {
997 self.tell_ancestors(target, |c, ctx| c.child_clicked(ctx, target));
998 }
999 }
1000 self.click_source = outer;
1001 if event.button == PointerButton::Secondary && hit == Some(target) {
1002 self.open_popup_menu(target, event.position);
1003 }
1004 self.set_hover(root, self.enabled_hit(root, event.position));
1006 }
1007
1008 pub fn begin_drag(&mut self, data: impl Into<String>, label: impl Into<String>) {
1012 self.drag_request = Some((data.into(), label.into()));
1013 }
1014
1015 pub fn set_drag_image(&mut self, visual: Option<DragVisual>) {
1019 let mut applied = false;
1020 for state in self.input.values_mut() {
1021 if let Some(d) = state.drag.as_mut() {
1022 d.visual = visual.clone();
1023 applied = true;
1024 }
1025 }
1026 if applied {
1027 self.request_repaint();
1028 } else {
1029 self.drag_visual_request = visual;
1030 }
1031 }
1032
1033 pub fn drag_visual(&self, root: ComponentId) -> Option<(DragVisual, PointF)> {
1035 let d = self.input.get(&root)?.drag.as_ref()?;
1036 Some((d.visual.clone()?, d.position))
1037 }
1038
1039 pub fn set_native_drag_image(&mut self, on: bool) {
1042 self.native_drag_image = on;
1043 }
1044
1045 pub fn native_drag_image(&self) -> bool {
1046 self.native_drag_image
1047 }
1048
1049 pub fn reject_drop(&mut self) {
1052 self.drop_rejected = true;
1053 }
1054
1055 pub fn drag_data(&self, root: ComponentId) -> Option<&str> {
1057 self.input.get(&root)?.drag.as_ref().map(|d| d.data.as_str())
1058 }
1059
1060 pub fn drag_view(&self, root: ComponentId) -> Option<(String, PointF, Option<ComponentId>)> {
1062 let d = self.input.get(&root)?.drag.as_ref()?;
1063 Some((d.label.clone(), d.position, d.target.filter(|_| d.accepted)))
1064 }
1065
1066 pub fn begin_drag_now(&mut self, source: ComponentId, data: impl Into<String>, label: impl Into<String>, visual: Option<DragVisual>, position: PointF) -> bool {
1072 let root = self.root_of(source);
1073 if self.input_state(root).drag.is_some() {
1074 return false;
1075 }
1076 let state = self.input_state(root);
1077 state.press = None;
1078 if let Some(c) = state.captured.take() {
1079 self.set_state_flag(c, Trigger::Pressed, false);
1080 }
1081 self.hide_hint(root);
1082 let data = data.into();
1083 self.input_state(root).drag = Some(Drag {
1084 source,
1085 label: label.into(),
1086 data,
1087 position,
1088 target: None,
1089 accepted: false,
1090 starting: None,
1091 over: None,
1092 dropped: false,
1093 visual,
1094 target_position: position,
1095 });
1096 let target = self.drop_target_at(root, position, source);
1097 self.drag_retarget(root, target, position, position);
1098 true
1099 }
1100
1101 pub fn set_screen_pointer(&mut self, pointer: Option<ScreenPointer>) {
1105 self.screen_pointer = pointer;
1106 }
1107
1108 pub fn screen_pointer(&self) -> Option<ScreenPointer> {
1110 self.screen_pointer
1111 }
1112
1113 pub fn window_drag_over(&mut self, form: ComponentId, over: Option<(ComponentId, PointF)>) {
1119 let data = format!("{FORM_DRAG}{}", form.to_u64());
1120 let target = over.filter(|&(f, _)| f != form && self.contains(f)).and_then(|(f, pos)| {
1121 let mut cur = self.enabled_hit(f, pos);
1122 while let Some(c) = cur {
1123 if self.hook_target(c, &data) {
1124 return Some((c, pos));
1125 }
1126 cur = self.parent(c);
1127 }
1128 None
1129 });
1130 let old = self.window_drag.and_then(|(f, t, _)| t.filter(|_| f == form));
1131 if let Some(old) = old.filter(|&o| Some(o) != target.map(|(t, _)| t) && self.contains(o)) {
1132 self.deliver(old, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_leave(ctx) });
1133 }
1134 if let Some((t, pos)) = target {
1135 let local = self.local_point(t, pos);
1136 self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_hover(ctx, &data, local) });
1137 }
1138 self.window_drag = Some((form, target.map(|(t, _)| t), target.map_or(PointF::default(), |(_, p)| p)));
1139 self.request_repaint();
1140 }
1141
1142 pub fn window_drag_end(&mut self, form: ComponentId) -> bool {
1145 let Some((f, target, pos)) = self.window_drag.take() else { return false };
1146 let Some(t) = target.filter(|&t| f == form && self.contains(t)) else { return false };
1147 let data = format!("{FORM_DRAG}{}", form.to_u64());
1148 let local = self.local_point(t, pos);
1149 self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_receive(ctx, &data, local) });
1150 self.request_repaint();
1151 true
1152 }
1153
1154 fn hook_target(&self, id: ComponentId, data: &str) -> bool {
1156 self.component(id).and_then(|c| c.drag_drop()).is_some_and(|d| d.drop_accepts(self, id, data))
1157 }
1158
1159 fn draggable_ancestor(&self, root: ComponentId, id: ComponentId) -> Option<ComponentId> {
1161 let mut cur = Some(id);
1162 while let Some(c) = cur {
1163 if self.cb(c).is_some_and(|cb| cb.draggable()) {
1164 return Some(c);
1165 }
1166 if c == root {
1167 return None;
1168 }
1169 cur = self.parent(c);
1170 }
1171 None
1172 }
1173
1174 fn drop_target_at(&self, root: ComponentId, pos: PointF, source: ComponentId) -> Option<ComponentId> {
1179 let data = self.input.values().find_map(|s| s.drag.as_ref().filter(|d| d.source == source).map(|d| d.data.clone())).unwrap_or_default();
1180 let mut cur = self.enabled_hit(root, pos);
1181 while let Some(c) = cur {
1182 if !data.is_empty() && self.hook_target(c, &data) {
1183 return Some(c);
1184 }
1185 if c == source {
1186 return None;
1187 }
1188 if self.cb(c).is_some_and(|cb| cb.accepts_drops() || !cb.drop_types().is_empty()) {
1189 let mut up = self.parent(c);
1191 while let Some(p) = up {
1192 if p == source {
1193 return None;
1194 }
1195 up = self.parent(p);
1196 }
1197 return Some(c);
1198 }
1199 if c == root {
1200 return None;
1201 }
1202 cur = self.parent(c);
1203 }
1204 None
1205 }
1206
1207 fn drag_move(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1210 if self.input_state(root).drag.is_none() && !self.start_drag(root, event) {
1211 return false;
1212 }
1213 let Some(drag) = self.input_state(root).drag.clone() else { return false };
1214 let target = self.drop_target_at(root, event.position, drag.source);
1215 self.drag_retarget(root, target, event.position, event.position);
1216 true
1217 }
1218
1219 pub fn drag_over_form(&mut self, root: ComponentId, form: Option<ComponentId>, pos: PointF) {
1223 let Some(drag) = self.input.get(&root).and_then(|s| s.drag.clone()) else { return };
1224 let target = form.filter(|&f| f != root).and_then(|f| self.drop_target_at(f, pos, drag.source));
1225 let position = drag.position;
1226 self.drag_retarget(root, target, position, pos);
1227 }
1228
1229 pub fn dragging(&self, root: ComponentId) -> bool {
1231 self.input.get(&root).is_some_and(|s| s.drag.is_some())
1232 }
1233
1234 fn start_drag(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1238 let state = self.input_state(root);
1239 let Some(press) = state.press.filter(|p| !p.fired && !p.touch) else { return false };
1240 if (press.position.x - event.position.x).abs() <= DRAG_START && (press.position.y - event.position.y).abs() <= DRAG_START {
1241 return false;
1242 }
1243 let Some(source) = self.draggable_ancestor(root, press.target) else { return false };
1244 let declared = self.cb(source).map(|cb| (cb.drag_data().to_string(), cb.drag_label().to_string())).filter(|(d, _)| !d.is_empty());
1246 let declared = declared.or_else(|| self.component(source).and_then(|c| c.drag_drop()).and_then(|d| d.drag_item(self)));
1247 self.drag_request = None;
1248 self.drag_visual_request = None;
1249 let mut pending = None;
1250 let (data, label) = match self.ask(source, "on_drag_start", &EventArgs::None) {
1251 crate::question::Asked::Answered(crate::question::Answer::Refused(_)) => return false,
1252 crate::question::Asked::Answered(answer) => {
1253 let answered = answer.value("data").and_then(|v| v.to_str().ok()).filter(|d| !d.is_empty()).map(|d| {
1254 let label = answer.value("label").and_then(|v| v.to_str().ok()).unwrap_or(d).to_string();
1255 (d.to_string(), label)
1256 });
1257 match self.drag_request.take().or(answered).or(declared) {
1258 Some(d) => d,
1259 None => return false,
1260 }
1261 }
1262 crate::question::Asked::Deferred(token) => {
1263 pending = Some(token);
1266 let (root2, declared2) = (root, declared.clone());
1267 self.on_answer(token, move |ui, answer| ui.drag_start_answered(root2, answer, declared2));
1268 declared.unwrap_or_default()
1269 }
1270 };
1271 let state = self.input_state(root);
1272 state.press = None;
1273 if let Some(c) = state.captured.take() {
1274 self.set_state_flag(c, Trigger::Pressed, false);
1275 }
1276 self.hide_hint(root);
1277 let label = if label.is_empty() { data.clone() } else { label };
1278 let visual = self.drag_visual_request.take().or_else(|| {
1280 let image = self.cb(source).and_then(|cb| cb.drag_image())?;
1281 self.component(image)?.drag_drop()?.drag_visual(self, source)
1282 });
1283 self.input_state(root).drag = Some(Drag { source, data, label, position: event.position, target: None, accepted: false, starting: pending, over: None, dropped: false, visual, target_position: event.position });
1284 true
1285 }
1286
1287 fn drag_start_answered(&mut self, root: ComponentId, answer: crate::question::Answer, declared: Option<(String, String)>) {
1289 let Some(drag) = self.input.get_mut(&root).and_then(|s| s.drag.as_mut()) else { return };
1290 drag.starting = None;
1291 let data = answer.value("data").and_then(|v| v.to_str().ok()).map(str::to_string).filter(|d| !d.is_empty());
1292 let label = answer.value("label").and_then(|v| v.to_str().ok()).map(str::to_string);
1293 match (answer.is_refused(), data.or_else(|| declared.as_ref().map(|d| d.0.clone()))) {
1294 (false, Some(data)) => {
1295 drag.label = label.filter(|l| !l.is_empty()).or_else(|| declared.map(|d| d.1).filter(|l| !l.is_empty())).unwrap_or_else(|| data.clone());
1296 drag.data = data;
1297 let (target, position, dropped, target_position) = (drag.target.take(), drag.position, drag.dropped, drag.target_position);
1299 drag.accepted = false;
1300 self.drag_retarget(root, target, position, target_position);
1301 if dropped {
1302 self.drag_drop(root);
1303 }
1304 }
1305 _ => {
1306 self.cancel_drag(root);
1307 }
1308 }
1309 }
1310
1311 fn drag_retarget(&mut self, root: ComponentId, target: Option<ComponentId>, position: PointF, target_position: PointF) {
1316 let Some(drag) = self.input_state(root).drag.clone() else { return };
1317 let mut accepted = drag.accepted;
1318 let mut over = drag.over;
1319 if let Some(old) = drag.target.filter(|&t| Some(t) != target && self.hook_target(t, &drag.data)) {
1321 self.deliver(old, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_leave(ctx) });
1322 }
1323 if let Some(t) = target.filter(|&t| drag.starting.is_none() && self.hook_target(t, &drag.data)) {
1324 let local = self.local_point(t, target_position);
1325 let data = drag.data.clone();
1326 self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_hover(ctx, &data, local) });
1327 if let Some(d) = self.input_state(root).drag.as_mut() {
1328 d.position = position;
1329 d.target = Some(t);
1330 d.accepted = true;
1331 d.over = None;
1332 d.target_position = target_position;
1333 }
1334 self.request_repaint();
1335 return;
1336 }
1337 if target == drag.target && drag.accepted && drag.starting.is_none()
1340 && let Some(t) = target
1341 {
1342 let local = self.local_point(t, target_position);
1343 self.fire(t, "on_drag_move", &EventArgs::Pointer(crate::PointerEvent { position: local, ..Default::default() }));
1344 }
1345 if target != drag.target && drag.starting.is_none() {
1346 if let Some(old) = drag.target.filter(|&o| self.contains(o)) {
1348 self.fire(old, "on_drag_leave", &EventArgs::Text(drag.data.clone()));
1349 }
1350 accepted = false;
1351 over = None;
1352 if let Some(t) = target {
1353 let types = self.cb(t).map(|cb| cb.drop_types().to_string()).unwrap_or_default();
1354 if !types.is_empty() {
1355 let kind = drag.data.split(':').next().unwrap_or_default().trim();
1356 accepted = types.split([';', ',']).map(str::trim).any(|k| k.eq_ignore_ascii_case(kind));
1357 } else {
1358 self.drop_rejected = false;
1359 match self.ask(t, "on_drag_over", &EventArgs::Text(drag.data.clone())) {
1360 crate::question::Asked::Answered(answer) => accepted = drag_accepted(&answer) && !std::mem::take(&mut self.drop_rejected),
1361 crate::question::Asked::Deferred(token) => {
1362 over = Some((t, token));
1363 self.on_answer(token, move |ui, answer| ui.drag_over_answered(root, t, token, answer));
1364 }
1365 }
1366 }
1367 }
1368 }
1369 if let Some(d) = self.input_state(root).drag.as_mut() {
1370 d.position = position;
1371 d.target = target;
1372 d.accepted = accepted;
1373 d.over = over;
1374 d.target_position = target_position;
1375 }
1376 self.request_repaint();
1377 }
1378
1379 fn drag_over_answered(&mut self, root: ComponentId, target: ComponentId, token: u64, answer: crate::question::Answer) {
1381 let Some(drag) = self.input.get_mut(&root).and_then(|s| s.drag.as_mut()) else { return };
1382 if drag.over != Some((target, token)) {
1383 return;
1384 }
1385 drag.over = None;
1386 drag.accepted = drag_accepted(&answer);
1387 let dropped = drag.dropped;
1388 self.request_repaint();
1389 if dropped {
1390 self.drag_drop(root);
1391 }
1392 }
1393
1394 fn drag_drop(&mut self, root: ComponentId) -> bool {
1397 let Some(drag) = self.input_state(root).drag.as_mut() else { return false };
1398 if drag.starting.is_some() || drag.over.is_some() {
1399 drag.dropped = true;
1400 return true;
1401 }
1402 let Some(drag) = self.input_state(root).drag.take() else { return false };
1403 let dropped = drag.accepted && drag.target.is_some_and(|t| self.contains(t));
1404 if let Some(t) = drag.target.filter(|_| dropped) {
1405 if self.hook_target(t, &drag.data) {
1406 let local = self.local_point(t, drag.target_position);
1407 self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_receive(ctx, &drag.data, local) });
1408 } else {
1409 self.drop_point = Some(self.local_point(t, drag.target_position));
1411 self.fire(t, "on_drag_drop", &EventArgs::Text(drag.data.clone()));
1412 }
1413 }
1414 if self.contains(drag.source) {
1415 let end = if dropped { crate::DragEnd::Dropped } else { crate::DragEnd::Nowhere };
1416 self.deliver(drag.source, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drag_ended(ctx, &drag.data, end) });
1417 }
1418 if self.contains(drag.source) {
1419 self.fire(drag.source, "on_drag_end", &EventArgs::Value(dropped.into()));
1420 }
1421 self.request_repaint();
1422 true
1423 }
1424
1425 pub fn drop_point(&self) -> Option<PointF> {
1427 self.drop_point
1428 }
1429
1430 pub fn cancel_drag(&mut self, root: ComponentId) -> bool {
1432 let Some(drag) = self.input_state(root).drag.take() else { return false };
1433 let state = self.input_state(root);
1434 state.press = None;
1435 state.captured = None;
1436 if let Some(t) = drag.target.filter(|&t| self.hook_target(t, &drag.data)) {
1437 self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_leave(ctx) });
1438 }
1439 if self.contains(drag.source) {
1440 self.deliver(drag.source, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drag_ended(ctx, &drag.data, crate::DragEnd::Cancelled) });
1441 }
1442 if self.contains(drag.source) {
1443 self.fire(drag.source, "on_drag_end", &EventArgs::Value(false.into()));
1444 }
1445 self.request_repaint();
1446 true
1447 }
1448
1449 pub fn open_popup_menu(&mut self, target: ComponentId, at: PointF) -> bool {
1451 self.open_context_menu(target, at, false)
1452 }
1453
1454 pub(crate) fn mark_press_menu(&mut self, root: ComponentId, target: ComponentId) {
1456 if let Some(p) = self.input_state(root).press.as_mut() {
1457 p.menu = true;
1458 }
1459 self.set_state_flag(target, Trigger::Pressed, false);
1460 }
1461
1462 pub(crate) fn open_context_menu(&mut self, target: ComponentId, at: PointF, touch: bool) -> bool {
1466 let mut current = Some(target);
1467 while let Some(c) = current {
1468 if let Some(menu) = self.cb(c).and_then(|cb| cb.popup_menu()).filter(|&m| self.contains(m)) {
1469 return self.send_message(menu, &crate::event::PopupRequest { at, source: target });
1470 }
1471 current = self.parent(c);
1472 }
1473 let mut current = Some(target);
1474 while let Some(c) = current {
1475 let local = self.local_point(c, at);
1476 if self.is_effectively_enabled(c) && self.with_component(c, |comp, ctx| comp.context_menu(ctx, local, touch)).unwrap_or(false) {
1477 return true;
1478 }
1479 current = self.parent(c);
1480 }
1481 false
1482 }
1483
1484 pub fn pointer_leave(&mut self, root: ComponentId) {
1486 self.hide_hint(root);
1487 let before = self.input_state(root).pointer.take();
1488 self.reveal_moved(root, before, None);
1489 if self.input_state(root).captured.is_none() {
1490 self.set_hover(root, None);
1491 }
1492 }
1493
1494 pub fn pointer_cancel(&mut self, root: ComponentId) {
1496 if let Some(p) = self.input_state(root).pinch.take() {
1497 let e = crate::event::GestureEvent { phase: crate::event::GesturePhase::End, scale: 1.0, delta_scale: 1.0, center: p.last_center, ..Default::default() };
1498 self.gesture_from(p.target, e);
1499 }
1500 let state = self.input_state(root);
1501 state.fingers.clear();
1502 state.after_pinch = false;
1503 state.touch = None;
1504 if let Some(captured) = self.input_state(root).captured.take() {
1505 self.set_state_flag(captured, Trigger::Pressed, false);
1506 }
1507 self.set_hover(root, None);
1508 }
1509
1510 pub fn wheel(&mut self, root: ComponentId, event: WheelEvent) {
1513 self.report(&crate::activity::Activity::Wheel { form: root, event });
1514 if self.input_blocked(root) {
1515 return; }
1517 if self.busy_blocks_input() {
1518 return;
1519 }
1520 self.hide_hint(root);
1521 if !self.wheel_handled(root, event) {
1522 self.scroll_form(root, event.delta.y);
1525 }
1526 }
1527
1528 pub fn wheel_controls(&mut self, root: ComponentId, event: WheelEvent) -> bool {
1532 self.wheel_handled(root, event)
1533 }
1534
1535 fn wheel_handled(&mut self, root: ComponentId, event: WheelEvent) -> bool {
1536 self.update_layout();
1537 let hit = self.enabled_hit(root, event.position);
1538 self.wheel_from(hit, event)
1539 }
1540
1541 fn wheel_from(&mut self, start: Option<ComponentId>, event: WheelEvent) -> bool {
1543 let mut current = start;
1544 while let Some(id) = current {
1545 let e = WheelEvent { position: self.local_point(id, event.position), ..event };
1546 self.fire(id, "on_wheel", &EventArgs::Wheel(e));
1547 if self.deliver(id, |c, ctx| c.wheel(ctx, &e)) {
1548 self.sync_timer(id);
1550 return true;
1551 }
1552 if self.cb(id).is_some_and(|cb| cb.captures_wheel()) {
1555 return true;
1556 }
1557 current = self.parent(id);
1558 }
1559 false
1560 }
1561
1562 fn finger_down(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1569 let state = self.input_state(root);
1570 state.fingers.retain(|(id, _)| *id != event.pointer_id);
1571 state.fingers.push((event.pointer_id, event.position));
1572 if state.pinch.is_some() || state.after_pinch || state.fingers.len() > 2 {
1573 return true;
1574 }
1575 if state.fingers.len() < 2 {
1576 return false;
1577 }
1578 let ((a_id, a), (b_id, b)) = (state.fingers[0], state.fingers[1]);
1579 let first_target = state.touch.and_then(|t| t.target);
1580 state.touch = None;
1581 state.fling = None;
1582 state.press = None;
1583 if let Some(c) = self.input_state(root).captured.take() {
1584 self.set_state_flag(c, Trigger::Pressed, false);
1585 }
1586 let (distance, angle, center) = finger_geometry(a, b);
1587 let Some(target) = first_target.or_else(|| self.enabled_hit(root, center)) else { return true };
1588 self.input_state(root).pinch =
1589 Some(Pinch { target, ids: (a_id, b_id), start_distance: distance, start_angle: angle, last_distance: distance, last_angle: angle, last_center: center });
1590 let e = crate::event::GestureEvent { phase: crate::event::GesturePhase::Begin, center, scale: 1.0, delta_scale: 1.0, ..Default::default() };
1591 self.gesture_from(target, e);
1592 true
1593 }
1594
1595 fn finger_move(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1598 let state = self.input_state(root);
1599 if let Some(f) = state.fingers.iter_mut().find(|(id, _)| *id == event.pointer_id) {
1600 f.1 = event.position;
1601 }
1602 if state.after_pinch {
1603 return true;
1604 }
1605 let Some(mut p) = state.pinch else { return false };
1606 let pos = |id: u64| state.fingers.iter().find(|(i, _)| *i == id).map(|(_, p)| *p);
1607 let (Some(a), Some(b)) = (pos(p.ids.0), pos(p.ids.1)) else { return true };
1608 let (distance, angle, center) = finger_geometry(a, b);
1609 let wrap = |r: f32| (r + std::f32::consts::PI).rem_euclid(std::f32::consts::TAU) - std::f32::consts::PI;
1610 let e = crate::event::GestureEvent {
1611 phase: crate::event::GesturePhase::Update,
1612 center,
1613 scale: distance / p.start_distance,
1614 delta_scale: distance / p.last_distance,
1615 rotation: wrap(angle - p.start_angle),
1616 delta_rotation: wrap(angle - p.last_angle),
1617 pan: center - p.last_center,
1618 };
1619 p.last_distance = distance;
1620 p.last_angle = angle;
1621 p.last_center = center;
1622 state.pinch = Some(p);
1623 self.gesture_from(p.target, e);
1624 true
1625 }
1626
1627 fn finger_up(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1629 let state = self.input_state(root);
1630 state.fingers.retain(|(id, _)| *id != event.pointer_id);
1631 if let Some(p) = state.pinch.take() {
1632 state.after_pinch = !state.fingers.is_empty();
1633 let scale = p.last_distance / p.start_distance;
1634 let e = crate::event::GestureEvent { phase: crate::event::GesturePhase::End, center: p.last_center, scale, delta_scale: 1.0, ..Default::default() };
1635 self.gesture_from(p.target, e);
1636 return true;
1637 }
1638 if state.after_pinch {
1639 state.after_pinch = !state.fingers.is_empty();
1640 return true;
1641 }
1642 false
1643 }
1644
1645 pub fn gesture(&mut self, root: ComponentId, event: crate::event::GestureEvent) {
1648 if self.input_blocked(root) {
1649 return;
1650 }
1651 self.update_layout();
1652 if let Some(target) = self.enabled_hit(root, event.center) {
1653 self.gesture_from(target, event);
1654 }
1655 }
1656
1657 fn gesture_from(&mut self, start: ComponentId, event: crate::event::GestureEvent) -> bool {
1659 self.request_repaint();
1660 let mut current = Some(start);
1661 while let Some(id) = current {
1662 let e = crate::event::GestureEvent { center: self.local_point(id, event.center), ..event };
1663 self.fire(id, "on_gesture", &EventArgs::Gesture(e));
1664 if self.deliver(id, |c, ctx| c.gesture(ctx, &e)) {
1665 return true;
1666 }
1667 if self.cb(id).is_some_and(|cb| cb.captures_gesture()) {
1671 return true;
1672 }
1673 current = self.parent(id);
1674 }
1675 false
1676 }
1677
1678 fn swipe_check(&mut self, root: ComponentId, t: Touch) {
1686 let distance = t.last - t.start;
1687 let horizontal = distance.x.abs() >= distance.y.abs();
1688 let (along, scrolled, velocity) = if horizontal { (distance.x, t.scrolled.x, t.velocity.x) } else { (distance.y, t.scrolled.y, t.velocity.y) };
1689 if along.abs() < SWIPE_DISTANCE || velocity.abs() < SWIPE_SPEED || scrolled > SWIPE_SCROLLED || along.signum() != velocity.signum() {
1690 return;
1691 }
1692 let direction = match (horizontal, along > 0.0) {
1693 (true, true) => crate::event::SwipeDirection::Right,
1694 (true, false) => crate::event::SwipeDirection::Left,
1695 (false, true) => crate::event::SwipeDirection::Down,
1696 (false, false) => crate::event::SwipeDirection::Up,
1697 };
1698 let event = crate::event::SwipeEvent { direction, start: t.start, distance, velocity: t.velocity };
1699 let form = self.cb(root).map(|cb| cb.bounds().size()).unwrap_or_default();
1702 let at_edge = t.start.x <= EDGE_SWIPE || t.start.x >= form.width - EDGE_SWIPE || t.start.y <= EDGE_SWIPE || t.start.y >= form.height - EDGE_SWIPE;
1703 if at_edge && self.edge_swipe(root, event) {
1704 return;
1705 }
1706 let target = t.target.filter(|&c| self.is_effectively_enabled(c));
1707 self.swipe_from(target, event);
1708 }
1709
1710 fn edge_swipe(&mut self, root: ComponentId, event: crate::event::SwipeEvent) -> bool {
1712 let mut stack = vec![root];
1715 while let Some(id) = stack.pop() {
1716 if !self.cb(id).is_some_and(|cb| cb.enabled()) {
1719 continue;
1720 }
1721 if id != root && self.with_component(id, |c, ctx| c.edge_swipe(ctx, &event)).unwrap_or(false) {
1722 self.request_repaint();
1723 return true;
1724 }
1725 if self.cb(id).is_some_and(|cb| cb.visible()) {
1726 stack.extend(self.children(id).iter().rev().copied());
1727 }
1728 }
1729 false
1730 }
1731
1732 fn swipe_from(&mut self, start: Option<ComponentId>, event: crate::event::SwipeEvent) -> bool {
1734 let mut current = start;
1735 while let Some(id) = current {
1736 let e = crate::event::SwipeEvent { start: self.local_point(id, event.start), ..event };
1737 self.fire(id, "on_swipe", &EventArgs::Swipe(e));
1738 if self.deliver(id, |c, ctx| c.swipe(ctx, &e)) {
1739 self.request_repaint();
1740 return true;
1741 }
1742 if self.cb(id).is_some_and(|cb| cb.captures_gesture()) {
1744 return true;
1745 }
1746 current = self.parent(id);
1747 }
1748 false
1749 }
1750
1751 fn pans_on_touch(&self, id: ComponentId) -> bool {
1757 let mut current = Some(id);
1758 while let Some(c) = current {
1759 if self.cb(c).is_some_and(|cb| !cb.pan_on_touch()) {
1760 return false;
1761 }
1762 current = self.parent(c);
1763 }
1764 true
1765 }
1766
1767 fn touch_pan(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1770 let now = self.time;
1771 let Some(mut t) = self.input_state(root).touch else { return false };
1772 if t.id != event.pointer_id {
1773 return true;
1774 }
1775 if !t.panning {
1776 let moved = event.position - t.start;
1777 if moved.x.abs() < TOUCH_SLOP && moved.y.abs() < TOUCH_SLOP {
1778 return false;
1779 }
1780 let captured = self.input_state(root).captured;
1781 if captured.is_some_and(|c| !self.pans_on_touch(c)) {
1782 self.input_state(root).touch = None;
1784 return false;
1785 }
1786 if let Some(c) = self.input_state(root).captured.take() {
1788 self.set_state_flag(c, Trigger::Pressed, false);
1789 }
1790 self.set_hover(root, None);
1791 self.input_state(root).press = None;
1792 t.panning = true;
1793 }
1794 let delta = event.position - t.last;
1795 let dt = (now - t.time).max(0.004) as f32;
1796 let v = PointF::new(delta.x / dt, delta.y / dt);
1797 t.velocity = PointF::new(t.velocity.x * 0.5 + v.x * 0.5, t.velocity.y * 0.5 + v.y * 0.5);
1798 t.last = event.position;
1799 t.time = now;
1800 self.input_state(root).touch = Some(t);
1801 self.update_layout();
1802 let target = t.target.filter(|&c| self.is_effectively_enabled(c));
1803 let host = self.overscroll_host(target);
1806 let delta = match host {
1807 Some(h) => self.overscroll_take_back(h, delta),
1808 None => delta,
1809 };
1810 let mut scrolled = false;
1811 if delta != PointF::ZERO {
1812 scrolled = self.wheel_from(target, WheelEvent { position: t.start, delta, touch: true, ..Default::default() });
1813 if !scrolled {
1814 match host {
1815 Some(h) => self.overscroll_drag(h, delta),
1816 None => scrolled = self.scroll_form(root, delta.y),
1817 }
1818 }
1819 }
1820 if scrolled {
1821 if let Some(t) = self.input_state(root).touch.as_mut() {
1822 t.scrolled = PointF::new(t.scrolled.x + delta.x.abs(), t.scrolled.y + delta.y.abs());
1823 }
1824 }
1825 true
1826 }
1827
1828 pub(crate) fn is_flinging(&self) -> bool {
1830 self.input.values().any(|s| s.fling.is_some())
1831 }
1832
1833 pub(crate) fn tick_flings(&mut self) {
1836 let now = self.time;
1837 let roots: Vec<ComponentId> = self.input.iter().filter(|(_, s)| s.fling.is_some()).map(|(&r, _)| r).collect();
1838 for root in roots {
1839 let Some(mut f) = self.input_state(root).fling else { continue };
1840 let dt = (now - f.time).clamp(0.0, 0.05) as f32;
1842 if dt <= 0.0 {
1843 continue;
1844 }
1845 let delta = PointF::new(f.velocity.x * dt, f.velocity.y * dt);
1846 let keep = (-FLING_DECAY * dt).exp();
1847 f.velocity = PointF::new(f.velocity.x * keep, f.velocity.y * keep);
1848 f.time = now;
1849 self.input_state(root).fling = Some(f);
1850 self.update_layout();
1851 let target = f.target.filter(|&c| self.is_effectively_enabled(c));
1852 let moved = self.wheel_from(target, WheelEvent { position: f.position, delta, touch: true, ..Default::default() })
1853 || self.scroll_form(root, delta.y);
1854 if (!moved && speed(delta) >= 1.0) || speed(f.velocity) < FLING_MIN_SPEED {
1856 self.input_state(root).fling = None;
1857 if !moved && speed(f.velocity) >= FLING_MIN_SPEED {
1859 if let Some(host) = self.overscroll_host(target) {
1860 self.overscroll_absorb(host, f.velocity);
1861 }
1862 }
1863 }
1864 }
1865 }
1866
1867 fn can_take_focus(&self, id: ComponentId) -> bool {
1872 self.cb(id).is_some_and(|cb| cb.can_focus()) && self.is_effectively_enabled(id)
1873 }
1874
1875 fn focusable_ancestor(&self, id: ComponentId) -> Option<ComponentId> {
1876 let mut current = Some(id);
1877 while let Some(c) = current {
1878 if self.can_take_focus(c) {
1879 return Some(c);
1880 }
1881 current = self.parent(c);
1882 }
1883 None
1884 }
1885
1886 pub fn set_focus(&mut self, id: ComponentId) -> bool {
1889 if !self.can_take_focus(id) {
1890 return false;
1891 }
1892 let root = self.root_of(id);
1893 let old = self.input_state(root).focused;
1894 if old == Some(id) {
1895 return true;
1896 }
1897 self.input_state(root).focused = Some(id);
1898 if let Some(old) = old.filter(|&o| self.contains(o)) {
1899 self.set_state_flag(old, Trigger::Focused, false);
1900 self.fire(old, "on_exit", &EventArgs::None);
1901 self.deliver(old, |c, ctx| c.focus_exit(ctx));
1902 }
1903 self.set_state_flag(id, Trigger::Focused, true);
1904 self.fire(id, "on_enter", &EventArgs::None);
1905 self.deliver(id, |c, ctx| c.focus_enter(ctx));
1906 true
1907 }
1908
1909 pub fn clear_focus(&mut self, root: ComponentId) {
1911 if let Some(old) = self.input_state(root).focused.take() {
1912 self.set_state_flag(old, Trigger::Focused, false);
1913 self.fire(old, "on_exit", &EventArgs::None);
1914 self.deliver(old, |c, ctx| c.focus_exit(ctx));
1915 }
1916 }
1917
1918 pub fn focus_next(&mut self, root: ComponentId, forward: bool) -> bool {
1920 let order = self.tab_order(root);
1921 if order.is_empty() {
1922 return false;
1923 }
1924 let current = self.focused(root).and_then(|f| order.iter().position(|&c| c == f));
1925 let next = match (current, forward) {
1926 (None, true) => 0,
1927 (None, false) => order.len() - 1,
1928 (Some(i), true) => (i + 1) % order.len(),
1929 (Some(i), false) => (i + order.len() - 1) % order.len(),
1930 };
1931 self.set_focus(order[next])
1932 }
1933
1934 pub fn tab_order(&self, root: ComponentId) -> Vec<ComponentId> {
1938 let mut natural = Vec::new();
1939 self.collect_tab_order(root, &mut natural);
1940 let custom = match self.get_prop(root, "tab_order") {
1941 Ok(crate::prop::PropValue::String(s)) if !s.trim().is_empty() => s,
1942 _ => return natural,
1943 };
1944 let mut order: Vec<ComponentId> = custom
1945 .split(';')
1946 .map(str::trim)
1947 .filter(|n| !n.is_empty())
1948 .filter_map(|n| self.find_in(root, n))
1949 .filter(|id| natural.contains(id))
1950 .collect();
1951 order.dedup();
1952 let rest: Vec<ComponentId> = natural.into_iter().filter(|id| !order.contains(id)).collect();
1953 order.extend(rest);
1954 order
1955 }
1956
1957 fn collect_tab_order(&self, id: ComponentId, out: &mut Vec<ComponentId>) {
1958 let Some(cb) = self.cb(id) else { return };
1959 if !cb.visible() || !cb.enabled() {
1960 return;
1961 }
1962 if cb.can_focus() && cb.tab_stop() {
1963 out.push(id);
1964 }
1965 for &c in self.children(id) {
1966 self.collect_tab_order(c, out);
1967 }
1968 }
1969
1970 pub fn key_down(&mut self, root: ComponentId, event: KeyEvent) {
1973 self.report(&crate::activity::Activity::KeyDown { form: root, event });
1974 if self.input_blocked(root) {
1975 return; }
1977 if self.hold_input(root, crate::keyflow::Held::Down(event)) {
1979 return;
1980 }
1981 if event.key == Key::Escape && self.cancel_drag(root) {
1982 return;
1983 }
1984 if !matches!(event.key, Key::Shift | Key::Control | Key::Alt | Key::Meta) {
1986 self.input_state(root).pointer_focus = false;
1987 }
1988 if let Some(forward) = self.tab_key(root, &event) {
1992 self.focus_next(root, forward);
1993 return;
1994 }
1995 if event.modifiers.alt
1999 && !event.modifiers.ctrl
2000 && !event.modifiers.shift
2001 && matches!(event.key, Key::Left | Key::Right)
2002 && self.navigate(root, event.key == Key::Right)
2003 {
2004 return;
2005 }
2006 self.key_down_flow(root, event);
2007 }
2008
2009 pub fn navigate(&mut self, root: ComponentId, forward: bool) -> bool {
2016 let args = EventArgs::Text(if forward { "forward" } else { "back" }.into());
2017 let mut at = self.focused(root).or(Some(root));
2018 while let Some(id) = at {
2019 if self.fire(id, "on_navigate", &args) {
2020 return true;
2021 }
2022 if id == root {
2023 break;
2024 }
2025 at = self.parent(id);
2026 }
2027 false
2028 }
2029
2030 pub(crate) fn deliver_key_down(&mut self, id: ComponentId, event: KeyEvent) -> bool {
2032 self.deliver(id, |c, ctx| c.key_down(ctx, &event))
2033 }
2034
2035 pub(crate) fn key_down_unhandled(&mut self, root: ComponentId, event: KeyEvent) {
2037 let plain = !event.modifiers.ctrl && !event.modifiers.alt && !event.modifiers.shift && !event.modifiers.meta;
2040 if plain && !event.repeat && matches!(event.key, Key::Enter | Key::Escape) {
2041 let prop = if event.key == Key::Enter { "default_button" } else { "cancel_button" };
2042 if let Some(button) = self.flagged_button(root, prop) {
2043 self.click(button);
2044 return;
2045 }
2046 }
2047 if event.key == Key::Tab && !event.modifiers.ctrl && !event.modifiers.alt {
2048 self.focus_next(root, !event.modifiers.shift);
2049 } else if !event.repeat && !self.dispatch_shortcut(root, event) {
2050 if let (true, false, Key::Char(c)) = (event.modifiers.alt, event.modifiers.ctrl, event.key) {
2052 if let Some(id) = self.mnemonic_target(root, c) {
2053 self.activate_mnemonic(id);
2054 }
2055 }
2056 }
2057 }
2058
2059 fn flagged_button(&self, root: ComponentId, prop: &str) -> Option<ComponentId> {
2062 let mut stack = vec![root];
2063 while let Some(id) = stack.pop() {
2064 if id != root && self.cb(id).is_some_and(|cb| !cb.visible() || !cb.enabled()) {
2065 continue;
2066 }
2067 if id != root && matches!(self.get_prop(id, prop), Ok(crate::prop::PropValue::Bool(true))) {
2068 return Some(id);
2069 }
2070 stack.extend(self.children(id).iter().rev().copied());
2071 }
2072 None
2073 }
2074
2075 fn tab_key(&self, root: ComponentId, event: &KeyEvent) -> Option<bool> {
2077 let list = |prop: &str| match self.get_prop(root, prop) {
2078 Ok(crate::prop::PropValue::String(s)) => crate::keys::parse_shortcut_list(&s),
2079 _ => Vec::new(),
2080 };
2081 let forward = if list("tab_keys").into_iter().any(|s| crate::keys::shortcut_matches(s, event)) {
2082 true
2083 } else if list("back_tab_keys").into_iter().any(|s| crate::keys::shortcut_matches(s, event)) {
2084 false
2085 } else {
2086 return None;
2087 };
2088 let captured = self.focused(root).and_then(|f| self.component(f)).is_some_and(|c| c.captures_key(event));
2089 (!captured).then_some(forward)
2090 }
2091
2092 pub fn mnemonic_target(&self, root: ComponentId, c: char) -> Option<ComponentId> {
2095 let c = c.to_lowercase().next()?;
2096 let mut stack = vec![root];
2097 while let Some(id) = stack.pop() {
2098 if self.cb(id).is_some_and(|cb| !cb.visible() || !cb.enabled()) && id != root {
2099 continue;
2100 }
2101 if id != root && self.component(id).and_then(|comp| comp.mnemonic_text()).and_then(crate::keys::mnemonic) == Some(c) {
2102 return Some(id);
2103 }
2104 stack.extend(self.children(id).iter().rev());
2105 }
2106 None
2107 }
2108
2109 pub fn mnemonic_conflicts(&self, root: ComponentId) -> Vec<(char, Vec<ComponentId>)> {
2112 let mut seen: Vec<(char, Vec<ComponentId>)> = Vec::new();
2113 let mut stack = vec![root];
2114 while let Some(id) = stack.pop() {
2115 if let Some(m) = self.component(id).and_then(|c| c.mnemonic_text()).and_then(crate::keys::mnemonic) {
2116 match seen.iter_mut().find(|(c, _)| *c == m) {
2117 Some((_, ids)) => ids.push(id),
2118 None => seen.push((m, vec![id])),
2119 }
2120 }
2121 stack.extend(self.children(id).iter().rev());
2122 }
2123 seen.retain(|(_, ids)| ids.len() > 1);
2124 seen
2125 }
2126
2127 fn activate_mnemonic(&mut self, id: ComponentId) {
2131 if let Ok(crate::prop::PropValue::Component(Some(target))) = self.get_prop(id, "focus_control") {
2132 self.set_focus(target);
2133 return;
2134 }
2135 if self.component(id).is_some_and(|c| c.mnemonic_focuses_child()) {
2136 let root = self.root_of(id);
2137 let order = self.tab_order(root);
2138 if let Some(&first) = order.iter().find(|&&c| self.is_ancestor(id, c)) {
2139 self.set_focus(first);
2140 }
2141 return;
2142 }
2143 if self.cb(id).is_some_and(|cb| cb.can_focus()) {
2144 self.set_focus(id);
2145 }
2146 self.click(id);
2147 }
2148
2149 fn is_ancestor(&self, ancestor: ComponentId, id: ComponentId) -> bool {
2151 let mut current = self.parent(id);
2152 while let Some(p) = current {
2153 if p == ancestor {
2154 return true;
2155 }
2156 current = self.parent(p);
2157 }
2158 false
2159 }
2160
2161 pub fn char_filter_of(&self, id: ComponentId) -> Option<crate::keys::CharFilter> {
2164 use crate::prop::PropValue;
2165 let text = |p: &str| match self.get_prop(id, p) {
2166 Ok(PropValue::String(s)) => s,
2167 _ => String::new(),
2168 };
2169 let flag = |p: &str| matches!(self.get_prop(id, p), Ok(PropValue::Bool(true)));
2170 let filter = crate::keys::CharFilter {
2171 allowed: text("allowed_chars"),
2172 blocked: text("blocked_chars"),
2173 only_allowed: flag("only_allowed"),
2174 overrides: flag("chars_override"),
2175 map: text("char_map"),
2176 case: match self.get_prop(id, "char_case") {
2177 Ok(PropValue::Enum(e)) => <crate::keys::CharCase as crate::prop::PropEnum>::from_name(&e).unwrap_or_default(),
2178 _ => Default::default(),
2179 },
2180 };
2181 (!filter.is_empty()).then_some(filter)
2182 }
2183
2184 pub fn accepts_char(&self, id: ComponentId, own: Option<&crate::keys::CharFilter>, ch: char) -> bool {
2189 let mut chain = Vec::new();
2190 match own {
2191 Some(f) => chain.push(f.clone()),
2192 None => chain.extend(self.char_filter_of(id)),
2193 }
2194 let mut current = self.parent(id);
2195 while let Some(p) = current {
2196 chain.extend(self.char_filter_of(p));
2197 current = self.parent(p);
2198 }
2199 crate::keys::char_allowed(&chain, ch)
2200 }
2201
2202 pub fn filter_text(&self, id: ComponentId, own: Option<&crate::keys::CharFilter>, text: &str) -> String {
2205 let mut chain = Vec::new();
2206 match own {
2207 Some(f) => chain.push(f.clone()),
2208 None => chain.extend(self.char_filter_of(id)),
2209 }
2210 let case = chain.first().map(|f| f.case).unwrap_or_default();
2211 let mut current = self.parent(id);
2212 while let Some(p) = current {
2213 chain.extend(self.char_filter_of(p));
2214 current = self.parent(p);
2215 }
2216 let mapped: String = text.chars().map(|c| crate::keys::map_char(&chain, c)).collect();
2217 case.apply(&mapped).chars().filter(|&c| crate::keys::char_allowed(&chain, c)).collect()
2218 }
2219
2220 fn dispatch_shortcut(&mut self, root: ComponentId, event: KeyEvent) -> bool {
2224 let menus = self.active_popup_menus(root);
2225 let mut current = self.focused(root).and_then(|f| self.parent(f));
2226 while let Some(p) = current.filter(|&p| p != root) {
2227 if self.class_name(p) == Some("Form") && self.dispatch_in(p, event, &menus) {
2228 return true;
2229 }
2230 current = self.parent(p);
2231 }
2232 self.dispatch_in(root, event, &menus)
2233 }
2234
2235 fn active_popup_menus(&self, root: ComponentId) -> Vec<ComponentId> {
2239 let mut out = Vec::new();
2240 let mut current = self.focused(root).or(Some(root));
2241 while let Some(id) = current {
2242 if let Ok(crate::PropValue::Component(Some(menu))) = self.get_prop(id, "popup_menu") {
2243 out.push(menu);
2244 }
2245 current = self.parent(id);
2246 }
2247 out
2248 }
2249
2250 fn dispatch_in(&mut self, root: ComponentId, event: KeyEvent, menus: &[ComponentId]) -> bool {
2251 let mut stack = vec![root];
2252 while let Some(id) = stack.pop() {
2253 if self.cb(id).is_some_and(|cb| !cb.visible() || !cb.enabled()) && id != root {
2254 continue;
2255 }
2256 if self.class_name(id) == Some("PopupMenu") && !menus.contains(&id) {
2257 continue;
2258 }
2259 if self.deliver(id, |c, ctx| c.shortcut(ctx, &event)) {
2260 return true;
2261 }
2262 stack.extend(self.children(id).iter().rev());
2263 }
2264 false
2265 }
2266
2267 pub fn key_up(&mut self, root: ComponentId, event: KeyEvent) {
2268 self.report(&crate::activity::Activity::KeyUp { form: root, event });
2269 if self.input_blocked(root) {
2270 return; }
2272 if self.hold_input(root, crate::keyflow::Held::Up(event)) {
2273 return;
2274 }
2275 self.bubble_key(root, |c, ctx| c.key_up(ctx, &event), "on_key_up", event);
2276 }
2277
2278 fn bubble_key(
2279 &mut self,
2280 root: ComponentId,
2281 f: impl Fn(&mut dyn Component, &mut EventCtx<'_>),
2282 event_name: &str,
2283 event: KeyEvent,
2284 ) -> bool {
2285 let mut current = self.focused(root).or(Some(root));
2286 while let Some(id) = current {
2287 self.fire(id, event_name, &EventArgs::Key(event));
2288 let handled = self.deliver(id, &f);
2289 if handled {
2290 return true;
2291 }
2292 current = self.parent(id);
2293 }
2294 false
2295 }
2296
2297 pub fn wants_text_input(&self, root: ComponentId) -> bool {
2300 self.focused(root).and_then(|f| self.component(f)).is_some_and(|c| c.accepts_text())
2301 }
2302
2303 pub fn text_input(&mut self, root: ComponentId, text: &str) {
2305 self.report(&crate::activity::Activity::Text { form: root, text });
2306 if self.input_blocked(root) {
2307 return; }
2309 if self.hold_input(root, crate::keyflow::Held::Text(text.to_string())) {
2310 return;
2311 }
2312 if let Some(id) = self.focused(root) {
2313 let text = self.filter_text(id, None, text);
2315 if text.is_empty() {
2316 return;
2317 }
2318 self.press_chars(root, id, text.chars().collect());
2319 }
2320 }
2321}
2322
2323fn unscale(cb: &crate::component::ControlBase, local: PointF) -> PointF {
2327 let s = cb.scale();
2328 if s == 1.0 { local } else { PointF::new(local.x / s, local.y / s) }
2329}
2330
2331fn unrotate(cb: &crate::component::ControlBase, local: PointF) -> PointF {
2332 let degrees = cb.rotation();
2333 if degrees == 0.0 {
2334 return local;
2335 }
2336 let b = cb.bounds();
2337 let (cx, cy) = (b.width / 2.0, b.height / 2.0);
2338 let (s, c) = (-degrees.to_radians()).sin_cos();
2339 let (dx, dy) = (local.x - cx, local.y - cy);
2340 PointF::new(cx + dx * c - dy * s, cy + dx * s + dy * c)
2341}
2342
2343fn drag_accepted(answer: &crate::question::Answer) -> bool {
2345 !answer.is_refused() && answer.flag("accept", true)
2346}