1use std::any::{Any, TypeId};
10use std::cell::{Cell, RefCell};
11use std::panic::{self, AssertUnwindSafe};
12use std::rc::{Rc, Weak};
13use std::sync::OnceLock;
14use std::time::{Duration, Instant};
15
16use crabshell_reactive::{Signal, untrack};
17
18use crate::cx::Cx;
19use crate::geometry::{Point, Rect, Size};
20use crate::keyboard::KeyHandler;
21use crate::prop::{Prop, PropKind};
22use crate::scrolling::{BarDrag, Flick};
23use crate::tree::{ButtonNode, Change, Node, NodeId, NodeKind, Tree, borrow};
24use crate::window::Window;
25
26pub(crate) const PIXELS_PER_STEP: f32 = 15.0;
28
29const VALUE120_PER_STEP: i32 = 120;
31
32pub(crate) const DRAG_THRESHOLD: f32 = 10.0;
35
36const LONG_PRESS: Duration = Duration::from_millis(800);
39
40const DOUBLE_CLICK_MS: u32 = 400;
43
44const DOUBLE_CLICK_DISTANCE: f32 = 5.0;
47
48pub(crate) struct Handler<F: ?Sized> {
50 disabled: Cell<bool>,
51 f: F,
52}
53
54impl<F> Handler<F> {
55 pub(crate) fn new(f: F) -> Handler<F> {
56 Handler {
57 disabled: Cell::new(false),
58 f,
59 }
60 }
61}
62
63pub(crate) type ClickHandler = Rc<Handler<dyn Fn(&Cx)>>;
64type ScrollHandler = Rc<Handler<dyn Fn(&Cx, i32)>>;
65pub(crate) type WheelHandler = Rc<Handler<dyn Fn(&Cx, Wheel)>>;
66pub(crate) type DragHandler = Rc<Handler<dyn Fn(&Cx, Drag)>>;
67
68pub(crate) type DragValue = Rc<dyn Any>;
72
73pub(crate) struct DropTarget {
75 pub(crate) accepts: TypeId,
76 pub(crate) handler: DropHandler,
77}
78
79pub(crate) type DropHandler = Rc<Handler<dyn Fn(&Cx, &dyn Any)>>;
81
82#[derive(Default)]
84pub(crate) struct Handlers {
85 pub(crate) click: Option<ClickHandler>,
86 pub(crate) press: Option<ClickHandler>,
87 pub(crate) release: Option<ClickHandler>,
88 pub(crate) double_click: Option<ClickHandler>,
89 pub(crate) long_press: Option<ClickHandler>,
90 pub(crate) right_click: Option<ClickHandler>,
91 pub(crate) middle_click: Option<ClickHandler>,
92 pub(crate) back: Option<ClickHandler>,
93 pub(crate) forward: Option<ClickHandler>,
94 pub(crate) scroll: Option<ScrollHandler>,
95 pub(crate) wheel: Option<WheelHandler>,
96 pub(crate) drag: Option<DragHandler>,
97 pub(crate) drop: Option<DropTarget>,
98 pub(crate) key: Option<KeyHandler>,
99}
100
101#[derive(Clone, Copy, Debug, PartialEq, Eq)]
103pub enum PointerButton {
104 Left,
106 Right,
108 Middle,
110 Back,
113 Forward,
116}
117
118#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
120pub enum ScrollSource {
121 #[default]
123 Wheel,
124 Finger,
127 Continuous,
129 WheelTilt,
131}
132
133#[derive(Clone, Copy, Debug, Default, PartialEq)]
135pub struct WheelAxis {
136 pub pixels: f32,
139 pub notches: f32,
143 pub stop: bool,
146}
147
148#[derive(Clone, Copy, Debug, Default, PartialEq)]
151pub struct Wheel {
152 pub source: ScrollSource,
154 pub x: WheelAxis,
156 pub y: WheelAxis,
158}
159
160#[derive(Clone, Copy, Debug, PartialEq, Eq)]
162pub enum DragPhase {
163 Start,
166 Move,
168 End,
171}
172
173#[derive(Clone, Copy, Debug, PartialEq)]
178pub struct Drag {
179 pub phase: DragPhase,
181 pub start: Point,
183 pub position: Point,
186 pub size: Size,
188 pub dropped: bool,
192}
193
194#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
197pub enum CursorShape {
198 #[default]
200 Default,
201 ContextMenu,
203 Help,
205 Pointer,
207 Progress,
209 Wait,
211 Cell,
213 Crosshair,
215 Text,
217 VerticalText,
219 Alias,
221 Copy,
223 Move,
225 NoDrop,
227 NotAllowed,
229 Grab,
231 Grabbing,
233 EResize,
235 NResize,
237 NeResize,
239 NwResize,
241 SResize,
243 SeResize,
245 SwResize,
247 WResize,
249 EwResize,
251 NsResize,
253 NeswResize,
255 NwseResize,
257 ColResize,
259 RowResize,
261 AllScroll,
263 ZoomIn,
265 ZoomOut,
267 DndAsk,
270 AllResize,
273}
274
275#[derive(Clone, Copy)]
277struct Press {
278 id: NodeId,
279 button: PointerButton,
280 at: Point,
283 last: Point,
284 start: Point,
286 dragging: bool,
288 long_pressed: bool,
290}
291
292#[derive(Default)]
294pub(crate) struct Pointer {
295 pub(crate) position: Option<Point>,
296 pub(crate) hovered: Option<NodeId>,
298 inside: Vec<(NodeId, Signal<bool>)>,
301 positions: Vec<(NodeId, Signal<Option<Point>>, Point)>,
304 pressed: Option<Press>,
306 pub(crate) bar: Option<BarDrag>,
308 pub(crate) flick: Option<Flick>,
311 pub(crate) gesture: Option<NodeId>,
313 last_click: Option<(NodeId, u32, Point)>,
316 wheel: i32,
318 pixels: f32,
319 caused_layout: bool,
321 drop_over: Option<(NodeId, Option<Signal<bool>>)>,
324}
325
326impl Pointer {
327 pub(crate) fn forget(&mut self, removed: &[NodeId]) {
330 if self.hovered.is_some_and(|id| removed.contains(&id)) {
331 self.hovered = None;
332 }
333 let (gone, kept): (Vec<_>, Vec<_>) = std::mem::take(&mut self.inside)
334 .into_iter()
335 .partition(|(id, _)| removed.contains(id));
336 for (_, signal) in gone {
337 if !kept.iter().any(|(_, other)| *other == signal) {
339 signal.try_set(false);
340 }
341 }
342 self.inside = kept;
343 self.positions.retain(|(id, signal, _)| {
344 let gone = removed.contains(id);
345 if gone {
346 signal.try_set(None);
347 }
348 !gone
349 });
350 let source_gone = self
351 .pressed
352 .is_some_and(|press| removed.contains(&press.id));
353 if source_gone {
354 self.pressed = None;
355 }
356 if source_gone || self.drop_over.is_some_and(|(id, _)| removed.contains(&id)) {
357 self.set_drop_over(None);
358 }
359 self.forget_views(removed);
360 if self
361 .last_click
362 .is_some_and(|(id, _, _)| removed.contains(&id))
363 {
364 self.last_click = None;
365 }
366 }
367}
368
369impl Pointer {
370 fn set_drop_over(&mut self, over: Option<(NodeId, Option<Signal<bool>>)>) {
373 let old = std::mem::replace(&mut self.drop_over, over);
374 if old.map(|(id, _)| id) == over.map(|(id, _)| id) {
375 return;
376 }
377 let (old, new) = (old.and_then(|(_, s)| s), over.and_then(|(_, s)| s));
378 if old != new {
379 if let Some(old) = old {
380 old.try_set(false);
381 }
382 if let Some(new) = new {
383 new.try_set(true);
384 }
385 }
386 }
387}
388
389impl Tree {
390 pub(crate) fn pointer_hide(&mut self, hidden: &[NodeId]) {
393 let held = [
394 self.pointer.hovered,
395 self.pointer.pressed.map(|press| press.id),
396 ];
397 self.pointer.forget(hidden);
398 for id in held.into_iter().flatten().filter(|id| hidden.contains(id)) {
399 self.update_button_style(id, |button| {
400 button.hovered = false;
401 button.pressed = false;
402 });
403 }
404 }
405}
406
407fn now_ms() -> u32 {
410 static START: OnceLock<Instant> = OnceLock::new();
411 START.get_or_init(Instant::now).elapsed().as_millis() as u32
413}
414
415impl Window {
416 pub fn pointer_motion(&self, position: Point) -> CursorShape {
419 self.pointer_motion_at(position, now_ms())
420 }
421
422 pub fn pointer_motion_at(&self, position: Point, time: u32) -> CursorShape {
427 let calls = {
428 let mut tree = borrow(&self.tree);
429 tree.pointer.position = Some(position);
430 tree.bar_motion(position);
431 let calls = if tree.flick_motion(position, time) {
432 Vec::new()
433 } else {
434 tree.drag_motion(position)
435 };
436 tree.hover_at(position);
437 calls
438 };
439 run_all(calls);
440 self.cursor()
441 }
442
443 pub fn pointer_leave(&self) {
446 let calls = borrow(&self.tree).leave();
447 run_all(calls);
448 }
449
450 pub fn pointer_button(&self, button: PointerButton, pressed: bool) {
453 self.pointer_button_at(button, pressed, now_ms());
454 }
455
456 pub fn pointer_button_at(&self, button: PointerButton, pressed: bool, time: u32) {
464 let calls = borrow(&self.tree).button(button, pressed, time);
465 run_all(calls);
466 }
467
468 pub fn pointer_scroll(&self, wheel: Wheel) {
477 self.pointer_scroll_at(wheel, now_ms());
478 }
479
480 pub fn pointer_scroll_at(&self, wheel: Wheel, time: u32) {
484 let calls = borrow(&self.tree).scroll(wheel, time);
485 run_all(calls);
486 }
487
488 pub fn cursor(&self) -> CursorShape {
490 self.tree.borrow().cursor()
491 }
492}
493
494fn run_all(calls: Vec<Call>) {
496 for call in calls {
497 call.run();
498 }
499}
500
501fn distance(a: Point, b: Point) -> f32 {
502 (a.x - b.x).hypot(a.y - b.y)
503}
504
505impl Tree {
506 fn hit(
513 &self,
514 id: NodeId,
515 point: Point,
516 path: &mut Vec<NodeId>,
517 skip: Option<NodeId>,
518 ) -> Option<NodeId> {
519 if skip == Some(id) {
520 return None;
521 }
522 let node = self.node(id)?;
523 let point = local(node, point)?;
524 let rect = node.rect?;
525 if !node.inner_bounds.contains(point) {
528 return None;
529 }
530 let style = node.effective_style();
531 let border = style.border.map_or(0.0, |border| border.width.max(0.0));
533 let corners = style.radius.unwrap_or_default();
534 let children = if node.clips() && !corners.contains(rect, border, point) {
535 Vec::new()
536 } else {
537 self.drawn_children(id)
538 };
539 path.push(id);
540 if let Some(hit) = children
541 .into_iter()
542 .rev()
543 .find_map(|child| self.hit(child, point, path, skip))
544 {
545 return Some(hit);
546 }
547 let takes = match &node.kind {
548 NodeKind::Button(button) => button.enabled,
549 NodeKind::Input(_) => true,
550 _ => false,
551 };
552 if rect.contains(point) && takes {
553 return Some(id);
554 }
555 path.pop();
556 None
557 }
558
559 pub(crate) fn hover_at(&mut self, point: Point) {
563 let mut path = Vec::new();
564 let hit = match self.pointer.pressed.filter(|press| press.dragging) {
565 Some(press) => {
566 path = self.path_to(press.id);
567 Some(press.id)
568 }
569 None => self.hit(self.root, point, &mut path, None),
570 };
571 self.set_hovered(hit, &path);
572 self.set_positions(&path, Some(point));
573 self.update_drop();
574 }
575
576 fn drag_type(&self, id: NodeId) -> Option<TypeId> {
578 let Some(NodeKind::Button(button)) = self.node(id).map(|node| &node.kind) else {
579 return None;
580 };
581 let data = button.drag_data?;
582 untrack(|| data.try_with(|data| data.as_ref().map(|value| (**value).type_id()))).flatten()
584 }
585
586 fn drop_target(&self) -> Option<NodeId> {
590 let press = self.pointer.pressed.filter(|press| press.dragging)?;
591 let carried = self.drag_type(press.id)?;
592 let mut path = Vec::new();
593 self.hit(self.root, self.pointer.position?, &mut path, Some(press.id))?;
594 path.into_iter().rev().find(|&id| {
595 self.enabled(id)
596 && self.has(id, |h| {
597 h.drop
599 .as_ref()
600 .is_some_and(|target| target.accepts == carried && !target.handler.disabled.get())
601 })
602 })
603 }
604
605 fn update_drop(&mut self) {
608 let over = self.drop_target().map(|id| {
609 let signal = match self.node(id).map(|node| &node.kind) {
610 Some(NodeKind::Button(button)) => button.drop_hovered,
611 _ => None,
612 };
613 (id, signal)
614 });
615 self.pointer.set_drop_over(over);
616 }
617
618 pub(crate) fn drop_after_place(&mut self) {
621 if self.pointer.pressed.is_some_and(|press| press.dragging) {
622 self.update_drop();
623 }
624 }
625
626 fn drags(&self, id: NodeId) -> bool {
629 self.drag_type(id).is_some() || self.has(id, |h| h.drag.is_some())
630 }
631
632 pub(crate) fn path_to(&self, id: NodeId) -> Vec<NodeId> {
634 let mut path = vec![id];
635 while let Some(parent) = path.last().and_then(|&id| self.taffy.parent(id)) {
636 path.push(parent);
637 }
638 path.reverse();
639 path
640 }
641
642 fn cursor(&self) -> CursorShape {
643 match self
644 .pointer
645 .hovered
646 .and_then(|id| self.node(id))
647 .map(|node| &node.kind)
648 {
649 Some(NodeKind::Input(_)) => CursorShape::Text,
650 Some(NodeKind::Button(button)) => button.cursor,
651 _ => CursorShape::Default,
652 }
653 }
654
655 pub(crate) fn pointer_after_layout(&mut self) {
660 if std::mem::take(&mut self.pointer.caused_layout) {
661 return;
662 }
663 if let Some(position) = self.pointer.position {
664 self.hover_at(position);
665 }
666 }
667
668 fn set_hovered(&mut self, hovered: Option<NodeId>, path: &[NodeId]) {
671 self.set_inside(path);
672 let old = self.pointer.hovered;
673 if old == hovered {
674 return;
675 }
676 self.pointer.hovered = hovered;
677 self.pointer.wheel = 0;
678 self.pointer.pixels = 0.0;
679 if let Some(old) = old {
680 self.set_button_state(old, |button| button.hovered = false);
681 }
682 if let Some(new) = hovered {
683 self.set_button_state(new, |button| button.hovered = true);
684 }
685 }
686
687 fn path_buttons<T>(
689 &self,
690 path: &[NodeId],
691 pick: impl Fn(&ButtonNode) -> Option<T>,
692 ) -> Vec<(NodeId, T)> {
693 path
694 .iter()
695 .filter_map(|&id| match &self.node(id)?.kind {
696 NodeKind::Button(button) if button.enabled => Some((id, pick(button)?)),
697 _ => None,
698 })
699 .collect()
700 }
701
702 fn set_inside(&mut self, path: &[NodeId]) {
705 let inside = self.path_buttons(path, |button| button.hover_signal);
706 let holds = |list: &[(NodeId, Signal<bool>)], signal| list.iter().any(|(_, s)| *s == signal);
709 let mut seen = Vec::new();
710 for &(_, signal) in self.pointer.inside.iter().chain(&inside) {
711 if seen.contains(&signal) {
712 continue;
713 }
714 seen.push(signal);
715 let now = holds(&inside, signal);
716 if holds(&self.pointer.inside, signal) != now {
717 signal.try_set(now);
718 }
719 }
720 self.pointer.inside = inside;
721 }
722
723 fn set_positions(&mut self, path: &[NodeId], at: Option<Point>) {
727 let now: Vec<(NodeId, Signal<Option<Point>>, Point)> = match at {
728 Some(at) => self
729 .path_buttons(path, |button| button.position_signal)
730 .into_iter()
731 .filter_map(|(id, signal)| Some((id, signal, self.button_local(id, at)?)))
732 .collect(),
733 None => Vec::new(),
734 };
735 for (id, signal, _) in &self.pointer.positions {
736 if !now.iter().any(|(other, ..)| other == id) {
737 signal.try_set(None);
738 }
739 }
740 for &(id, signal, point) in &now {
741 let same = |&(other, _, was): &(NodeId, _, Point)| other == id && was == point;
742 if !self.pointer.positions.iter().any(same) {
743 signal.try_set(Some(point));
744 }
745 }
746 self.pointer.positions = now;
747 }
748
749 fn button_local(&self, id: NodeId, point: Point) -> Option<Point> {
752 let rect = self.node(id)?.rect?;
753 let point = self.local_point(id, point)?;
754 Some(Point::new(point.x - rect.x, point.y - rect.y))
755 }
756
757 fn set_pressed(&mut self, pressed: Option<Press>) {
758 let old = std::mem::replace(&mut self.pointer.pressed, pressed);
759 if let Some(old) = old {
760 self.set_button_state(old.id, |button| button.pressed = false);
761 }
762 if let Some(new) = pressed {
763 self.set_button_state(new.id, |button| button.pressed = true);
764 }
765 }
766
767 fn set_button_state(&mut self, id: NodeId, f: impl FnOnce(&mut ButtonNode)) {
770 if self.update_button_style(id, f) == Change::Layout {
771 self.pointer.caused_layout = true;
772 }
773 }
774
775 fn button(&mut self, button: PointerButton, pressed: bool, time: u32) -> Vec<Call> {
776 if pressed {
777 self.press(button)
778 } else {
779 self.release(button, time)
780 }
781 }
782
783 fn press(&mut self, button: PointerButton) -> Vec<Call> {
784 if let (PointerButton::Left, None, Some(at)) =
786 (button, self.pointer.pressed, self.pointer.position)
787 && self.press_bar(at)
788 {
789 return Vec::new();
790 }
791 if let (PointerButton::Left, None, Some(at)) =
792 (button, self.pointer.pressed, self.pointer.position)
793 {
794 let drags = self.pointer.hovered.is_some_and(|id| self.drags(id));
795 self.press_views(at, drags);
796 }
797 let (None, Some(id), Some(at)) = (
798 self.pointer.pressed,
799 self.pointer.hovered,
800 self.pointer.position,
801 ) else {
802 return Vec::new();
803 };
804 let start = self.button_local(id, at).unwrap_or_default();
805 self.set_pressed(Some(Press {
806 id,
807 button,
808 at,
809 last: at,
810 start,
811 dragging: false,
812 long_pressed: false,
813 }));
814 if button != PointerButton::Left {
815 return Vec::new();
816 }
817 self.press_field(id);
818 let mut calls: Vec<Call> = self.call(id, Action::Press).into_iter().collect();
819 if self.has(id, |h| h.long_press.is_some()) {
820 self.arm_long_press(id);
821 }
822 let waits =
824 |h: &Handlers| h.click.is_some() || h.double_click.is_some() || h.long_press.is_some();
825 if self.drags(id) && !self.has(id, waits) {
826 calls.extend(self.start_drag(at));
827 }
828 calls
829 }
830
831 fn release(&mut self, button: PointerButton, time: u32) -> Vec<Call> {
832 if button == PointerButton::Left {
833 if let Some(bar) = self.pointer.bar.take() {
834 self.release_view(bar.view, None);
835 }
836 self.flick_release(Some(time));
837 }
838 let Some(press) = self.pointer.pressed.filter(|press| press.button == button) else {
839 return Vec::new();
840 };
841 let mut calls = Vec::new();
842 if button == PointerButton::Left {
843 calls.extend(self.call(press.id, Action::Release));
844 }
845 let landed = Rc::new(Cell::new(false));
847 calls.extend(self.drop_call(&landed));
848 calls.extend(self.end_press(Some(landed)));
849 if press.dragging {
850 if let Some(at) = self.pointer.position {
852 self.hover_at(at);
853 }
854 return calls;
855 }
856 if press.long_pressed || self.pointer.hovered != Some(press.id) {
857 return calls;
858 }
859 let action = match button {
860 PointerButton::Left => self.left_click(press.id, time, press.at),
861 PointerButton::Right => Action::RightClick,
862 PointerButton::Middle => Action::MiddleClick,
863 PointerButton::Back => Action::Back,
864 PointerButton::Forward => Action::Forward,
865 };
866 calls.extend(self.call(press.id, action));
867 calls
868 }
869
870 fn left_click(&mut self, id: NodeId, time: u32, at: Point) -> Action {
874 let close = self.pointer.last_click.is_some_and(|(last, then, place)| {
875 last == id
876 && time.wrapping_sub(then) <= DOUBLE_CLICK_MS
877 && distance(place, at) <= DOUBLE_CLICK_DISTANCE
878 });
879 if close && self.has(id, |h| h.double_click.is_some()) {
880 self.pointer.last_click = None;
881 Action::DoubleClick
882 } else {
883 self.pointer.last_click = Some((id, time, at));
884 Action::Click
885 }
886 }
887
888 fn drop_call(&self, landed: &Rc<Cell<bool>>) -> Option<Call> {
891 let target = self.drop_target()?;
892 let press = self.pointer.pressed?;
893 let Some(NodeKind::Button(button)) = self.node(press.id).map(|node| &node.kind) else {
894 return None;
895 };
896 let value = untrack(|| button.drag_data?.try_get().flatten())?;
897 self.call(target, Action::Drop(value, Rc::clone(landed)))
898 }
899
900 fn end_press(&mut self, landed: Option<Rc<Cell<bool>>>) -> Option<Call> {
904 let press = self.pointer.pressed?;
905 self.set_pressed(None);
906 self.update_drop();
907 self.stop_long_press(press.id);
908 if press.dragging {
909 self.drag_call(press, DragPhase::End, press.last, landed)
910 } else {
911 None
912 }
913 }
914
915 fn drag_motion(&mut self, at: Point) -> Vec<Call> {
918 let Some(press) = self.pointer.pressed.as_mut() else {
919 return Vec::new();
920 };
921 press.last = at;
922 let press = *press;
923 if press.button != PointerButton::Left {
924 return Vec::new();
925 }
926 if press.dragging {
927 return self
928 .drag_call(press, DragPhase::Move, at, None)
929 .into_iter()
930 .collect();
931 }
932 if distance(press.at, at) <= DRAG_THRESHOLD {
933 return Vec::new();
934 }
935 self.stop_long_press(press.id);
936 if self.drags(press.id) {
937 self.start_drag(at)
938 } else {
939 Vec::new()
940 }
941 }
942
943 fn start_drag(&mut self, at: Point) -> Vec<Call> {
945 let Some(press) = self.pointer.pressed.as_mut() else {
946 return Vec::new();
947 };
948 press.dragging = true;
949 let press = *press;
950 self.stop_long_press(press.id);
951 self.update_drop();
952 self
953 .drag_call(press, DragPhase::Start, at, None)
954 .into_iter()
955 .collect()
956 }
957
958 fn drag_call(
959 &self,
960 press: Press,
961 phase: DragPhase,
962 at: Point,
963 landed: Option<Rc<Cell<bool>>>,
964 ) -> Option<Call> {
965 let rect = self.node(press.id)?.rect?;
966 let drag = Drag {
967 phase,
968 start: press.start,
969 position: self.button_local(press.id, at).unwrap_or(press.start),
972 size: Size::new(rect.width, rect.height),
973 dropped: false,
974 };
975 self.call(press.id, Action::Drag(drag, landed))
976 }
977
978 fn arm_long_press(&mut self, id: NodeId) {
981 let tree = self.this.clone();
982 let Some(Node { cx, kind, .. }) = self.node_mut(id) else {
983 return;
984 };
985 let NodeKind::Button(button) = kind else {
986 return;
987 };
988 match button.long_press {
989 Some(timer) => timer.restart(),
990 None => {
991 let timer = cx.after(LONG_PRESS, move || long_press_fired(&tree, id));
992 button.long_press = Some(timer);
993 }
994 }
995 }
996
997 fn stop_long_press(&self, id: NodeId) {
998 if let Some(NodeKind::Button(button)) = self.node(id).map(|node| &node.kind)
999 && let Some(timer) = button.long_press
1000 {
1001 timer.stop();
1002 }
1003 }
1004
1005 fn long_press(&mut self, id: NodeId) -> Option<Call> {
1007 let press = self.pointer.pressed.as_mut().filter(|press| {
1008 press.id == id
1009 && press.button == PointerButton::Left
1010 && !press.dragging
1011 && !press.long_pressed
1012 })?;
1013 press.long_pressed = true;
1014 self.call(id, Action::LongPress)
1015 }
1016
1017 pub(crate) fn leave(&mut self) -> Vec<Call> {
1020 self.pointer.position = None;
1021 if let Some(bar) = self.pointer.bar.take() {
1022 self.release_view(bar.view, None);
1023 }
1024 self.flick_release(None);
1025 if let Some(id) = self.pointer.gesture.take() {
1026 self.release_view(id, None);
1027 }
1028 let calls = self.end_press(None).into_iter().collect();
1029 self.set_hovered(None, &[]);
1030 self.set_positions(&[], None);
1031 calls
1032 }
1033
1034 pub(crate) fn set_enabled(&mut self, id: NodeId, enabled: bool) -> Vec<Call> {
1038 let Some(NodeKind::Button(button)) = self.node_mut(id).map(|node| &mut node.kind) else {
1039 return Vec::new();
1040 };
1041 if std::mem::replace(&mut button.enabled, enabled) == enabled {
1042 return Vec::new();
1043 }
1044 let mut calls = Vec::new();
1045 if !enabled {
1046 if self.pointer.pressed.is_some_and(|press| press.id == id) {
1047 calls.extend(self.end_press(None));
1048 }
1049 if self.keyboard.focused == Some(id) {
1050 self.focus(None);
1051 }
1052 }
1053 if let Some(at) = self.pointer.position {
1054 self.hover_at(at);
1055 }
1056 calls
1057 }
1058
1059 pub(crate) fn bind_enabled(&mut self, id: NodeId, prop: Prop<bool>) {
1062 let mut compute = match prop.0 {
1063 PropKind::Value(enabled) => {
1065 self.set_enabled(id, enabled);
1066 return;
1067 }
1068 PropKind::Binding(compute) => compute,
1069 };
1070 let Some(node) = self.node(id) else {
1071 return;
1072 };
1073 let label = format!("{}.enabled", node.path);
1074 let tree = self.this.clone();
1075 node
1076 .cx
1077 .effect(move || {
1078 let enabled = compute();
1079 let Some(tree) = tree.upgrade() else {
1080 return;
1081 };
1082 let calls = borrow(&tree).set_enabled(id, enabled);
1083 untrack(|| run_all(calls));
1085 })
1086 .named(label);
1087 }
1088
1089 pub(crate) fn enabled(&self, id: NodeId) -> bool {
1091 match self.node(id).map(|node| &node.kind) {
1092 Some(NodeKind::Button(button)) => button.enabled,
1093 _ => true,
1094 }
1095 }
1096
1097 fn scroll(&mut self, wheel: Wheel, time: u32) -> Vec<Call> {
1098 let wants = |h: &Handlers| h.scroll.is_some() || h.wheel.is_some();
1099 let target = self.pointer.hovered.filter(|&id| self.has(id, wants));
1100 let calls = match target {
1101 None => {
1102 self.scroll_view(wheel, time);
1103 Vec::new()
1104 }
1105 Some(target) => {
1106 let mut calls = Vec::new();
1107 if self.has(target, |h| h.wheel.is_some()) {
1108 calls.extend(self.call(target, Action::Wheel(wheel)));
1109 }
1110 if self.has(target, |h| h.scroll.is_some()) {
1111 let down = self.steps(wheel.y);
1112 if down != 0 {
1114 calls.extend(self.call(target, Action::Scroll(down.saturating_neg())));
1115 }
1116 }
1117 calls
1118 }
1119 };
1120 if wheel.y.stop {
1121 self.pointer.pixels = 0.0;
1122 }
1123 if wheel.source == ScrollSource::Finger
1127 && (wheel.x.stop || wheel.y.stop)
1128 && let Some(id) = self.pointer.gesture.take()
1129 {
1130 self.release_view(id, Some(time));
1131 }
1132 calls
1133 }
1134
1135 fn steps(&mut self, axis: WheelAxis) -> i32 {
1138 if axis.notches != 0.0 && axis.notches.is_finite() {
1139 let value120 = (axis.notches * VALUE120_PER_STEP as f32).round() as i32;
1141 self.pointer.wheel = self.pointer.wheel.saturating_add(value120);
1142 let steps = self.pointer.wheel / VALUE120_PER_STEP;
1143 self.pointer.wheel -= steps * VALUE120_PER_STEP;
1144 steps
1145 } else if axis.pixels.is_finite() {
1146 self.pointer.pixels += axis.pixels;
1147 let steps = (self.pointer.pixels / PIXELS_PER_STEP).trunc();
1148 self.pointer.pixels -= steps * PIXELS_PER_STEP;
1149 steps as i32
1150 } else {
1151 0
1152 }
1153 }
1154
1155 fn press_field(&mut self, id: NodeId) {
1158 let Some(position) = self
1159 .pointer
1160 .position
1161 .and_then(|at| self.local_point(id, at))
1162 else {
1163 return;
1164 };
1165 let Some(NodeKind::Input(input)) = self.node(id).map(|node| &node.kind) else {
1166 return;
1167 };
1168 let at = input.hit(position);
1169 self.focus(Some(id));
1170 self.update_input(id, |input| {
1171 input.edit.cursor = at;
1172 input.edit.anchor = None;
1173 });
1174 }
1175
1176 pub(crate) fn cancel_press(&mut self) {
1179 if let Some(press) = self.pointer.pressed.filter(|press| !press.dragging) {
1180 self.set_pressed(None);
1181 self.stop_long_press(press.id);
1182 }
1183 }
1184
1185 fn has(&self, id: NodeId, f: impl FnOnce(&Handlers) -> bool) -> bool {
1187 let Some(NodeKind::Button(button)) = self.node(id).map(|node| &node.kind) else {
1188 return false;
1189 };
1190 untrack(|| button.handlers.try_with(f)).unwrap_or(false)
1191 }
1192
1193 pub(crate) fn local_point(&self, id: NodeId, point: Point) -> Option<Point> {
1197 self
1198 .path_to(id)
1199 .iter()
1200 .try_fold(point, |point, &id| local(self.node(id)?, point))
1201 }
1202
1203 pub(crate) fn window_rect(&self, id: NodeId, rect: Rect) -> Rect {
1207 let mut rect = rect;
1208 let mut at = Some(id);
1209 while let Some(current) = at {
1210 if let Some(transform) = self.node(current).and_then(|node| node.transform) {
1211 rect = transform.map_rect(rect);
1212 }
1213 at = self.taffy.parent(current);
1214 }
1215 rect
1216 }
1217
1218 pub(crate) fn click(&self, id: NodeId) -> Option<Call> {
1220 self.call(id, Action::Click)
1221 }
1222
1223 fn call(&self, id: NodeId, action: Action) -> Option<Call> {
1224 let node = self.node(id)?;
1225 let NodeKind::Button(button) = &node.kind else {
1226 return None;
1227 };
1228 Some(Call {
1229 cx: node.cx.clone(),
1230 path: Rc::clone(&node.path),
1231 handlers: button.handlers,
1232 action,
1233 })
1234 }
1235}
1236
1237fn long_press_fired(tree: &Weak<RefCell<Tree>>, id: NodeId) {
1239 let Some(tree) = tree.upgrade() else {
1240 return;
1241 };
1242 let Ok(mut borrowed) = tree.try_borrow_mut() else {
1244 return;
1245 };
1246 let call = borrowed.long_press(id);
1247 drop(borrowed);
1248 if let Some(call) = call {
1249 call.run();
1250 }
1251}
1252
1253pub(crate) fn local(node: &Node, point: Point) -> Option<Point> {
1257 match node.transform {
1258 Some(transform) => Some(transform.invert()?.map(point)),
1259 None => Some(point),
1260 }
1261}
1262
1263#[derive(Clone)]
1264enum Action {
1265 Click,
1266 Press,
1267 Release,
1268 DoubleClick,
1269 LongPress,
1270 RightClick,
1271 MiddleClick,
1272 Back,
1273 Forward,
1274 Scroll(i32),
1275 Wheel(Wheel),
1276 Drag(Drag, Option<Rc<Cell<bool>>>),
1278 Drop(DragValue, Rc<Cell<bool>>),
1280}
1281
1282pub(crate) struct Call {
1284 cx: Cx,
1285 path: Rc<str>,
1286 handlers: Signal<Handlers>,
1287 action: Action,
1288}
1289
1290enum Picked {
1292 Plain(ClickHandler, &'static str),
1293 Scroll(ScrollHandler, i32),
1294 Wheel(WheelHandler, Wheel),
1295 Drag(DragHandler, Drag),
1296 Drop(DropHandler, DragValue, Rc<Cell<bool>>),
1297}
1298
1299impl Call {
1300 pub(crate) fn run(self) {
1301 let picked = untrack(|| {
1303 self.handlers.try_with(|h| {
1304 let plain = |handler: &Option<ClickHandler>, name| {
1305 handler.clone().map(|handler| Picked::Plain(handler, name))
1306 };
1307 match &self.action {
1308 Action::Click => plain(&h.click, "on_click"),
1309 Action::Press => plain(&h.press, "on_press"),
1310 Action::Release => plain(&h.release, "on_release"),
1311 Action::DoubleClick => plain(&h.double_click, "on_double_click"),
1312 Action::LongPress => plain(&h.long_press, "on_long_press"),
1313 Action::RightClick => plain(&h.right_click, "on_right_click"),
1314 Action::MiddleClick => plain(&h.middle_click, "on_middle_click"),
1315 Action::Back => plain(&h.back, "on_back"),
1316 Action::Forward => plain(&h.forward, "on_forward"),
1317 Action::Scroll(steps) => h.scroll.clone().map(|f| Picked::Scroll(f, *steps)),
1318 Action::Wheel(wheel) => h.wheel.clone().map(|f| Picked::Wheel(f, *wheel)),
1319 Action::Drag(drag, landed) => {
1320 let drag = Drag {
1321 dropped: landed.as_ref().is_some_and(|landed| landed.get()),
1322 ..*drag
1323 };
1324 h.drag.clone().map(|f| Picked::Drag(f, drag))
1325 }
1326 Action::Drop(value, landed) => {
1327 let target = h.drop.as_ref()?;
1328 Some(Picked::Drop(
1329 target.handler.clone(),
1330 Rc::clone(value),
1331 Rc::clone(landed),
1332 ))
1333 }
1334 }
1335 })
1336 });
1337 let Some(Some(picked)) = picked else {
1338 return;
1339 };
1340 let (path, cx) = (&self.path, &self.cx);
1341 match picked {
1342 Picked::Plain(handler, name) => {
1343 run_isolated(path, name, handler, |f| f(cx));
1344 }
1345 Picked::Scroll(handler, steps) => {
1346 run_isolated(path, "on_scroll", handler, |f| f(cx, steps));
1347 }
1348 Picked::Wheel(handler, wheel) => {
1349 run_isolated(path, "on_wheel", handler, |f| f(cx, wheel));
1350 }
1351 Picked::Drag(handler, drag) => {
1352 run_isolated(path, "on_drag", handler, |f| f(cx, drag));
1353 }
1354 Picked::Drop(handler, value, landed) => {
1356 let ran = run_isolated(path, "on_drop", handler, move |f| f(cx, &*value));
1357 landed.set(ran.is_some());
1358 }
1359 }
1360 }
1361}
1362
1363pub(crate) fn run_isolated<F: ?Sized, R>(
1368 path: &str,
1369 name: &str,
1370 handler: Rc<Handler<F>>,
1371 call: impl FnOnce(&F) -> R,
1372) -> Option<R> {
1373 if handler.disabled.get() {
1374 return None;
1375 }
1376 let result = match panic::catch_unwind(AssertUnwindSafe(|| call(&handler.f))) {
1377 Ok(result) => Some(result),
1378 Err(payload) => {
1379 handler.disabled.set(true);
1380 tracing::error!(
1381 "handler {path}.{name} panicked and is disabled: {}",
1382 panic_message(payload.as_ref())
1383 );
1384 None
1385 }
1386 };
1387 if let Err(payload) = panic::catch_unwind(AssertUnwindSafe(move || drop(handler))) {
1388 tracing::error!(
1389 "dropping handler {path}.{name} panicked: {}",
1390 panic_message(payload.as_ref())
1391 );
1392 }
1393 result
1394}
1395
1396pub(crate) fn panic_message(payload: &(dyn Any + Send)) -> &str {
1397 if let Some(message) = payload.downcast_ref::<&str>() {
1398 message
1399 } else if let Some(message) = payload.downcast_ref::<String>() {
1400 message
1401 } else {
1402 "(panic payload is not a string)"
1403 }
1404}