1use std::any::{Any, TypeId};
8use std::cell::Cell;
9use std::rc::Rc;
10
11use crate::geometry::Point;
12use crate::input::{Action, DragPhase, PointerButton, run_all};
13use crate::tree::{NodeId, borrow};
14use crate::window::Window;
15
16#[derive(Clone, Debug, PartialEq, Eq)]
20pub enum DragContent {
21 Text(String),
23 Uris(Vec<String>),
25}
26
27#[derive(Clone, Debug, PartialEq)]
29pub struct DragOut {
30 pub carried: TypeId,
33 pub content: Option<DragContent>,
35}
36
37#[derive(Clone, Copy, Debug, PartialEq, Eq)]
40pub struct DropSpot(NodeId);
41
42#[derive(Clone, Copy)]
45pub(crate) struct Incoming {
46 pub(crate) at: Point,
47 pub(crate) carried: TypeId,
48}
49
50impl Window {
51 pub fn take_drag_out(&self) -> Option<DragOut> {
56 let mut tree = borrow(&self.tree);
57 let at = tree.pointer.position?;
58 let size = tree.size;
59 if at.x >= 0.0 && at.y >= 0.0 && at.x < size.width && at.y < size.height {
60 return None;
61 }
62 let press = tree
63 .pointer
64 .pressed
65 .filter(|press| press.dragging && !press.out && press.button == PointerButton::Left)?;
66 let value = tree.drag_value(press.id)?;
67 if let Some(press) = tree.pointer.pressed.as_mut() {
68 press.out = true;
69 }
70 tree.update_drop();
71 Some(DragOut {
72 carried: (*value).type_id(),
73 content: value.downcast_ref::<DragContent>().cloned(),
74 })
75 }
76
77 pub fn dragging_out(&self) -> bool {
80 let tree = borrow(&self.tree);
81 tree.pointer.pressed.is_some_and(|press| press.out)
82 }
83
84 pub fn drag_out_moved(&self, at: Point) {
87 let call = {
88 let mut tree = borrow(&self.tree);
89 let Some(press) = tree.pointer.pressed.as_mut().filter(|press| press.out) else {
90 return;
91 };
92 press.last = at;
93 let press = *press;
94 tree.drag_call(press, DragPhase::Move, at, None)
95 };
96 run_all(call.into_iter().collect());
97 }
98
99 pub fn end_drag_out(&self, drop: impl FnOnce(Rc<dyn Any>) -> bool) {
104 let (release, value) = {
105 let tree = borrow(&self.tree);
106 let Some(press) = tree.pointer.pressed.filter(|press| press.out) else {
107 return;
108 };
109 (
110 tree.call(press.id, Action::Release),
111 tree.drag_value(press.id),
112 )
113 };
114 run_all(release.into_iter().collect());
115 let landed = Rc::new(Cell::new(false));
116 if let Some(value) = value {
117 landed.set(drop(value));
118 }
119 let end = {
120 let mut tree = borrow(&self.tree);
121 match tree.pointer.pressed.is_some_and(|press| press.out) {
122 true => tree.end_press(Some(landed)),
123 false => None,
124 }
125 };
126 run_all(end.into_iter().collect());
127 }
128
129 pub fn drag_over(&self, at: Point, carried: TypeId) -> bool {
133 let mut tree = borrow(&self.tree);
134 tree.pointer.incoming = Some(Incoming { at, carried });
135 tree.update_drop();
136 tree.pointer.drop_over.is_some()
137 }
138
139 pub fn drag_takes(&self) -> bool {
142 let tree = borrow(&self.tree);
143 tree.pointer.incoming.is_some() && tree.pointer.drop_over.is_some()
144 }
145
146 pub fn drag_leave(&self) {
148 let mut tree = borrow(&self.tree);
149 if tree.pointer.incoming.take().is_some() {
150 tree.update_drop();
151 }
152 }
153
154 pub fn drag_drop(&self) -> Option<DropSpot> {
157 let mut tree = borrow(&self.tree);
158 tree.pointer.incoming?;
159 let target = tree.drop_target();
160 tree.pointer.incoming = None;
161 tree.update_drop();
162 target.map(DropSpot)
163 }
164
165 pub fn drop_into(&self, spot: DropSpot, value: Rc<dyn Any>) -> bool {
169 let landed = Rc::new(Cell::new(false));
170 let call = {
171 let tree = borrow(&self.tree);
172 let carried = (*value).type_id();
173 let shown = tree.node(spot.0).is_some_and(|node| node.rect.is_some());
175 let takes = shown
176 && tree.enabled(spot.0)
177 && tree.has(spot.0, |h| {
178 h.drop
179 .as_ref()
180 .is_some_and(|target| target.accepts == carried && !target.handler.disabled())
181 });
182 takes
183 .then(|| tree.call(spot.0, Action::Drop(value, Rc::clone(&landed))))
184 .flatten()
185 };
186 run_all(call.into_iter().collect());
187 landed.get()
188 }
189}