Skip to main content

sui_widgets/
reorderable.rs

1use sui_core::{
2    DragDropScope, DragEventKind, DragOutcome, DragPayload, DragSessionId, DropEffect, Event, Path,
3    Point, PointerButton, PointerEventKind, Rect, SemanticsAction, SemanticsNode, SemanticsRole,
4    Size, Transform, Vector, WakeEvent,
5};
6use sui_layout::Constraints;
7use sui_runtime::{
8    ArrangeCtx, EventCtx, MeasureCtx, PaintCtx, SemanticsCtx, Widget, WidgetChildren,
9    WidgetPodMutVisitor, WidgetPodVisitor,
10};
11
12use crate::{DefaultTheme, Easing, Transition};
13
14const DEFAULT_DRAG_THRESHOLD: f32 = 4.0;
15const REORDERABLE_LIST_PAYLOAD_KIND: &str = "sui-widgets.reorderable-list";
16
17type ReorderCallback = Box<dyn FnMut(&mut EventCtx, ReorderableListChange)>;
18
19#[derive(Debug, Clone, Copy, PartialEq, Eq)]
20pub struct ReorderableListChange {
21    pub item: usize,
22    pub from: usize,
23    pub to: usize,
24}
25
26#[derive(Debug, Clone, Copy, PartialEq, Eq)]
27struct ReorderPayload {
28    list: u64,
29    item: usize,
30}
31
32#[derive(Debug, Clone, Copy)]
33struct ReorderPress {
34    pointer_id: u64,
35    start_position: Point,
36    item: usize,
37    from: usize,
38    drag_offset_y: f32,
39}
40
41#[derive(Debug, Clone, Copy)]
42struct ActiveReorderDrag {
43    pointer_id: u64,
44    session_id: DragSessionId,
45    item: usize,
46    from: usize,
47    target: usize,
48    drag_offset_y: f32,
49    position: Point,
50}
51
52#[derive(Debug, Clone, Copy)]
53struct RowMotion {
54    y: f32,
55    target_y: f32,
56    transition: Option<Transition<f32>>,
57}
58
59impl RowMotion {
60    fn new(y: f32) -> Self {
61        Self {
62            y,
63            target_y: y,
64            transition: None,
65        }
66    }
67
68    fn current_at(self, time: f64) -> f32 {
69        self.transition
70            .map(|transition| transition.sample(time))
71            .unwrap_or(self.y)
72    }
73
74    fn jump_to(&mut self, y: f32) {
75        self.y = y;
76        self.target_y = y;
77        self.transition = None;
78    }
79
80    fn set_target(&mut self, target_y: f32, time: f64, duration: f64, easing: Easing) -> bool {
81        let current = self.current_at(time);
82        if (current - target_y).abs() <= 0.5 {
83            self.jump_to(target_y);
84            return false;
85        }
86
87        self.y = current;
88        self.target_y = target_y;
89        self.transition = Some(Transition::new(current, target_y, time, duration, easing));
90        true
91    }
92
93    fn advance(&mut self, time: f64) -> bool {
94        let Some(transition) = self.transition else {
95            return false;
96        };
97
98        self.y = transition.sample(time);
99        if transition.is_complete(time) {
100            self.jump_to(self.target_y);
101            false
102        } else {
103            true
104        }
105    }
106
107    fn is_animating(&self) -> bool {
108        self.transition.is_some()
109    }
110}
111
112pub struct ReorderableList {
113    theme: Box<DefaultTheme>,
114    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
115    scope: DragDropScope,
116    name: String,
117    children: WidgetChildren,
118    order: Vec<usize>,
119    spacing: f32,
120    drag_threshold: f32,
121    animation_duration: Option<f64>,
122    animation_easing: Option<Easing>,
123    preview_label: Option<String>,
124    press: Option<ReorderPress>,
125    active_drag: Option<ActiveReorderDrag>,
126    row_sizes: Vec<Size>,
127    row_offsets: Vec<f32>,
128    row_bounds: Vec<Rect>,
129    row_motions: Vec<RowMotion>,
130    content_y: f32,
131    content_height: f32,
132    on_reorder: Option<ReorderCallback>,
133}
134
135impl ReorderableList {
136    pub fn new(name: impl Into<String>) -> Self {
137        Self {
138            theme: Box::new(DefaultTheme::default()),
139            theme_reader: None,
140            scope: DragDropScope::new(),
141            name: name.into(),
142            children: WidgetChildren::new(),
143            order: Vec::new(),
144            spacing: 8.0,
145            drag_threshold: DEFAULT_DRAG_THRESHOLD,
146            animation_duration: None,
147            animation_easing: None,
148            preview_label: None,
149            press: None,
150            active_drag: None,
151            row_sizes: Vec::new(),
152            row_offsets: Vec::new(),
153            row_bounds: Vec::new(),
154            row_motions: Vec::new(),
155            content_y: 0.0,
156            content_height: 0.0,
157            on_reorder: None,
158        }
159    }
160
161    pub fn theme(mut self, theme: DefaultTheme) -> Self {
162        self.theme = Box::new(theme);
163        self.theme_reader = None;
164        self
165    }
166
167    pub fn theme_when<F>(mut self, theme: F) -> Self
168    where
169        F: Fn() -> DefaultTheme + 'static,
170    {
171        self.theme_reader = Some(Box::new(theme));
172        self
173    }
174
175    pub fn scope(mut self, scope: DragDropScope) -> Self {
176        self.scope = scope;
177        self
178    }
179
180    pub fn spacing(mut self, spacing: f32) -> Self {
181        self.spacing = spacing.max(0.0);
182        self
183    }
184
185    pub fn drag_threshold(mut self, threshold: f32) -> Self {
186        self.drag_threshold = threshold.max(0.0);
187        self
188    }
189
190    pub fn animation_duration(mut self, duration: f64) -> Self {
191        self.animation_duration = Some(duration.max(0.0));
192        self
193    }
194
195    pub fn animation_easing(mut self, easing: Easing) -> Self {
196        self.animation_easing = Some(easing);
197        self
198    }
199
200    pub fn preview_label(mut self, label: impl Into<String>) -> Self {
201        self.preview_label = Some(label.into());
202        self
203    }
204
205    pub fn item<W>(mut self, child: W) -> Self
206    where
207        W: Widget + 'static,
208    {
209        self.children.push(child);
210        self
211    }
212
213    pub fn on_reorder<F>(mut self, callback: F) -> Self
214    where
215        F: FnMut(ReorderableListChange) + 'static,
216    {
217        let mut callback = callback;
218        self.on_reorder = Some(Box::new(move |_, change| callback(change)));
219        self
220    }
221
222    pub fn on_reorder_with_ctx<F>(mut self, callback: F) -> Self
223    where
224        F: FnMut(&mut EventCtx, ReorderableListChange) + 'static,
225    {
226        self.on_reorder = Some(Box::new(callback));
227        self
228    }
229
230    pub fn order(&self) -> &[usize] {
231        &self.order
232    }
233
234    pub fn scope_ref(&self) -> &DragDropScope {
235        &self.scope
236    }
237
238    fn resolved_theme(&self) -> DefaultTheme {
239        self.theme_reader
240            .as_ref()
241            .map(|reader| reader())
242            .unwrap_or(*self.theme)
243    }
244
245    fn sync_storage(&mut self) {
246        let len = self.children.len();
247        if self.order.len() != len {
248            self.order = (0..len).collect();
249        }
250        self.row_sizes.resize(len, Size::ZERO);
251        self.row_offsets.resize(len, 0.0);
252        self.row_bounds.resize(len, Rect::ZERO);
253        if self.row_motions.len() != len {
254            self.row_motions = (0..len).map(|_| RowMotion::new(0.0)).collect();
255        }
256        if self
257            .active_drag
258            .is_some_and(|drag| drag.item >= len || drag.from >= len || drag.target >= len)
259        {
260            self.active_drag = None;
261            self.press = None;
262        }
263    }
264
265    fn compute_offsets_for_order(&self, order: &[usize]) -> (Vec<f32>, f32) {
266        let mut offsets = vec![0.0; self.children.len()];
267        let mut y: f32 = 0.0;
268        for (visual, item) in order.iter().copied().enumerate() {
269            if visual > 0 {
270                y += self.spacing;
271            }
272            offsets[item] = y;
273            y += self
274                .row_sizes
275                .get(item)
276                .copied()
277                .unwrap_or(Size::ZERO)
278                .height;
279        }
280        (offsets, y)
281    }
282
283    fn desired_order(&self) -> Vec<usize> {
284        let Some(drag) = self.active_drag else {
285            return self.order.clone();
286        };
287
288        let mut order = self.order.clone();
289        let Some(from) = order.iter().position(|item| *item == drag.item) else {
290            return order;
291        };
292        let item = order.remove(from);
293        let target = drag.target.min(order.len());
294        order.insert(target, item);
295        order
296    }
297
298    fn visual_index_of(&self, item: usize) -> Option<usize> {
299        self.order.iter().position(|candidate| *candidate == item)
300    }
301
302    fn insertion_index_at(&self, position: Point) -> usize {
303        let local_y = position.y - self.content_y;
304        let mut y = 0.0;
305        for visual in 0..self.order.len() {
306            if visual > 0 {
307                y += self.spacing;
308            }
309            let item = self.order[visual];
310            let height = self
311                .row_sizes
312                .get(item)
313                .copied()
314                .unwrap_or(Size::ZERO)
315                .height;
316            if local_y < y + (height * 0.5) {
317                return visual;
318            }
319            y += height;
320        }
321        self.order.len()
322    }
323
324    fn target_index_at(&self, item: usize, position: Point) -> usize {
325        if self.order.is_empty() {
326            return 0;
327        }
328
329        let insertion = self.insertion_index_at(position);
330        let from = self.visual_index_of(item).unwrap_or(0);
331        let target = if insertion > from {
332            insertion.saturating_sub(1)
333        } else {
334            insertion
335        };
336        target.min(self.order.len().saturating_sub(1))
337    }
338
339    fn press_at(&self, pointer_id: u64, position: Point) -> Option<ReorderPress> {
340        for (visual, item) in self.order.iter().copied().enumerate() {
341            let rect = self.row_bounds.get(item).copied().unwrap_or(Rect::ZERO);
342            if rect.contains(position) {
343                return Some(ReorderPress {
344                    pointer_id,
345                    start_position: position,
346                    item,
347                    from: visual,
348                    drag_offset_y: position.y - rect.y(),
349                });
350            }
351        }
352        None
353    }
354
355    fn start_drag(&mut self, ctx: &mut EventCtx, press: ReorderPress, position: Point) {
356        let session_id = ctx.begin_drag(
357            self.scope.id(),
358            press.pointer_id,
359            press.start_position,
360            DragPayload::custom(
361                REORDERABLE_LIST_PAYLOAD_KIND,
362                ReorderPayload {
363                    list: ctx.widget_id().get(),
364                    item: press.item,
365                },
366            ),
367            DropEffect::Move,
368            self.preview_label.clone(),
369        );
370        let target = self.target_index_at(press.item, position);
371        self.active_drag = Some(ActiveReorderDrag {
372            pointer_id: press.pointer_id,
373            session_id,
374            item: press.item,
375            from: press.from,
376            target,
377            drag_offset_y: press.drag_offset_y,
378            position,
379        });
380        if let Some(motion) = self.row_motions.get_mut(press.item) {
381            motion.jump_to(position.y - press.drag_offset_y);
382        }
383        self.retarget_row_motions(ctx, true);
384    }
385
386    fn set_drag_target(&mut self, ctx: &mut EventCtx, target: usize, position: Point) {
387        let Some(drag) = &mut self.active_drag else {
388            return;
389        };
390        drag.position = position;
391        if drag.target != target {
392            drag.target = target;
393            self.retarget_row_motions(ctx, true);
394        } else {
395            ctx.request_paint();
396        }
397    }
398
399    fn retarget_row_motions(&mut self, ctx: &mut EventCtx, animate: bool) {
400        let order = self.desired_order();
401        let (offsets, _) = self.compute_offsets_for_order(&order);
402        let base_y = self.content_y;
403        let theme = self.resolved_theme();
404        let duration = self
405            .animation_duration
406            .unwrap_or_else(|| theme.motion.duration_fast.into());
407        let easing = self
408            .animation_easing
409            .unwrap_or(theme.motion.easing_standard);
410        let mut animating = false;
411
412        for item in 0..self.row_motions.len() {
413            if self.active_drag.is_some_and(|drag| drag.item == item) {
414                continue;
415            }
416            let target_y = base_y + offsets.get(item).copied().unwrap_or(0.0);
417            let motion = &mut self.row_motions[item];
418            if animate {
419                animating |= motion.set_target(target_y, ctx.current_time(), duration, easing);
420            } else {
421                motion.jump_to(target_y);
422            }
423        }
424
425        ctx.request_paint();
426        if animating {
427            ctx.request_animation_frame();
428        }
429    }
430
431    fn advance_motions(&mut self, ctx: &mut EventCtx, time: f64) {
432        let mut animating = false;
433        for motion in &mut self.row_motions {
434            animating |= motion.advance(time);
435        }
436        ctx.request_paint();
437        if animating {
438            ctx.request_animation_frame();
439        }
440    }
441
442    fn reset_drag(&mut self, ctx: &mut EventCtx, animate: bool) {
443        self.press = None;
444        self.active_drag = None;
445        self.retarget_row_motions(ctx, animate);
446    }
447
448    fn finish_reorder(&mut self, ctx: &mut EventCtx) {
449        let Some(drag) = self.active_drag else {
450            self.reset_drag(ctx, true);
451            return;
452        };
453        let Some(from) = self.order.iter().position(|item| *item == drag.item) else {
454            self.reset_drag(ctx, true);
455            return;
456        };
457        let mut to = drag.target.min(self.order.len().saturating_sub(1));
458
459        if let Some(motion) = self.row_motions.get_mut(drag.item) {
460            motion.jump_to(drag.position.y - drag.drag_offset_y);
461        }
462
463        if from != to {
464            let item = self.order.remove(from);
465            if to > self.order.len() {
466                to = self.order.len();
467            }
468            self.order.insert(to, item);
469            if let Some(callback) = &mut self.on_reorder {
470                callback(ctx, ReorderableListChange { item, from, to });
471            }
472            ctx.request_semantics();
473        }
474
475        self.reset_drag(ctx, true);
476    }
477
478    fn marker_y(&self) -> Option<f32> {
479        let drag = self.active_drag?;
480        let order = self.desired_order();
481        let (offsets, _) = self.compute_offsets_for_order(&order);
482        let base_y = self.content_y;
483        Some(base_y + offsets.get(drag.item).copied().unwrap_or(0.0))
484    }
485}
486
487impl Widget for ReorderableList {
488    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
489        match event {
490            Event::Pointer(pointer)
491                if pointer.kind == PointerEventKind::Down
492                    && pointer.button == Some(PointerButton::Primary)
493                    && ctx.phase() != sui_runtime::EventPhase::Capture =>
494            {
495                if let Some(press) = self.press_at(pointer.pointer_id, pointer.position) {
496                    self.press = Some(press);
497                    ctx.request_pointer_capture(pointer.pointer_id);
498                    ctx.set_handled();
499                }
500            }
501            Event::Pointer(pointer)
502                if pointer.kind == PointerEventKind::Move
503                    && self
504                        .press
505                        .is_some_and(|press| press.pointer_id == pointer.pointer_id) =>
506            {
507                if let Some(drag) = self.active_drag {
508                    if drag.pointer_id == pointer.pointer_id {
509                        let target = self.target_index_at(drag.item, pointer.position);
510                        self.set_drag_target(ctx, target, pointer.position);
511                        ctx.set_handled();
512                    }
513                    return;
514                }
515
516                let press = self.press.unwrap();
517                let delta = pointer.position - press.start_position;
518                let distance_sq = (delta.x * delta.x) + (delta.y * delta.y);
519                if distance_sq >= self.drag_threshold * self.drag_threshold {
520                    self.start_drag(ctx, press, pointer.position);
521                    ctx.set_handled();
522                }
523            }
524            Event::Pointer(pointer)
525                if matches!(
526                    pointer.kind,
527                    PointerEventKind::Up | PointerEventKind::Cancel
528                ) && self
529                    .press
530                    .is_some_and(|press| press.pointer_id == pointer.pointer_id) =>
531            {
532                if self.active_drag.is_none() {
533                    self.press = None;
534                }
535                ctx.release_pointer_capture(pointer.pointer_id);
536                ctx.set_handled();
537            }
538            Event::Drag(drag) if drag.scope_id == self.scope.id() => {
539                if drag.payload.custom_kind() != Some(REORDERABLE_LIST_PAYLOAD_KIND) {
540                    return;
541                }
542                let Some(payload) = drag.payload.custom_data::<ReorderPayload>() else {
543                    return;
544                };
545                if payload.list != ctx.widget_id().get() {
546                    return;
547                }
548
549                match drag.kind {
550                    DragEventKind::Enter | DragEventKind::Over => {
551                        let target = self.target_index_at(payload.item, drag.position);
552                        self.set_drag_target(ctx, target, drag.position);
553                        ctx.accept_drop(DropEffect::Move);
554                    }
555                    DragEventKind::Leave => {
556                        if self
557                            .active_drag
558                            .is_some_and(|active| active.session_id == drag.session_id)
559                        {
560                            let from = self.active_drag.map(|active| active.from).unwrap_or(0);
561                            self.set_drag_target(ctx, from, drag.position);
562                        }
563                    }
564                    DragEventKind::Drop if drag.target == Some(ctx.widget_id()) => {
565                        self.finish_reorder(ctx);
566                        ctx.set_handled();
567                    }
568                    DragEventKind::End => {
569                        if matches!(drag.outcome, Some(DragOutcome::Cancelled)) {
570                            self.reset_drag(ctx, true);
571                        } else {
572                            self.press = None;
573                            self.active_drag = None;
574                        }
575                    }
576                    _ => {}
577                }
578            }
579            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
580                self.advance_motions(ctx, *time);
581            }
582            _ => {}
583        }
584    }
585
586    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
587        self.sync_storage();
588
589        let child_constraints = Constraints::new(
590            Size::ZERO,
591            Size::new(constraints.max.width.max(0.0), f32::INFINITY),
592        );
593        let mut width: f32 = 0.0;
594        for index in 0..self.children.len() {
595            let size = self.children.measure_child(index, ctx, child_constraints);
596            self.row_sizes[index] = size;
597            width = width.max(size.width);
598        }
599
600        let (_, height) = self.compute_offsets_for_order(&self.order);
601        self.content_height = height;
602        constraints.clamp(Size::new(width, height))
603    }
604
605    fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
606        self.sync_storage();
607        let (offsets, height) = self.compute_offsets_for_order(&self.order);
608        self.content_y = bounds.y();
609        self.row_offsets = offsets.clone();
610        self.content_height = height;
611
612        for (item, &offset) in offsets.iter().enumerate().take(self.children.len()) {
613            let size = Size::new(bounds.width(), self.row_sizes[item].height);
614            let rect = Rect::new(bounds.x(), bounds.y() + offset, size.width, size.height);
615            self.row_bounds[item] = rect;
616            self.children.arrange_child(item, ctx, rect);
617            if !self.row_motions[item].is_animating() && self.active_drag.is_none() {
618                self.row_motions[item].jump_to(rect.y());
619            }
620        }
621    }
622
623    fn paint(&self, ctx: &mut PaintCtx) {
624        let bounds = ctx.bounds();
625        ctx.push_clip_rect(bounds);
626
627        let active_item = self.active_drag.map(|drag| drag.item);
628        for item in self.desired_order() {
629            if active_item == Some(item) {
630                continue;
631            }
632            let rect = self.row_bounds.get(item).copied().unwrap_or(Rect::ZERO);
633            let y = self
634                .row_motions
635                .get(item)
636                .map(|motion| motion.y)
637                .unwrap_or(rect.y());
638            ctx.translate(Vector::new(0.0, y - rect.y()));
639            self.children.as_slice()[item].paint(ctx);
640            ctx.pop_transform();
641        }
642
643        if let Some(marker_y) = self.marker_y() {
644            let theme = self.resolved_theme();
645            let marker = Rect::new(
646                bounds.x() + 4.0,
647                (marker_y - 1.0).max(bounds.y()),
648                (bounds.width() - 8.0).max(0.0),
649                2.0,
650            );
651            ctx.fill(Path::rounded_rect(marker, 1.0), theme.palette.border_focus);
652        }
653
654        if let Some(drag) = self.active_drag {
655            let item = drag.item;
656            let rect = self.row_bounds.get(item).copied().unwrap_or(Rect::ZERO);
657            let y = drag.position.y - drag.drag_offset_y;
658            ctx.push_transform(Transform::translation(0.0, y - rect.y()));
659            self.children.as_slice()[item].paint(ctx);
660            ctx.pop_transform();
661        }
662
663        ctx.pop_clip();
664    }
665
666    fn semantics(&self, ctx: &mut SemanticsCtx) {
667        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::List, ctx.bounds());
668        node.name = Some(self.name.clone());
669        node.actions = vec![SemanticsAction::Focus];
670        ctx.push(node);
671        self.children.semantics(ctx);
672    }
673
674    fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
675        self.children.visit_children(visitor);
676    }
677
678    fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
679        self.children.visit_children_mut(visitor);
680    }
681}
682
683#[cfg(test)]
684mod tests {
685    use std::{cell::RefCell, rc::Rc};
686
687    use super::*;
688    use crate::SizedBox;
689    use sui_core::{Modifiers, PointerButtons, PointerEvent, PointerKind, Result, WindowId};
690    use sui_runtime::{Application, Runtime, WindowBuilder};
691
692    fn primary_pointer(kind: PointerEventKind, position: Point, pressed: bool) -> Event {
693        let mut buttons = PointerButtons::NONE;
694        if pressed {
695            buttons.insert(PointerButton::Primary);
696        }
697        Event::Pointer(PointerEvent {
698            pointer_id: 1,
699            kind,
700            position,
701            delta: Vector::ZERO,
702            scroll_delta: None,
703            button: Some(PointerButton::Primary),
704            buttons,
705            modifiers: Modifiers::NONE,
706            pointer_kind: PointerKind::Mouse,
707            is_primary: true,
708        })
709    }
710
711    fn build_runtime<W>(root: W) -> (Runtime, WindowId)
712    where
713        W: Widget + 'static,
714    {
715        let runtime = Application::new()
716            .window(WindowBuilder::new().title("Reorder").root(root))
717            .build()
718            .unwrap();
719        let window_id = runtime.window_ids()[0];
720        (runtime, window_id)
721    }
722
723    #[test]
724    fn reorderable_list_reports_reorder_after_pointer_drag() -> Result<()> {
725        let changes = Rc::new(RefCell::new(Vec::new()));
726        let list = ReorderableList::new("Tasks")
727            .spacing(0.0)
728            .item(SizedBox::new().width(120.0).height(30.0))
729            .item(SizedBox::new().width(120.0).height(30.0))
730            .item(SizedBox::new().width(120.0).height(30.0))
731            .on_reorder({
732                let changes = Rc::clone(&changes);
733                move |change| changes.borrow_mut().push(change)
734            });
735        let (mut runtime, window_id) = build_runtime(list);
736        let _ = runtime.render(window_id)?;
737
738        runtime.handle_event(
739            window_id,
740            primary_pointer(PointerEventKind::Down, Point::new(10.0, 15.0), true),
741        )?;
742        runtime.handle_event(
743            window_id,
744            primary_pointer(PointerEventKind::Move, Point::new(10.0, 48.0), true),
745        )?;
746        runtime.handle_event(
747            window_id,
748            primary_pointer(PointerEventKind::Move, Point::new(10.0, 78.0), true),
749        )?;
750        runtime.handle_event(
751            window_id,
752            primary_pointer(PointerEventKind::Up, Point::new(10.0, 78.0), false),
753        )?;
754
755        assert_eq!(
756            &*changes.borrow(),
757            &[ReorderableListChange {
758                item: 0,
759                from: 0,
760                to: 2
761            }]
762        );
763        Ok(())
764    }
765}