Skip to main content

hyprforge_ui/widgets/
wheel_zoom.rs

1//! Ctrl+wheel over something to zoom it, the way every file manager and
2//! browser does — without stealing the plain wheel from what is inside.
3//!
4//! It has to be a widget of its own, around the thing being zoomed. A
5//! `mouse_area` with `on_scroll` hears the wheel only *after* its child
6//! has had it, and the child here is a `scrollable`, which takes every
7//! wheel event for scrolling and captures it — so Ctrl+wheel would scroll
8//! the listing and never zoom it. This looks at the event first: with
9//! Ctrl held and the pointer over it, the wheel is a zoom and the child
10//! never sees it; otherwise everything goes to the child untouched.
11//!
12//! It keeps track of Ctrl itself from the window's `ModifiersChanged`,
13//! because a wheel event carries no modifiers.
14//!
15//! A mouse wheel moves in lines, one per notch, and each notch is one
16//! step. A touchpad scrolls in pixels, dozens of small events per swipe;
17//! those are added up and a step is made per [`PIXELS_PER_STEP`], so a
18//! two-finger swipe zooms a few levels rather than all of them.
19
20use iced::advanced::layout;
21use iced::advanced::mouse;
22use iced::advanced::renderer;
23use iced::advanced::widget::{tree, Operation, Tree};
24use iced::advanced::{Clipboard, Layout, Shell, Widget};
25use iced::{keyboard, Element, Event, Length, Rectangle, Size};
26
27/// How far a touchpad has to scroll, in logical pixels, to make one step.
28pub const PIXELS_PER_STEP: f32 = 60.0;
29
30/// `content`, zoomed by Ctrl+wheel: `on_zoom(1)` for each step in (away
31/// from you, the way a page zooms in), `on_zoom(-1)` for each step out.
32pub struct WheelZoom<'a, Message, Theme = iced::Theme, Renderer = iced::Renderer> {
33    content: Element<'a, Message, Theme, Renderer>,
34    on_zoom: Box<dyn Fn(i32) -> Message + 'a>,
35}
36
37pub fn wheel_zoom<'a, Message, Theme, Renderer>(
38    content: impl Into<Element<'a, Message, Theme, Renderer>>,
39    on_zoom: impl Fn(i32) -> Message + 'a,
40) -> WheelZoom<'a, Message, Theme, Renderer> {
41    WheelZoom { content: content.into(), on_zoom: Box::new(on_zoom) }
42}
43
44#[derive(Debug, Default)]
45struct State {
46    modifiers: keyboard::Modifiers,
47    /// Touchpad scrolling not yet turned into a step.
48    pixels: f32,
49}
50
51/// Whole steps in `pixels`, and what is left over. Pure, so the
52/// touchpad arithmetic is tested without a window.
53pub fn steps_from_pixels(pixels: f32) -> (i32, f32) {
54    let steps = (pixels / PIXELS_PER_STEP).trunc();
55    (steps as i32, pixels - steps * PIXELS_PER_STEP)
56}
57
58impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer> for WheelZoom<'_, Message, Theme, Renderer>
59where
60    Renderer: renderer::Renderer,
61{
62    fn tag(&self) -> tree::Tag {
63        tree::Tag::of::<State>()
64    }
65
66    fn state(&self) -> tree::State {
67        tree::State::new(State::default())
68    }
69
70    fn children(&self) -> Vec<Tree> {
71        vec![Tree::new(&self.content)]
72    }
73
74    fn diff(&self, tree: &mut Tree) {
75        tree.diff_children(std::slice::from_ref(&self.content));
76    }
77
78    fn size(&self) -> Size<Length> {
79        self.content.as_widget().size()
80    }
81
82    fn size_hint(&self) -> Size<Length> {
83        self.content.as_widget().size_hint()
84    }
85
86    fn layout(&mut self, tree: &mut Tree, renderer: &Renderer, limits: &layout::Limits) -> layout::Node {
87        self.content.as_widget_mut().layout(&mut tree.children[0], renderer, limits)
88    }
89
90    fn operate(&mut self, tree: &mut Tree, layout: Layout<'_>, renderer: &Renderer, operation: &mut dyn Operation) {
91        self.content.as_widget_mut().operate(&mut tree.children[0], layout, renderer, operation);
92    }
93
94    fn update(
95        &mut self,
96        tree: &mut Tree,
97        event: &Event,
98        layout: Layout<'_>,
99        cursor: mouse::Cursor,
100        renderer: &Renderer,
101        clipboard: &mut dyn Clipboard,
102        shell: &mut Shell<'_, Message>,
103        viewport: &Rectangle,
104    ) {
105        let state = tree.state.downcast_mut::<State>();
106        match event {
107            Event::Keyboard(keyboard::Event::ModifiersChanged(modifiers)) => {
108                state.modifiers = *modifiers;
109                if !modifiers.control() {
110                    state.pixels = 0.0;
111                }
112            }
113            Event::Mouse(mouse::Event::WheelScrolled { delta })
114                if state.modifiers.control() && cursor.is_over(layout.bounds()) =>
115            {
116                let steps = match delta {
117                    mouse::ScrollDelta::Lines { y, .. } => y.signum() as i32 * (y.abs().round().max(1.0) as i32),
118                    mouse::ScrollDelta::Pixels { y, .. } => {
119                        let (steps, rest) = steps_from_pixels(state.pixels + y);
120                        state.pixels = rest;
121                        steps
122                    }
123                };
124                if steps != 0 {
125                    shell.publish((self.on_zoom)(steps));
126                }
127                // Taken either way: a Ctrl+wheel that did not make a whole
128                // step yet is still a zoom in progress, not a scroll.
129                shell.capture_event();
130                return;
131            }
132            _ => {}
133        }
134        self.content.as_widget_mut().update(
135            &mut tree.children[0],
136            event,
137            layout,
138            cursor,
139            renderer,
140            clipboard,
141            shell,
142            viewport,
143        );
144    }
145
146    fn mouse_interaction(
147        &self,
148        tree: &Tree,
149        layout: Layout<'_>,
150        cursor: mouse::Cursor,
151        viewport: &Rectangle,
152        renderer: &Renderer,
153    ) -> mouse::Interaction {
154        self.content.as_widget().mouse_interaction(&tree.children[0], layout, cursor, viewport, renderer)
155    }
156
157    fn draw(
158        &self,
159        tree: &Tree,
160        renderer: &mut Renderer,
161        theme: &Theme,
162        style: &renderer::Style,
163        layout: Layout<'_>,
164        cursor: mouse::Cursor,
165        viewport: &Rectangle,
166    ) {
167        self.content.as_widget().draw(&tree.children[0], renderer, theme, style, layout, cursor, viewport);
168    }
169
170    fn overlay<'b>(
171        &'b mut self,
172        tree: &'b mut Tree,
173        layout: Layout<'b>,
174        renderer: &Renderer,
175        viewport: &Rectangle,
176        translation: iced::Vector,
177    ) -> Option<iced::advanced::overlay::Element<'b, Message, Theme, Renderer>> {
178        self.content.as_widget_mut().overlay(&mut tree.children[0], layout, renderer, viewport, translation)
179    }
180}
181
182impl<'a, Message, Theme, Renderer> From<WheelZoom<'a, Message, Theme, Renderer>> for Element<'a, Message, Theme, Renderer>
183where
184    Message: 'a,
185    Theme: 'a,
186    Renderer: renderer::Renderer + 'a,
187{
188    fn from(zoom: WheelZoom<'a, Message, Theme, Renderer>) -> Self {
189        Element::new(zoom)
190    }
191}
192
193#[cfg(test)]
194mod tests {
195    use super::*;
196
197    #[test]
198    fn a_short_touchpad_scroll_makes_no_step_and_keeps_what_it_scrolled() {
199        assert_eq!(steps_from_pixels(25.0), (0, 25.0));
200    }
201
202    #[test]
203    fn a_long_touchpad_scroll_makes_whole_steps_and_keeps_the_rest() {
204        let (steps, rest) = steps_from_pixels(2.5 * PIXELS_PER_STEP);
205        assert_eq!(steps, 2);
206        assert!((rest - 0.5 * PIXELS_PER_STEP).abs() < 0.001);
207    }
208
209    #[test]
210    fn scrolling_back_steps_the_other_way() {
211        assert_eq!(steps_from_pixels(-PIXELS_PER_STEP).0, -1);
212    }
213}