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}