1use 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
27pub const PIXELS_PER_STEP: f32 = 60.0;
29
30pub 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 pixels: f32,
49}
50
51pub 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 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}