diff --git a/src/widget/mod.rs b/src/widget/mod.rs index d0dee7c..5089b99 100644 --- a/src/widget/mod.rs +++ b/src/widget/mod.rs @@ -215,6 +215,10 @@ pub mod flex_row; #[doc(inline)] pub use flex_row::{FlexRow, flex_row}; +pub mod reorderable_flex_row; +#[doc(inline)] +pub use reorderable_flex_row::{ReorderableFlexRow, reorderable_flex_row}; + pub mod grid; #[doc(inline)] pub use grid::{Grid, grid}; diff --git a/src/widget/reorderable_flex_row/mod.rs b/src/widget/reorderable_flex_row/mod.rs new file mode 100644 index 0000000..d5da9f4 --- /dev/null +++ b/src/widget/reorderable_flex_row/mod.rs @@ -0,0 +1,8 @@ +// Copyright 2026 System76 +// SPDX-License-Identifier: MPL-2.0 + +//! A keyed wrapping flex row whose items can be dragged to reorder. + +mod widget; + +pub use widget::{ReorderableFlexRow, reorderable_flex_row}; diff --git a/src/widget/reorderable_flex_row/widget.rs b/src/widget/reorderable_flex_row/widget.rs new file mode 100644 index 0000000..ed95a34 --- /dev/null +++ b/src/widget/reorderable_flex_row/widget.rs @@ -0,0 +1,1296 @@ +// Copyright 2026 System76 +// SPDX-License-Identifier: MPL-2.0 + +use crate::{Element, Renderer}; +use iced::{Alignment, Pixels, alignment}; +use iced_core::event::Event; +use iced_core::layout::{self, Layout}; +use iced_core::mouse::{self, Cursor}; +use iced_core::widget::Operation; +use iced_core::widget::tree::{self, Tree}; +#[cfg(feature = "wgpu")] +use iced_core::{Background, Border, Shadow}; +use iced_core::{ + Clipboard, Length, Padding, Point, Rectangle, Renderer as _, Shell, Size, Vector, Widget, + overlay, renderer, window, +}; +use std::collections::{HashMap, HashSet}; +use std::hash::Hash; +use std::time::{Duration, Instant}; + +const DEFAULT_ANIMATION_DURATION: Duration = Duration::from_millis(180); +const DEFAULT_DRAG_LIFT: f32 = 10.0; +const DEFAULT_DRAG_THRESHOLD: f32 = 6.0; +const SHADOW_BLUR_RADIUS: f32 = 20.0; +const POSITION_EPSILON: f32 = 0.5; + +#[derive(Debug, Clone)] +struct SlotAnimation { + from: Point, + to: Point, + started_at: Option, +} + +impl SlotAnimation { + fn new(position: Point) -> Self { + Self { + from: position, + to: position, + started_at: None, + } + } + + fn current_position(&self, duration: Duration) -> Point { + let Some(started_at) = self.started_at else { + return self.to; + }; + + let duration_secs = duration.as_secs_f32(); + if duration_secs <= f32::EPSILON { + return self.to; + } + + let progress = (started_at.elapsed().as_secs_f32() / duration_secs).clamp(0.0, 1.0); + let eased = 1.0 - (1.0 - progress).powi(3); + + Point::new( + self.from.x + (self.to.x - self.from.x) * eased, + self.from.y + (self.to.y - self.from.y) * eased, + ) + } + + fn retarget(&mut self, new_target: Point, duration: Duration) { + if approx_eq_point(self.to, new_target) { + if !self.is_animating(duration) { + self.from = new_target; + self.to = new_target; + self.started_at = None; + } + return; + } + + self.from = self.current_position(duration); + self.to = new_target; + self.started_at = Some(Instant::now()); + } + + fn is_animating(&self, duration: Duration) -> bool { + self.started_at + .is_some_and(|started_at| started_at.elapsed() < duration) + } + + fn finish_if_done(&mut self, duration: Duration) { + if self + .started_at + .is_some_and(|started_at| started_at.elapsed() >= duration) + { + self.from = self.to; + self.started_at = None; + } + } +} + +#[derive(Debug, Clone)] +struct PendingDragState +where + Key: Clone + Eq + Hash + 'static, +{ + key: Key, + item_index: usize, + original_index: usize, + press_local: Point, + pointer_offset: Vector, +} + +#[derive(Debug, Clone)] +struct DragState +where + Key: Clone + Eq + Hash + 'static, +{ + key: Key, + item_index: usize, + original_index: usize, + current_index: usize, + cursor_local: Point, + pointer_offset: Vector, +} + +#[derive(Debug, Clone)] +struct State +where + Key: Clone + Eq + Hash + 'static, +{ + keys: Vec, + slot_positions: HashMap, + pending_drag: Option>, + drag: Option>, + wrap_width: f32, + initialized: bool, +} + +impl Default for State +where + Key: Clone + Eq + Hash + 'static, +{ + fn default() -> Self { + Self { + keys: Vec::new(), + slot_positions: HashMap::new(), + pending_drag: None, + drag: None, + wrap_width: f32::INFINITY, + initialized: false, + } + } +} + +impl State +where + Key: Clone + Eq + Hash + 'static, +{ + fn retain_keys(&mut self, keys: &[Key]) { + let keep: HashSet<_> = keys.iter().cloned().collect(); + self.slot_positions.retain(|key, _| keep.contains(key)); + + if self + .pending_drag + .as_ref() + .is_some_and(|drag| !keep.contains(&drag.key)) + { + self.pending_drag = None; + } + + if self + .drag + .as_ref() + .is_some_and(|drag| !keep.contains(&drag.key)) + { + self.drag = None; + } + } + + fn finish_animations(&mut self, duration: Duration) { + self.slot_positions + .values_mut() + .for_each(|slot| slot.finish_if_done(duration)); + } + + fn is_animating(&self, duration: Duration) -> bool { + self.slot_positions + .values() + .any(|slot| slot.is_animating(duration)) + } + + fn current_slot_position(&self, key: &Key, fallback: Point, duration: Duration) -> Point { + self.slot_positions + .get(key) + .map(|slot| slot.current_position(duration)) + .unwrap_or(fallback) + } + + fn retarget_slot(&mut self, key: &Key, target: Point, duration: Duration) { + self.slot_positions + .entry(key.clone()) + .or_insert_with(|| SlotAnimation::new(target)) + .retarget(target, duration); + } + + fn snap_slot(&mut self, key: &Key, target: Point) { + self.slot_positions + .insert(key.clone(), SlotAnimation::new(target)); + } + + fn apply_layout_position(&mut self, key: &Key, target: Point, duration: Duration) { + if self.initialized { + self.retarget_slot(key, target, duration); + } else { + self.snap_slot(key, target); + } + } +} + +#[derive(Debug, Clone)] +struct LocalSlot +where + Key: Clone + Eq + Hash + 'static, +{ + key: Key, + locked: bool, + bounds: Rectangle, +} + +/// A horizontal flex row with drag-to-reorder behavior. +#[must_use] +pub struct ReorderableFlexRow<'a, Key, Message> +where + Key: Clone + Eq + Hash + 'static, +{ + spacing: f32, + padding: Padding, + width: Length, + height: Length, + align: Alignment, + clip: bool, + drag_lift: f32, + animation_duration: Duration, + on_reorder: Box) -> Message + 'a>, + keys: Vec, + locked: Vec, + children: Vec>, +} + +impl<'a, Key, Message> ReorderableFlexRow<'a, Key, Message> +where + Key: Clone + Eq + Hash + 'static, +{ + pub fn new(on_reorder: impl Fn(Vec) -> Message + 'a) -> Self { + Self { + spacing: 0.0, + padding: Padding::ZERO, + width: Length::Shrink, + height: Length::Shrink, + align: Alignment::Start, + clip: false, + drag_lift: DEFAULT_DRAG_LIFT, + animation_duration: DEFAULT_ANIMATION_DURATION, + on_reorder: Box::new(on_reorder), + keys: Vec::new(), + locked: Vec::new(), + children: Vec::new(), + } + } + + pub fn with_capacity(capacity: usize, on_reorder: impl Fn(Vec) -> Message + 'a) -> Self { + let mut row = Self::new(on_reorder); + row.keys = Vec::with_capacity(capacity); + row.locked = Vec::with_capacity(capacity); + row.children = Vec::with_capacity(capacity); + row + } + + pub fn spacing(mut self, amount: impl Into) -> Self { + self.spacing = amount.into().0; + self + } + + pub fn padding>(mut self, padding: P) -> Self { + self.padding = padding.into(); + self + } + + pub fn width(mut self, width: impl Into) -> Self { + self.width = width.into(); + self + } + + pub fn height(mut self, height: impl Into) -> Self { + self.height = height.into(); + self + } + + pub fn align_y(mut self, align: impl Into) -> Self { + self.align = Alignment::from(align.into()); + self + } + + /// Leave disabled for dragged item to visibly lift above the row. + pub fn clip(mut self, clip: bool) -> Self { + self.clip = clip; + self + } + + pub fn drag_lift(mut self, lift: f32) -> Self { + self.drag_lift = lift.max(0.0); + self + } + + pub fn animation_duration(mut self, duration: Duration) -> Self { + self.animation_duration = duration; + self + } + + pub fn push(self, key: Key, child: impl Into>) -> Self { + self.push_with_lock(key, false, child) + } + + /// Item stays fixed, never participates in reordering. + pub fn push_locked(self, key: Key, child: impl Into>) -> Self { + self.push_with_lock(key, true, child) + } + + fn push_with_lock( + mut self, + key: Key, + locked: bool, + child: impl Into>, + ) -> Self { + let child = child.into(); + let child_size = child.as_widget().size_hint(); + + if !child_size.is_void() { + self.width = self.width.enclose(child_size.width); + self.height = self.height.enclose(child_size.height); + self.keys.push(key); + self.locked.push(locked); + self.children.push(child); + } + + self + } + + pub fn extend(self, items: impl IntoIterator)>) -> Self { + items + .into_iter() + .fold(self, |row, (key, child)| row.push(key, child)) + } + + pub fn extend_locked( + self, + items: impl IntoIterator)>, + ) -> Self { + items + .into_iter() + .fold(self, |row, (key, child)| row.push_locked(key, child)) + } + + fn item_local_slots_from_layout( + &self, + bounds: Rectangle, + child_layouts: &[Layout<'_>], + ) -> Vec> { + self.keys + .iter() + .zip(self.locked.iter()) + .zip(child_layouts.iter()) + .map(|((key, locked), child_layout)| { + let child_bounds = child_layout.bounds(); + LocalSlot { + key: key.clone(), + locked: *locked, + bounds: Rectangle { + x: child_bounds.x - bounds.x, + y: child_bounds.y - bounds.y, + width: child_bounds.width, + height: child_bounds.height, + }, + } + }) + .collect() + } + + fn sync_slot_positions(&self, state: &mut State, slots: &[LocalSlot]) { + let ordered_keys: Vec = slots.iter().map(|slot| slot.key.clone()).collect(); + state.retain_keys(&ordered_keys); + + let size_by_key: HashMap = slots + .iter() + .map(|slot| { + ( + slot.key.clone(), + Size::new(slot.bounds.width, slot.bounds.height), + ) + }) + .collect(); + let locked_by_key: HashMap = slots + .iter() + .map(|slot| (slot.key.clone(), slot.locked)) + .collect(); + + let Some(drag_snapshot) = state.drag.as_ref().map(|drag| { + ( + drag.key.clone(), + drag.cursor_local, + drag.pointer_offset, + drag.item_index, + ) + }) else { + for slot in slots { + state.apply_layout_position( + &slot.key, + Point::new(slot.bounds.x, slot.bounds.y), + self.animation_duration, + ); + } + return; + }; + + let (drag_key, cursor_local, pointer_offset, drag_item_index) = drag_snapshot; + + let Some(dragged_slot) = slots.iter().find(|slot| slot.key == drag_key) else { + state.drag = None; + for slot in slots { + state.apply_layout_position( + &slot.key, + Point::new(slot.bounds.x, slot.bounds.y), + self.animation_duration, + ); + } + return; + }; + + if dragged_slot.locked { + state.drag = None; + return; + } + + let dragged_center = Point::new( + cursor_local.x - pointer_offset.x + dragged_slot.bounds.width / 2.0, + cursor_local.y - pointer_offset.y + dragged_slot.bounds.height / 2.0, + ); + let target_index = target_index_for_drag(slots, &drag_key, dragged_center); + let prior_index = state.drag.as_ref().map(|drag| drag.current_index); + + if let Some(drag) = state.drag.as_mut() { + drag.current_index = target_index; + drag.item_index = drag_item_index; + } + + if prior_index == Some(target_index) { + return; + } + + let reordered_keys = + reordered_keys_for_drag(&ordered_keys, &locked_by_key, &drag_key, target_index); + let (target_slots, _) = compute_wrapped_slots( + &reordered_keys, + &locked_by_key, + &size_by_key, + state.wrap_width, + self.padding, + self.spacing, + self.align, + ); + let target_positions: HashMap = target_slots + .iter() + .map(|slot| (slot.key.clone(), Point::new(slot.bounds.x, slot.bounds.y))) + .collect(); + + for slot in slots { + let target = target_positions + .get(&slot.key) + .copied() + .unwrap_or(Point::new(slot.bounds.x, slot.bounds.y)); + state.retarget_slot(&slot.key, target, self.animation_duration); + } + } +} + +impl<'a, Key, Message> Widget + for ReorderableFlexRow<'a, Key, Message> +where + Key: Clone + Eq + Hash + 'static, + Message: 'a, +{ + fn tag(&self) -> tree::Tag { + tree::Tag::of::>() + } + + fn state(&self) -> tree::State { + tree::State::new(State { + keys: self.keys.clone(), + ..State::default() + }) + } + + fn children(&self) -> Vec { + self.children.iter().map(Tree::new).collect() + } + + fn diff(&mut self, tree: &mut Tree) { + let Tree { + state, children, .. + } = tree; + let state = state.downcast_mut::>(); + let previous_keys = state.keys.clone(); + let previous_children = std::mem::take(children); + let mut previous_by_key = HashMap::with_capacity(previous_keys.len()); + + for (key, child_tree) in previous_keys.into_iter().zip(previous_children) { + previous_by_key.insert(key, child_tree); + } + + children.reserve(self.children.len()); + + for (key, child) in self.keys.iter().cloned().zip(self.children.iter_mut()) { + let mut child_tree = previous_by_key + .remove(&key) + .unwrap_or_else(|| Tree::new(child.as_widget())); + child.as_widget_mut().diff(&mut child_tree); + children.push(child_tree); + } + + if state.keys != self.keys { + state.keys.clone_from(&self.keys); + } + state.retain_keys(&self.keys); + } + + fn size(&self) -> Size { + Size { + width: self.width, + height: self.height, + } + } + + fn layout( + &mut self, + tree: &mut Tree, + renderer: &Renderer, + limits: &layout::Limits, + ) -> layout::Node { + let limits = limits + .width(self.width) + .height(self.height) + .shrink(self.padding); + let child_limits = limits.loose(); + let wrap_width = limits.max().width; + + let mut nodes = Vec::with_capacity(self.children.len()); + let mut size_by_key = HashMap::with_capacity(self.children.len()); + let locked_by_key: HashMap = self + .keys + .iter() + .cloned() + .zip(self.locked.iter().copied()) + .collect(); + + for ((key, child), child_tree) in self + .keys + .iter() + .zip(self.children.iter_mut()) + .zip(tree.children.iter_mut()) + { + let node = child + .as_widget_mut() + .layout(child_tree, renderer, &child_limits); + size_by_key.insert(key.clone(), node.size()); + nodes.push(node); + } + + let (slots, intrinsic_size) = compute_wrapped_slots( + &self.keys, + &locked_by_key, + &size_by_key, + wrap_width, + self.padding, + self.spacing, + self.align, + ); + + for (node, slot) in nodes.iter_mut().zip(&slots) { + node.move_to_mut(Point::new(slot.bounds.x, slot.bounds.y)); + } + + let size = limits.resolve(self.width, self.height, intrinsic_size); + let node = layout::Node::with_children(size.expand(self.padding), nodes); + let state = tree.state.downcast_mut::>(); + state.wrap_width = wrap_width; + self.sync_slot_positions(state, &slots); + + node + } + + fn operate( + &mut self, + tree: &mut Tree, + layout: Layout<'_>, + renderer: &Renderer, + operation: &mut dyn Operation, + ) { + operation.container(None, layout.bounds()); + operation.traverse(&mut |operation| { + self.children + .iter_mut() + .zip(&mut tree.children) + .zip(layout.children()) + .for_each(|((child, state), child_layout)| { + child.as_widget_mut().operate( + state, + child_layout.with_virtual_offset(layout.virtual_offset()), + renderer, + operation, + ); + }); + }); + } + + fn update( + &mut self, + tree: &mut Tree, + event: &Event, + layout: Layout<'_>, + cursor: Cursor, + renderer: &Renderer, + clipboard: &mut dyn Clipboard, + shell: &mut Shell<'_, Message>, + viewport: &Rectangle, + ) { + let bounds = layout.bounds(); + let state = tree.state.downcast_mut::>(); + let child_layouts: Vec<_> = layout.children().collect(); + + if let Event::Window(window::Event::RedrawRequested(_)) = event { + state.initialized = true; + state.finish_animations(self.animation_duration); + if state.drag.is_some() || state.is_animating(self.animation_duration) { + shell.request_redraw(); + } + } + + match event { + Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => { + if state.drag.is_none() + && state.pending_drag.is_none() + && let Some(cursor_pos) = cursor.position() + && let Some((index, child_layout)) = child_layouts + .iter() + .enumerate() + .find(|(_, child_layout)| child_layout.bounds().contains(cursor_pos)) + && !self.locked.get(index).copied().unwrap_or(false) + && let Some(reorder_index) = reorderable_index_for_child(&self.locked, index) + { + let child_bounds = child_layout.bounds(); + state.pending_drag = Some(PendingDragState { + key: self.keys[index].clone(), + item_index: index, + original_index: reorder_index, + press_local: Point::new(cursor_pos.x - bounds.x, cursor_pos.y - bounds.y), + pointer_offset: Vector::new( + cursor_pos.x - child_bounds.x, + cursor_pos.y - child_bounds.y, + ), + }); + } + } + Event::Mouse(mouse::Event::CursorMoved { .. }) => { + if let Some(pending) = state.pending_drag.clone() + && let Some(cursor_pos) = cursor.position() + { + let cursor_local = Point::new(cursor_pos.x - bounds.x, cursor_pos.y - bounds.y); + let delta = Vector::new( + cursor_local.x - pending.press_local.x, + cursor_local.y - pending.press_local.y, + ); + let distance = (delta.x.powi(2) + delta.y.powi(2)).sqrt(); + + if distance >= DEFAULT_DRAG_THRESHOLD { + if let (Some(child), Some(child_tree), Some(child_layout)) = ( + self.children.get_mut(pending.item_index), + tree.children.get_mut(pending.item_index), + child_layouts.get(pending.item_index), + ) { + let cursor_left = Event::Mouse(mouse::Event::CursorLeft); + child.as_widget_mut().update( + child_tree, + &cursor_left, + child_layout.with_virtual_offset(layout.virtual_offset()), + cursor, + renderer, + clipboard, + shell, + viewport, + ); + } + + state.pending_drag = None; + state.drag = Some(DragState { + key: pending.key, + item_index: pending.item_index, + original_index: pending.original_index, + current_index: pending.original_index, + cursor_local, + pointer_offset: pending.pointer_offset, + }); + let slots = self.item_local_slots_from_layout(bounds, &child_layouts); + self.sync_slot_positions(state, &slots); + shell.capture_event(); + shell.request_redraw(); + return; + } + } + + if let Some(drag) = state.drag.as_mut() + && let Some(cursor_pos) = cursor.position() + { + drag.cursor_local = + Point::new(cursor_pos.x - bounds.x, cursor_pos.y - bounds.y); + let slots = self.item_local_slots_from_layout(bounds, &child_layouts); + self.sync_slot_positions(state, &slots); + shell.capture_event(); + shell.request_redraw(); + return; + } + } + Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => { + state.pending_drag = None; + + if state.drag.is_some() { + let slots = self.item_local_slots_from_layout(bounds, &child_layouts); + self.sync_slot_positions(state, &slots); + } + if let Some(drag) = state.drag.take() { + if drag.current_index != drag.original_index { + let locked_by_key: HashMap = self + .keys + .iter() + .cloned() + .zip(self.locked.iter().copied()) + .collect(); + let new_order = reordered_keys_for_drag( + &self.keys, + &locked_by_key, + &drag.key, + drag.current_index, + ); + shell.publish((self.on_reorder)(new_order)); + } + shell.capture_event(); + shell.request_redraw(); + return; + } + } + _ => {} + } + + if state.drag.is_some() { + return; + } + + for ((item, tree), child_layout) in self + .children + .iter_mut() + .zip(&mut tree.children) + .zip(child_layouts.into_iter()) + { + item.as_widget_mut().update( + tree, + event, + child_layout.with_virtual_offset(layout.virtual_offset()), + cursor, + renderer, + clipboard, + shell, + viewport, + ); + } + } + + fn mouse_interaction( + &self, + tree: &Tree, + layout: Layout<'_>, + cursor: Cursor, + viewport: &Rectangle, + renderer: &Renderer, + ) -> mouse::Interaction { + let state = tree.state.downcast_ref::>(); + + if state.drag.is_some() { + return mouse::Interaction::Grabbing; + } + + if let Some(cursor_pos) = cursor.position() + && self + .locked + .iter() + .zip(layout.children()) + .any(|(locked, child_layout)| { + !*locked && child_layout.bounds().contains(cursor_pos) + }) + { + return mouse::Interaction::Grab; + } + + self.children + .iter() + .zip(&tree.children) + .zip(layout.children()) + .map(|((child, tree), child_layout)| { + child.as_widget().mouse_interaction( + tree, + child_layout.with_virtual_offset(layout.virtual_offset()), + cursor, + viewport, + renderer, + ) + }) + .max() + .unwrap_or_default() + } + + fn draw( + &self, + tree: &Tree, + renderer: &mut Renderer, + theme: &crate::Theme, + style: &renderer::Style, + layout: Layout<'_>, + cursor: Cursor, + viewport: &Rectangle, + ) { + let state = tree.state.downcast_ref::>(); + let bounds = layout.bounds(); + + let Some(clipped_viewport) = bounds.intersection(viewport) else { + return; + }; + + let viewport = if self.clip { + &clipped_viewport + } else { + viewport + }; + let drag_key = state.drag.as_ref().map(|drag| &drag.key); + let drag_item = state.drag.as_ref().and_then(|drag| { + self.keys + .iter() + .zip(&self.children) + .zip(&tree.children) + .zip(layout.children()) + .find_map(|(((key, child), state), child_layout)| { + (key == &drag.key).then_some((key, child, state, child_layout, drag)) + }) + }); + + for (((key, child), child_tree), child_layout) in self + .keys + .iter() + .zip(&self.children) + .zip(&tree.children) + .zip(layout.children()) + { + if drag_key.is_some_and(|drag_key| drag_key == key) { + continue; + } + + let child_layout = child_layout.with_virtual_offset(layout.virtual_offset()); + let child_bounds = child_layout.bounds(); + let base_local = Point::new(child_bounds.x - bounds.x, child_bounds.y - bounds.y); + let target_local = + state.current_slot_position(key, base_local, self.animation_duration); + let translation = + Vector::new(target_local.x - base_local.x, target_local.y - base_local.y); + let translated_bounds = translate_rect(child_bounds, translation); + + if translated_bounds.intersects(viewport) { + renderer.with_translation(translation, |renderer| { + child.as_widget().draw( + child_tree, + renderer, + theme, + style, + child_layout, + cursor, + viewport, + ); + }); + } + } + + if let Some((_key, child, child_tree, child_layout, drag)) = drag_item { + let child_layout = child_layout.with_virtual_offset(layout.virtual_offset()); + let child_bounds = child_layout.bounds(); + let base_local = Point::new(child_bounds.x - bounds.x, child_bounds.y - bounds.y); + let drag_local = Point::new( + drag.cursor_local.x - drag.pointer_offset.x, + drag.cursor_local.y - drag.pointer_offset.y - self.drag_lift, + ); + let translation = Vector::new(drag_local.x - base_local.x, drag_local.y - base_local.y); + + #[cfg(feature = "wgpu")] + { + let translated_bounds = translate_rect(child_bounds, translation); + draw_drag_backdrop(renderer, theme, translated_bounds); + } + + renderer.with_translation(translation, |renderer| { + child.as_widget().draw( + child_tree, + renderer, + theme, + style, + child_layout, + cursor, + viewport, + ); + }); + } + } + + fn overlay<'b>( + &'b mut self, + tree: &'b mut Tree, + layout: Layout<'b>, + renderer: &Renderer, + viewport: &Rectangle, + translation: Vector, + ) -> Option> { + overlay::from_children( + &mut self.children, + tree, + layout, + renderer, + viewport, + translation, + ) + } + + fn drag_destinations( + &self, + state: &Tree, + layout: Layout<'_>, + renderer: &Renderer, + dnd_rectangles: &mut iced_core::clipboard::DndDestinationRectangles, + ) { + for ((item, child_layout), child_state) in self + .children + .iter() + .zip(layout.children()) + .zip(state.children.iter()) + { + item.as_widget().drag_destinations( + child_state, + child_layout.with_virtual_offset(layout.virtual_offset()), + renderer, + dnd_rectangles, + ); + } + } +} + +impl<'a, Key, Message> From> for Element<'a, Message> +where + Key: Clone + Eq + Hash + 'static, + Message: 'a, +{ + fn from(row: ReorderableFlexRow<'a, Key, Message>) -> Self { + Element::new(row) + } +} + +/// Create a horizontal flex row with drag-to-reorder behavior. +pub fn reorderable_flex_row<'a, Key, Message>( + on_reorder: impl Fn(Vec) -> Message + 'a, +) -> ReorderableFlexRow<'a, Key, Message> +where + Key: Clone + Eq + Hash + 'static, +{ + ReorderableFlexRow::new(on_reorder) +} + +fn compute_wrapped_slots( + ordered_keys: &[Key], + locked_by_key: &HashMap, + size_by_key: &HashMap, + wrap_width: f32, + padding: Padding, + spacing: f32, + align: Alignment, +) -> (Vec>, Size) +where + Key: Clone + Eq + Hash + 'static, +{ + let wrap_width = if wrap_width.is_finite() { + wrap_width.max(0.0) + } else { + f32::INFINITY + }; + + let mut slots = Vec::with_capacity(ordered_keys.len()); + let mut intrinsic_size = Size::ZERO; + let mut row_start = 0; + let mut row_height = 0.0; + let mut x = 0.0; + let mut y = 0.0; + + let align_factor = match align { + Alignment::Start => 0.0, + Alignment::Center => 2.0, + Alignment::End => 1.0, + }; + + let align_row = + |range: std::ops::Range, row_height: f32, slots: &mut [LocalSlot]| { + if align_factor == 0.0 { + return; + } + + for slot in &mut slots[range] { + slot.bounds.y += (row_height - slot.bounds.height) / align_factor; + } + }; + + for (index, key) in ordered_keys.iter().enumerate() { + let size = size_by_key.get(key).copied().unwrap_or(Size::ZERO); + + if x != 0.0 && x + size.width > wrap_width { + intrinsic_size.width = intrinsic_size.width.max(x - spacing); + align_row(row_start..index, row_height, &mut slots); + y += row_height + spacing; + x = 0.0; + row_start = index; + row_height = 0.0; + } + + row_height = row_height.max(size.height); + + slots.push(LocalSlot { + key: key.clone(), + locked: locked_by_key.get(key).copied().unwrap_or(false), + bounds: Rectangle { + x: x + padding.left, + y: y + padding.top, + width: size.width, + height: size.height, + }, + }); + + x += size.width + spacing; + } + + if x != 0.0 { + intrinsic_size.width = intrinsic_size.width.max(x - spacing); + } + + intrinsic_size.height = y + row_height; + align_row(row_start..slots.len(), row_height, &mut slots); + + (slots, intrinsic_size) +} + +fn reordered_keys_for_drag( + ordered_keys: &[Key], + locked_by_key: &HashMap, + dragged_key: &Key, + target_index: usize, +) -> Vec +where + Key: Clone + Eq + Hash + 'static, +{ + let movable_keys: Vec = ordered_keys + .iter() + .filter(|key| !locked_by_key.get(*key).copied().unwrap_or(false)) + .cloned() + .collect(); + let mut remaining: Vec = movable_keys + .iter() + .filter(|key| *key != dragged_key) + .cloned() + .collect(); + + remaining.insert(target_index.min(remaining.len()), dragged_key.clone()); + merge_locked_and_reordered_keys(ordered_keys, locked_by_key, &remaining) +} + +/// Picks insertion index among movable items using row-aware midpoint rule. +/// +/// Walks laid-out slots in reading order, counting how many non-dragged movable +/// items the cursor has moved past. Skips locked slots. O(n) single pass, no +/// allocations. +fn target_index_for_drag( + slots: &[LocalSlot], + dragged_key: &Key, + dragged_center: Point, +) -> usize +where + Key: Clone + Eq + Hash + 'static, +{ + let mut target = 0; + let mut passed_movable: usize = 0; + let mut found_target = false; + + let mut i = 0; + while i < slots.len() { + let slot = &slots[i]; + + if slot.locked || &slot.key == dragged_key { + i += 1; + continue; + } + + let row_top = slot.bounds.y; + let row_bottom = row_top + slot.bounds.height; + + if !found_target && dragged_center.y < row_top { + target = passed_movable; + found_target = true; + break; + } + + if dragged_center.y > row_bottom { + passed_movable += 1; + i += 1; + continue; + } + + let center_x = slot.bounds.x + slot.bounds.width / 2.0; + if dragged_center.x < center_x { + target = passed_movable; + found_target = true; + break; + } + + passed_movable += 1; + i += 1; + } + + if !found_target { + target = passed_movable; + } + + target +} + +fn reorderable_index_for_child(locked: &[bool], item_index: usize) -> Option { + (!locked.get(item_index).copied().unwrap_or(false)).then(|| { + locked[..item_index] + .iter() + .filter(|is_locked| !**is_locked) + .count() + }) +} + +fn merge_locked_and_reordered_keys( + ordered_keys: &[Key], + locked_by_key: &HashMap, + reordered_movable_keys: &[Key], +) -> Vec +where + Key: Clone + Eq + Hash + 'static, +{ + let mut movable = reordered_movable_keys.iter(); + + ordered_keys + .iter() + .map(|key| { + if locked_by_key.get(key).copied().unwrap_or(false) { + key.clone() + } else { + movable.next().cloned().unwrap_or_else(|| key.clone()) + } + }) + .collect() +} + +fn approx_eq_point(a: Point, b: Point) -> bool { + (a.x - b.x).abs() <= POSITION_EPSILON && (a.y - b.y).abs() <= POSITION_EPSILON +} + +fn translate_rect(bounds: Rectangle, translation: Vector) -> Rectangle { + Rectangle { + x: bounds.x + translation.x, + y: bounds.y + translation.y, + width: bounds.width, + height: bounds.height, + } +} + +#[cfg(feature = "wgpu")] +fn draw_drag_backdrop(renderer: &mut Renderer, theme: &crate::Theme, bounds: Rectangle) { + let cosmic = theme.cosmic(); + let backdrop = iced::Color { + a: 0.08, + ..iced::Color::from(cosmic.bg_component_color()) + }; + + renderer.fill_quad( + renderer::Quad { + bounds, + border: Border { + radius: cosmic.corner_radii.radius_m.into(), + ..Border::default() + }, + shadow: Shadow { + color: cosmic.shade.into(), + offset: Vector::new(0.0, 8.0), + blur_radius: SHADOW_BLUR_RADIUS, + }, + snap: true, + }, + Background::Color(backdrop), + ); +} + +#[cfg(test)] +mod tests { + use super::{compute_wrapped_slots, reordered_keys_for_drag, target_index_for_drag}; + use iced::{Alignment, Padding, Point, Size}; + use std::collections::HashMap; + + fn size_map(keys: &[usize], width: f32, height: f32) -> HashMap { + keys.iter() + .copied() + .map(|key| (key, Size::new(width, height))) + .collect() + } + + fn locked_map(keys: &[usize], locked_keys: &[usize]) -> HashMap { + keys.iter() + .copied() + .map(|key| (key, locked_keys.contains(&key))) + .collect() + } + + #[test] + fn compute_wrapped_slots_creates_new_rows() { + let ordered_keys = vec![0, 1, 2]; + let locked_by_key = locked_map(&ordered_keys, &[]); + let size_by_key = size_map(&ordered_keys, 100.0, 40.0); + let (slots, intrinsic_size) = compute_wrapped_slots( + &ordered_keys, + &locked_by_key, + &size_by_key, + 220.0, + Padding::ZERO, + 10.0, + Alignment::Start, + ); + + assert_eq!(slots[0].bounds.x, 0.0); + assert_eq!(slots[0].bounds.y, 0.0); + assert_eq!(slots[1].bounds.x, 110.0); + assert_eq!(slots[1].bounds.y, 0.0); + assert_eq!(slots[2].bounds.x, 0.0); + assert_eq!(slots[2].bounds.y, 50.0); + assert_eq!(intrinsic_size.width, 210.0); + assert_eq!(intrinsic_size.height, 90.0); + } + + #[test] + fn reordered_keys_for_drag_inserts_key_at_target_index() { + let keys = [0, 1, 2, 3]; + let locked_by_key = locked_map(&keys, &[]); + let reordered = reordered_keys_for_drag(&keys, &locked_by_key, &0, 3); + assert_eq!(reordered, vec![1, 2, 3, 0]); + } + + #[test] + fn target_index_tracks_wrapped_drop_positions() { + let ordered_keys = vec![0, 1, 2, 3]; + let locked_by_key = locked_map(&ordered_keys, &[]); + let size_by_key = size_map(&ordered_keys, 100.0, 40.0); + + let (slots, _) = compute_wrapped_slots( + &ordered_keys, + &locked_by_key, + &size_by_key, + 220.0, + Padding::ZERO, + 10.0, + Alignment::Start, + ); + + let target_index = target_index_for_drag(&slots, &0, Point::new(160.0, 70.0)); + + assert_eq!(target_index, 3); + } + + #[test] + fn reordered_keys_for_drag_preserves_locked_positions() { + let keys = [10, 11, 12, 13]; + let locked_by_key = locked_map(&keys, &[10, 13]); + let reordered = reordered_keys_for_drag(&keys, &locked_by_key, &11, 1); + + assert_eq!(reordered, vec![10, 12, 11, 13]); + } +}