use iced::advanced::layout;
use iced::advanced::mouse;
use iced::advanced::overlay;
use iced::advanced::renderer;
use iced::advanced::widget::operation::scrollable::AbsoluteOffset;
use iced::advanced::widget::operation::{self, Operation};
use iced::advanced::widget::{tree, Id, Tree};
use iced::advanced::{Clipboard, Layout, Shell, Widget};
use iced::{keyboard, window, Border, Color, Element, Event, Length, Point, Rectangle, Size, Vector};
use std::collections::HashMap;
pub const THRESHOLD: f32 = 8.0;
pub const EDGE: f32 = 36.0;
pub const SPEED: f32 = 18.0;
type OnSelect<'a, Message> = Box<dyn Fn(Vec<usize>, bool) -> Message + 'a>;
pub struct Marquee<'a, Message, Theme = iced::Theme, Renderer = iced::Renderer> {
content: Element<'a, Message, Theme, Renderer>,
targets: HashMap<Id, usize>,
scroll: Option<Id>,
on_start: Option<Message>,
on_select: Option<OnSelect<'a, Message>>,
on_end: Option<Message>,
on_clear: Option<Message>,
}
pub fn marquee<'a, Message, Theme, Renderer>(
content: impl Into<Element<'a, Message, Theme, Renderer>>,
) -> Marquee<'a, Message, Theme, Renderer> {
Marquee {
content: content.into(),
targets: HashMap::new(),
scroll: None,
on_start: None,
on_select: None,
on_end: None,
on_clear: None,
}
}
impl<'a, Message, Theme, Renderer> Marquee<'a, Message, Theme, Renderer> {
pub fn targets(mut self, targets: HashMap<Id, usize>) -> Self {
self.targets = targets;
self
}
pub fn scroll(mut self, id: Id) -> Self {
self.scroll = Some(id);
self
}
pub fn on_start(mut self, message: Message) -> Self {
self.on_start = Some(message);
self
}
pub fn on_select(mut self, f: impl Fn(Vec<usize>, bool) -> Message + 'a) -> Self {
self.on_select = Some(Box::new(f));
self
}
pub fn on_end(mut self, message: Message) -> Self {
self.on_end = Some(message);
self
}
pub fn on_clear(mut self, message: Message) -> Self {
self.on_clear = Some(message);
self
}
}
#[derive(Debug, Clone, Default)]
struct State {
press: Option<Point>,
anchor: Point,
active: bool,
cursor: Point,
translation: Vector,
last: Vec<usize>,
modifiers: keyboard::Modifiers,
}
pub fn band_rect(anchor: Point, translation: Vector, cursor: Point) -> Rectangle {
let start = anchor - translation;
let (x0, x1) = (start.x.min(cursor.x), start.x.max(cursor.x));
let (y0, y1) = (start.y.min(cursor.y), start.y.max(cursor.y));
Rectangle { x: x0, y: y0, width: x1 - x0, height: y1 - y0 }
}
pub fn edge_scroll(y: f32, top: f32, bottom: f32) -> f32 {
let ramp = |into: f32| SPEED * (1.0 - (into / EDGE)).clamp(0.0, 1.0);
if y < top + EDGE {
-ramp(y - top)
} else if y > bottom - EDGE {
ramp(bottom - y)
} else {
0.0
}
}
struct Gather<'t> {
rect: Rectangle,
targets: &'t HashMap<Id, usize>,
scroll: Option<&'t Id>,
found: Vec<usize>,
translation: Option<Vector>,
frames: Vec<Frame>,
entering: Option<Frame>,
}
#[derive(Clone, Copy)]
struct Frame {
translation: Vector,
visible: Option<Rectangle>,
}
impl<'t> Gather<'t> {
fn new(rect: Rectangle, targets: &'t HashMap<Id, usize>, scroll: Option<&'t Id>) -> Self {
Gather {
rect,
targets,
scroll,
found: Vec::new(),
translation: None,
frames: vec![Frame { translation: Vector::ZERO, visible: None }],
entering: None,
}
}
fn frame(&self) -> Frame {
self.frames.last().copied().unwrap_or(Frame { translation: Vector::ZERO, visible: None })
}
}
impl Operation for Gather<'_> {
fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation)) {
let next = self.entering.take().unwrap_or_else(|| self.frame());
self.frames.push(next);
operate(self);
self.frames.pop();
}
fn container(&mut self, id: Option<&Id>, bounds: Rectangle) {
let Some(&index) = id.and_then(|id| self.targets.get(id)) else { return };
let frame = self.frame();
let drawn = Rectangle { x: bounds.x - frame.translation.x, y: bounds.y - frame.translation.y, ..bounds };
let shown = match frame.visible {
Some(visible) => visible.intersection(&drawn),
None => Some(drawn),
};
if shown.is_some_and(|shown| shown.intersects(&self.rect)) {
self.found.push(index);
}
}
fn scrollable(
&mut self,
id: Option<&Id>,
bounds: Rectangle,
_content_bounds: Rectangle,
translation: Vector,
_state: &mut dyn operation::Scrollable,
) {
if self.scroll.is_some() && id == self.scroll {
self.translation = Some(translation);
}
let outer = self.frame();
let viewport = Rectangle { x: bounds.x - outer.translation.x, y: bounds.y - outer.translation.y, ..bounds };
let visible = match outer.visible {
Some(v) => v.intersection(&viewport),
None => Some(viewport),
};
self.entering = Some(Frame {
translation: outer.translation + translation,
visible: Some(visible.unwrap_or(Rectangle::new(Point::ORIGIN, Size::ZERO))),
});
}
}
impl<'a, Message, Theme, Renderer> Marquee<'a, Message, Theme, Renderer>
where
Renderer: renderer::Renderer,
Message: Clone,
{
fn gather(&mut self, tree: &mut Tree, layout: Layout<'_>, renderer: &Renderer, rect: Rectangle) -> (Vec<usize>, Vector) {
let mut gather = Gather::new(rect, &self.targets, self.scroll.as_ref());
self.content.as_widget_mut().operate(&mut tree.children[0], layout, renderer, &mut gather);
let mut found = gather.found;
found.sort_unstable();
found.dedup();
(found, gather.translation.unwrap_or(Vector::ZERO))
}
fn reselect(&mut self, tree: &mut Tree, layout: Layout<'_>, renderer: &Renderer, shell: &mut Shell<'_, Message>) {
let state: &State = tree.state.downcast_ref();
let rect = band_rect(state.anchor, state.translation, state.cursor);
let (found, translation) = self.gather(tree, layout, renderer, rect);
let state: &mut State = tree.state.downcast_mut();
state.translation = translation;
if found != state.last {
state.last = found.clone();
if let Some(on_select) = &self.on_select {
let additive = state.modifiers.control() || state.modifiers.shift();
shell.publish(on_select(found, additive));
}
}
}
}
impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer> for Marquee<'_, Message, Theme, Renderer>
where
Renderer: renderer::Renderer,
Message: Clone,
{
fn tag(&self) -> tree::Tag {
tree::Tag::of::<State>()
}
fn state(&self) -> tree::State {
tree::State::new(State::default())
}
fn children(&self) -> Vec<Tree> {
vec![Tree::new(&self.content)]
}
fn diff(&self, tree: &mut Tree) {
tree.diff_children(std::slice::from_ref(&self.content));
}
fn size(&self) -> Size<Length> {
self.content.as_widget().size()
}
fn layout(&mut self, tree: &mut Tree, renderer: &Renderer, limits: &layout::Limits) -> layout::Node {
self.content.as_widget_mut().layout(&mut tree.children[0], renderer, limits)
}
fn operate(&mut self, tree: &mut Tree, layout: Layout<'_>, renderer: &Renderer, operation: &mut dyn Operation) {
self.content.as_widget_mut().operate(&mut tree.children[0], layout, renderer, operation);
}
fn update(
&mut self,
tree: &mut Tree,
event: &Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
viewport: &Rectangle,
) {
if let Event::Keyboard(keyboard::Event::ModifiersChanged(modifiers)) = event {
tree.state.downcast_mut::<State>().modifiers = *modifiers;
}
let active = tree.state.downcast_ref::<State>().active;
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
self.content
.as_widget_mut()
.update(&mut tree.children[0], event, layout, cursor, renderer, clipboard, shell, viewport);
if shell.is_event_captured() {
return;
}
let Some(at) = cursor.position_over(layout.bounds()) else { return };
let (_, translation) = self.gather(tree, layout, renderer, Rectangle::new(at, Size::ZERO));
let state: &mut State = tree.state.downcast_mut();
*state = State {
press: Some(at),
anchor: at + translation,
cursor: at,
translation,
modifiers: state.modifiers,
..State::default()
};
return;
}
Event::Mouse(mouse::Event::CursorMoved { position }) => {
let state: &mut State = tree.state.downcast_mut();
if let Some(press) = state.press {
state.cursor = *position;
if !state.active && press.distance(*position) >= THRESHOLD {
state.active = true;
if let Some(start) = &self.on_start {
shell.publish(start.clone());
}
}
if state.active {
self.reselect(tree, layout, renderer, shell);
shell.request_redraw();
shell.capture_event();
return;
}
}
}
Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => {
let state: &mut State = tree.state.downcast_mut();
let (pressed, was_active) = (state.press.take(), state.active);
state.active = false;
state.last.clear();
if was_active {
if let Some(end) = &self.on_end {
shell.publish(end.clone());
}
shell.request_redraw();
shell.capture_event();
return;
}
if pressed.is_some() {
if let Some(clear) = &self.on_clear {
shell.publish(clear.clone());
}
}
}
Event::Window(window::Event::RedrawRequested(_)) if active => {
let bounds = layout.bounds();
let y = tree.state.downcast_ref::<State>().cursor.y;
let step = edge_scroll(y, bounds.y, bounds.y + bounds.height);
if step != 0.0 {
if let Some(id) = self.scroll.clone() {
let mut scroll = operation::scrollable::scroll_by::<()>(id, AbsoluteOffset { x: 0.0, y: step });
self.content.as_widget_mut().operate(&mut tree.children[0], layout, renderer, &mut scroll);
self.reselect(tree, layout, renderer, shell);
}
shell.request_redraw();
}
}
_ => {}
}
self.content
.as_widget_mut()
.update(&mut tree.children[0], event, layout, cursor, renderer, clipboard, shell, viewport);
if active && matches!(event, Event::Mouse(mouse::Event::WheelScrolled { .. })) {
self.reselect(tree, layout, renderer, shell);
shell.request_redraw();
}
}
fn mouse_interaction(
&self,
tree: &Tree,
layout: Layout<'_>,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
if tree.state.downcast_ref::<State>().active {
return mouse::Interaction::Crosshair;
}
self.content
.as_widget()
.mouse_interaction(&tree.children[0], layout, cursor, viewport, renderer)
}
fn draw(
&self,
tree: &Tree,
renderer: &mut Renderer,
theme: &Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
self.content
.as_widget()
.draw(&tree.children[0], renderer, theme, style, layout, cursor, viewport);
let state: &State = tree.state.downcast_ref();
if !state.active {
return;
}
let Some(clip) = layout.bounds().intersection(viewport) else { return };
let Some(band) = band_rect(state.anchor, state.translation, state.cursor).intersection(&clip) else {
return;
};
let accent = crate::color::to_iced(crate::theme::active().accent);
renderer.with_layer(clip, |renderer| {
renderer.fill_quad(
renderer::Quad {
bounds: band,
border: Border { color: accent, width: 1.0, radius: 2.0.into() },
..renderer::Quad::default()
},
Color { a: 0.18, ..accent },
);
});
}
fn overlay<'b>(
&'b mut self,
tree: &'b mut Tree,
layout: Layout<'b>,
renderer: &Renderer,
viewport: &Rectangle,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
self.content
.as_widget_mut()
.overlay(&mut tree.children[0], layout, renderer, viewport, translation)
}
}
impl<'a, Message, Theme, Renderer> From<Marquee<'a, Message, Theme, Renderer>> for Element<'a, Message, Theme, Renderer>
where
Message: 'a + Clone,
Theme: 'a,
Renderer: 'a + renderer::Renderer,
{
fn from(marquee: Marquee<'a, Message, Theme, Renderer>) -> Self {
Element::new(marquee)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_band_spans_its_corners_whichever_way_it_was_drawn() {
let up_left = band_rect(Point::new(100.0, 100.0), Vector::ZERO, Point::new(40.0, 20.0));
assert_eq!(up_left, Rectangle { x: 40.0, y: 20.0, width: 60.0, height: 80.0 });
}
#[test]
fn the_anchor_moves_with_the_scrolled_content() {
let rect = band_rect(Point::new(10.0, 200.0), Vector::new(0.0, 50.0), Point::new(60.0, 300.0));
assert_eq!(rect.y, 150.0);
assert_eq!(rect.height, 150.0);
}
#[test]
fn the_listing_scrolls_only_near_an_edge_and_fastest_at_it() {
assert_eq!(edge_scroll(300.0, 0.0, 600.0), 0.0);
assert_eq!(edge_scroll(0.0, 0.0, 600.0), -SPEED);
assert_eq!(edge_scroll(-40.0, 0.0, 600.0), -SPEED, "past the edge is the fastest, not faster");
assert_eq!(edge_scroll(600.0, 0.0, 600.0), SPEED);
let partway = edge_scroll(600.0 - EDGE / 2.0, 0.0, 600.0);
assert!(partway > 0.0 && partway < SPEED);
}
#[test]
fn a_target_scrolled_out_of_sight_is_not_met() {
let a = Id::unique();
let b = Id::unique();
let targets = HashMap::from([(a.clone(), 0), (b.clone(), 1)]);
let scroll = Id::unique();
let mut gather = Gather::new(Rectangle::new(Point::new(0.0, 0.0), Size::new(100.0, 100.0)), &targets, Some(&scroll));
struct Inert;
impl operation::Scrollable for Inert {
fn snap_to(&mut self, _: operation::scrollable::RelativeOffset<Option<f32>>) {}
fn scroll_to(&mut self, _: AbsoluteOffset<Option<f32>>) {}
fn scroll_by(&mut self, _: AbsoluteOffset, _: Rectangle, _: Rectangle) {}
}
gather.scrollable(
Some(&scroll),
Rectangle::new(Point::ORIGIN, Size::new(100.0, 100.0)),
Rectangle::new(Point::ORIGIN, Size::new(100.0, 1000.0)),
Vector::new(0.0, 200.0),
&mut Inert,
);
gather.traverse(&mut |op| {
op.container(Some(&a), Rectangle::new(Point::new(0.0, 0.0), Size::new(100.0, 20.0)));
op.container(Some(&b), Rectangle::new(Point::new(0.0, 220.0), Size::new(100.0, 20.0)));
});
assert_eq!(gather.found, [1]);
assert_eq!(gather.translation, Some(Vector::new(0.0, 200.0)));
}
}