Skip to main content

xrack_layout/
file_drop.rs

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/// Native file drags carry a batch and a window-local position.
9#[derive(Debug)]
10pub enum FileDragInput {
11    Moved {
12        sequence: u64,
13        point: Point,
14        paths: Arc<[String]>,
15    },
16    /// Promised files may expose extensions before they expose local paths.
17    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    /// An asynchronous drop has copied its complete batch into local storage.
29    Copied {
30        sequence: u64,
31        point: Point,
32        paths: Arc<[String]>,
33        target: Target,
34    },
35    /// An accepted asynchronous drop could not prepare or copy its files.
36    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/// The interaction gates needed for a synchronous native drag acceptance query.
49#[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/// The destination and editing state observed before a native provider starts loading.
60#[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}