1use crate::{
2 Interaction, LayoutNode, Point, Target, TextEditContext,
3 drag::{Context, DragUpdate, send},
4};
5use std::{collections::BTreeSet, path::Path, sync::Arc};
6use xrack_runtime::{DragAction, DragEvent, Length, Node, Value};
7
8#[derive(Debug)]
10pub enum FileDragInput {
11 Moved {
12 sequence: u64,
13 point: Point,
14 paths: Arc<[String]>,
15 },
16 Offered {
18 sequence: u64,
19 point: Point,
20 extensions: Arc<[Option<String>]>,
21 },
22 Dropped {
23 sequence: u64,
24 point: Point,
25 paths: Arc<[String]>,
26 target: Target,
27 },
28 Copied {
30 sequence: u64,
31 point: Point,
32 paths: Arc<[String]>,
33 target: Target,
34 },
35 Failed {
37 sequence: u64,
38 point: Point,
39 extensions: Arc<[Option<String>]>,
40 target: Target,
41 message: String,
42 },
43 Left {
44 sequence: u64,
45 },
46}
47
48#[derive(Default)]
50pub struct FileDropScope {
51 pub(crate) modal: Option<Vec<usize>>,
52 pub(crate) popups: Vec<Vec<usize>>,
53 pub(crate) transitions: BTreeSet<Vec<usize>>,
54 pub(crate) blocked: bool,
55 pub(crate) text_composing: bool,
56 pub(crate) swiping: Option<Vec<usize>>,
57}
58
59#[doc(hidden)]
61pub struct TextDrop {
62 target: Target,
63 point: Point,
64 text: String,
65 password: bool,
66 focus: Option<Target>,
67 editor: Option<TextEditContext>,
68}
69
70impl TextDrop {
71 pub fn capture(
72 input: &Interaction,
73 scene: &Node,
74 layout: &LayoutNode,
75 point: Point,
76 target: Target,
77 ) -> Option<Self> {
78 if input
79 .file_drop_scope(layout)
80 .text_target(scene, layout, point)?
81 != target
82 {
83 return None;
84 }
85 let node = target.node_in(scene)?;
86 Some(Self {
87 text: input.editor_value(node).into_owned(),
88 password: node.is_password(),
89 focus: input.focused.clone(),
90 editor: TextEditContext::capture(input, scene),
91 target,
92 point,
93 })
94 }
95
96 pub fn destination(
97 &self,
98 input: &Interaction,
99 scene: &Node,
100 layout: &LayoutNode,
101 scope: &FileDropScope,
102 ) -> Option<(&Target, Point)> {
103 let node = self.target.node_in(scene)?;
104 if input.focused != self.focus
105 || self
106 .editor
107 .as_ref()
108 .is_some_and(|editor| !editor.is_current(input, scene))
109 || input.editor_value(node) != self.text
110 || node.is_password() != self.password
111 || scope.text_target(scene, layout, self.point).as_ref() != Some(&self.target)
112 {
113 return None;
114 }
115 Some((&self.target, self.point))
116 }
117}
118
119impl FileDropScope {
120 pub(crate) fn scope_at(&self, layout: &LayoutNode, point: Point) -> &[usize] {
121 self.popups
122 .iter()
123 .find(|path| {
124 layout
125 .at_path(path)
126 .is_some_and(|item| item.bounds.contains(point))
127 })
128 .map(Vec::as_slice)
129 .or(self.modal.as_deref())
130 .unwrap_or_default()
131 }
132
133 pub fn target(
134 &self,
135 scene: &Node,
136 layout: &LayoutNode,
137 point: Point,
138 paths: &[String],
139 ) -> Option<Target> {
140 self.hit_paths(scene, layout, point, paths)
141 .map(|hit| hit.target)
142 }
143
144 pub fn target_for_extensions(
145 &self,
146 scene: &Node,
147 layout: &LayoutNode,
148 point: Point,
149 extensions: &[Option<String>],
150 ) -> Option<Target> {
151 self.hit_extensions(scene, layout, point, extensions)
152 .map(|hit| hit.target)
153 }
154
155 fn hit_paths(
156 &self,
157 scene: &Node,
158 layout: &LayoutNode,
159 point: Point,
160 paths: &[String],
161 ) -> Option<FileHit> {
162 if paths.is_empty() || paths.iter().any(|path| !Path::new(path).is_absolute()) {
163 return None;
164 }
165 self.hit(scene, layout, point, |filters| {
166 paths.iter().all(|path| {
167 accepts_extension(
168 filters,
169 Path::new(path).extension().and_then(|ext| ext.to_str()),
170 )
171 })
172 })
173 }
174
175 fn hit_extensions(
176 &self,
177 scene: &Node,
178 layout: &LayoutNode,
179 point: Point,
180 extensions: &[Option<String>],
181 ) -> Option<FileHit> {
182 if extensions.is_empty() {
183 return None;
184 }
185 self.hit(scene, layout, point, |filters| {
186 extensions.iter().all(|ext| {
187 ext.as_deref()
188 .is_none_or(|ext| accepts_extension(filters, Some(ext)))
189 })
190 })
191 }
192
193 fn hit(
194 &self,
195 scene: &Node,
196 layout: &LayoutNode,
197 point: Point,
198 extensions_match: impl Fn(&[String]) -> bool,
199 ) -> Option<FileHit> {
200 let context = Context {
201 scene,
202 layout,
203 scope: self.scope_at(layout, point),
204 modal: self.modal.as_deref(),
205 transitions: &self.transitions,
206 blocked: self.blocked,
207 };
208 let (target, local) = context.find(point, &|node, item| {
209 let point = item.map_from_window(point)?;
210 (node.kind == "DropArea"
211 && node.boolean("accept-files", false)
212 && !matches!(node.properties.get("drop-action"), Some(Value::DragAction(action)) if *action != DragAction::Copy)
213 && extensions_match(node.strings("file-extensions")))
214 .then_some(Point {
215 x: point.x - item.bounds.x,
216 y: point.y - item.bounds.y,
217 })
218 })?;
219 Some(FileHit { target, local })
220 }
221}
222
223fn accepts_extension(filters: &[String], extension: Option<&str>) -> bool {
224 filters.is_empty()
225 || extension.is_some_and(|extension| {
226 filters
227 .iter()
228 .any(|filter| extension.eq_ignore_ascii_case(filter.trim_start_matches('.')))
229 })
230}
231
232#[derive(Clone, Debug)]
233struct FileHit {
234 target: Target,
235 local: Point,
236}
237
238#[derive(Clone, Debug)]
239struct Hover {
240 sequence: u64,
241 point: Point,
242 hit: FileHit,
243 offer: Offer,
244}
245
246#[derive(Clone, Debug, PartialEq)]
247enum Offer {
248 Paths(Arc<[String]>),
249 Extensions(Arc<[Option<String>]>),
250}
251
252impl Offer {
253 fn hit(
254 &self,
255 scope: &FileDropScope,
256 scene: &Node,
257 layout: &LayoutNode,
258 point: Point,
259 ) -> Option<FileHit> {
260 match self {
261 Self::Paths(paths) => scope.hit_paths(scene, layout, point, paths),
262 Self::Extensions(extensions) => scope.hit_extensions(scene, layout, point, extensions),
263 }
264 }
265}
266
267#[derive(Clone, Debug, Default)]
268pub(crate) struct FileDrag {
269 hover: Option<Hover>,
270 completed: Option<u64>,
271}
272
273impl FileDrag {
274 pub fn has_hover(&self) -> bool {
275 self.hover.is_some()
276 }
277
278 pub fn update(
279 &mut self,
280 scope: &FileDropScope,
281 scene: &Node,
282 layout: &LayoutNode,
283 input: FileDragInput,
284 ) -> DragUpdate {
285 let mut update = DragUpdate::default();
286 let copied = matches!(input, FileDragInput::Copied { .. });
287 match input {
288 FileDragInput::Moved {
289 sequence,
290 point,
291 paths,
292 } if self.completed != Some(sequence) => {
293 let offer = Offer::Paths(paths);
294 let next = offer.hit(scope, scene, layout, point).map(|hit| Hover {
295 sequence,
296 point,
297 hit,
298 offer,
299 });
300 self.update_hover(next, &mut update);
301 }
302 FileDragInput::Offered {
303 sequence,
304 point,
305 extensions,
306 } if self.completed != Some(sequence) => {
307 let offer = Offer::Extensions(extensions);
308 let next = offer.hit(scope, scene, layout, point).map(|hit| Hover {
309 sequence,
310 point,
311 hit,
312 offer,
313 });
314 self.update_hover(next, &mut update);
315 }
316 FileDragInput::Dropped {
317 sequence,
318 point,
319 paths,
320 target,
321 }
322 | FileDragInput::Copied {
323 sequence,
324 point,
325 paths,
326 target,
327 } if self.completed != Some(sequence) => {
328 self.completed = Some(sequence);
329 if scope.target(scene, layout, point, &paths).as_ref() == Some(&target) {
330 if self.hover.as_ref().is_some_and(|hover| {
331 hover.sequence == sequence && hover.hit.target == target
332 }) {
333 self.hover = None;
334 } else if !copied {
335 self.update_hover(None, &mut update);
336 }
337 if copied {
338 send(&mut update, &target, DragEvent::FilesEntered(paths.clone()));
339 }
340 send(&mut update, &target, DragEvent::FilesDropped(paths));
341 } else if self
342 .hover
343 .as_ref()
344 .is_some_and(|hover| hover.sequence == sequence)
345 {
346 self.update_hover(None, &mut update);
347 }
348 }
349 FileDragInput::Failed {
350 sequence,
351 point,
352 extensions,
353 target,
354 message,
355 } if self.completed != Some(sequence) => {
356 self.completed = Some(sequence);
357 if self
358 .hover
359 .as_ref()
360 .is_some_and(|hover| hover.sequence == sequence)
361 {
362 self.update_hover(None, &mut update);
363 }
364 if scope
365 .target_for_extensions(scene, layout, point, &extensions)
366 .as_ref()
367 == Some(&target)
368 {
369 send(&mut update, &target, DragEvent::FilesFailed(message));
370 }
371 }
372 FileDragInput::Left { sequence }
373 if self
374 .hover
375 .as_ref()
376 .is_some_and(|hover| hover.sequence == sequence) =>
377 {
378 self.update_hover(None, &mut update);
379 }
380 _ => {}
381 }
382 update
383 }
384
385 pub fn reconcile(
386 &mut self,
387 scope: &FileDropScope,
388 scene: &Node,
389 layout: &LayoutNode,
390 ) -> DragUpdate {
391 let mut update = DragUpdate::default();
392 if let Some(hover) = &self.hover
393 && hover
394 .offer
395 .hit(scope, scene, layout, hover.point)
396 .map(|hit| hit.target)
397 .as_ref()
398 != Some(&hover.hit.target)
399 {
400 self.update_hover(None, &mut update);
401 }
402 update
403 }
404
405 pub fn over(&self, node: &Node, path: &[usize]) -> bool {
406 self.hover.as_ref().is_some_and(|hover| {
407 hover.hit.target.path == path && hover.hit.target.matches_node(node)
408 })
409 }
410
411 fn update_hover(&mut self, next: Option<Hover>, update: &mut DragUpdate) {
412 let same = self
413 .hover
414 .as_ref()
415 .zip(next.as_ref())
416 .is_some_and(|(old, new)| {
417 old.sequence == new.sequence
418 && old.hit.target == new.hit.target
419 && old.offer == new.offer
420 });
421 if !same {
422 if let Some(old) = &self.hover {
423 send(update, &old.hit.target, DragEvent::Exited);
424 }
425 if let Some(new) = &next
426 && let Offer::Paths(paths) = &new.offer
427 {
428 send(
429 update,
430 &new.hit.target,
431 DragEvent::FilesEntered(paths.clone()),
432 );
433 }
434 }
435 if let Some(new) = &next
436 && (!same
437 || self
438 .hover
439 .as_ref()
440 .is_none_or(|old| old.hit.local != new.hit.local))
441 {
442 send(
443 update,
444 &new.hit.target,
445 DragEvent::Moved {
446 x: Length(new.hit.local.x.into()),
447 y: Length(new.hit.local.y.into()),
448 },
449 );
450 }
451 self.hover = next;
452 }
453}