Skip to main content

hyprforge_ui/widgets/
anchor.rs

1//! Something drawn under a widget, at that widget's width, over whatever
2//! is below it — the shape of every "suggestions under a field" in the
3//! suite.
4//!
5//! Files' path bar was the first: its candidates hang from the path field. They cannot be a
6//! row in the window's column — that would push the listing down a line
7//! per keystroke — and they cannot be a layer of the window stacked at a
8//! computed offset either: the field's left edge depends on the widths of
9//! everything beside it on the bar, the view toggle's included, and iced
10//! gives a layout function no way to ask. Only the field's own layout
11//! knows where the field is, so the panel is placed from there, as an
12//! overlay — the same mechanism iced's own tooltip and pick list use, and
13//! one that draws above every layer of the window.
14
15use iced::advanced::layout;
16use iced::advanced::mouse;
17use iced::advanced::overlay;
18use iced::advanced::renderer;
19use iced::advanced::widget::{Operation, Tree};
20use iced::advanced::{Clipboard, Layout, Shell, Widget};
21use iced::{Element, Event, Length, Point, Rectangle, Size, Vector};
22
23/// `base`, with `below` hung from its bottom edge when there is one.
24pub struct Anchored<'a, Message, Theme = iced::Theme, Renderer = iced::Renderer> {
25    base: Element<'a, Message, Theme, Renderer>,
26    below: Option<Element<'a, Message, Theme, Renderer>>,
27    /// Space between the two, in logical pixels.
28    gap: f32,
29}
30
31pub fn anchored<'a, Message, Theme, Renderer>(
32    base: impl Into<Element<'a, Message, Theme, Renderer>>,
33    below: Option<Element<'a, Message, Theme, Renderer>>,
34    gap: f32,
35) -> Anchored<'a, Message, Theme, Renderer> {
36    Anchored { base: base.into(), below, gap }
37}
38
39impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer> for Anchored<'_, Message, Theme, Renderer>
40where
41    Renderer: renderer::Renderer,
42{
43    fn children(&self) -> Vec<Tree> {
44        std::iter::once(&self.base).chain(self.below.as_ref()).map(Tree::new).collect()
45    }
46
47    fn diff(&self, tree: &mut Tree) {
48        // One child or two: `diff_children` adds or drops the second as
49        // the panel comes and goes, and the field's own state — its
50        // focus and cursor — stays put in the first.
51        match &self.below {
52            Some(below) => tree.diff_children(&[&self.base, below]),
53            None => tree.diff_children(std::slice::from_ref(&self.base)),
54        }
55    }
56
57    fn size(&self) -> Size<Length> {
58        self.base.as_widget().size()
59    }
60
61    fn size_hint(&self) -> Size<Length> {
62        self.base.as_widget().size_hint()
63    }
64
65    fn layout(&mut self, tree: &mut Tree, renderer: &Renderer, limits: &layout::Limits) -> layout::Node {
66        self.base.as_widget_mut().layout(&mut tree.children[0], renderer, limits)
67    }
68
69    fn operate(&mut self, tree: &mut Tree, layout: Layout<'_>, renderer: &Renderer, operation: &mut dyn Operation) {
70        self.base.as_widget_mut().operate(&mut tree.children[0], layout, renderer, operation);
71    }
72
73    fn update(
74        &mut self,
75        tree: &mut Tree,
76        event: &Event,
77        layout: Layout<'_>,
78        cursor: mouse::Cursor,
79        renderer: &Renderer,
80        clipboard: &mut dyn Clipboard,
81        shell: &mut Shell<'_, Message>,
82        viewport: &Rectangle,
83    ) {
84        self.base.as_widget_mut().update(
85            &mut tree.children[0],
86            event,
87            layout,
88            cursor,
89            renderer,
90            clipboard,
91            shell,
92            viewport,
93        );
94    }
95
96    fn mouse_interaction(
97        &self,
98        tree: &Tree,
99        layout: Layout<'_>,
100        cursor: mouse::Cursor,
101        viewport: &Rectangle,
102        renderer: &Renderer,
103    ) -> mouse::Interaction {
104        self.base.as_widget().mouse_interaction(&tree.children[0], layout, cursor, viewport, renderer)
105    }
106
107    fn draw(
108        &self,
109        tree: &Tree,
110        renderer: &mut Renderer,
111        theme: &Theme,
112        style: &renderer::Style,
113        layout: Layout<'_>,
114        cursor: mouse::Cursor,
115        viewport: &Rectangle,
116    ) {
117        self.base.as_widget().draw(&tree.children[0], renderer, theme, style, layout, cursor, viewport);
118    }
119
120    fn overlay<'b>(
121        &'b mut self,
122        tree: &'b mut Tree,
123        layout: Layout<'b>,
124        renderer: &Renderer,
125        viewport: &Rectangle,
126        translation: Vector,
127    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
128        let mut children = tree.children.iter_mut();
129        let base_tree = children.next()?;
130        let own = self.base.as_widget_mut().overlay(base_tree, layout, renderer, viewport, translation);
131        let hung = match (self.below.as_mut(), children.next()) {
132            (Some(below), Some(below_tree)) => {
133                let bounds = layout.bounds();
134                Some(overlay::Element::new(Box::new(Hung {
135                    content: below,
136                    tree: below_tree,
137                    at: Point::new(bounds.x, bounds.y + bounds.height + self.gap) + translation,
138                    width: bounds.width,
139                })))
140            }
141            _ => None,
142        };
143        match (own, hung) {
144            (None, None) => None,
145            (Some(one), None) | (None, Some(one)) => Some(one),
146            (Some(own), Some(hung)) => Some(overlay::Group::with_children(vec![own, hung]).overlay()),
147        }
148    }
149}
150
151impl<'a, Message, Theme, Renderer> From<Anchored<'a, Message, Theme, Renderer>> for Element<'a, Message, Theme, Renderer>
152where
153    Message: 'a,
154    Theme: 'a,
155    Renderer: renderer::Renderer + 'a,
156{
157    fn from(anchored: Anchored<'a, Message, Theme, Renderer>) -> Self {
158        Element::new(anchored)
159    }
160}
161
162/// The overlay itself: `content`, laid out at `width` from `at`.
163struct Hung<'a, 'b, Message, Theme, Renderer> {
164    content: &'b mut Element<'a, Message, Theme, Renderer>,
165    tree: &'b mut Tree,
166    at: Point,
167    width: f32,
168}
169
170impl<Message, Theme, Renderer> overlay::Overlay<Message, Theme, Renderer> for Hung<'_, '_, Message, Theme, Renderer>
171where
172    Renderer: renderer::Renderer,
173{
174    fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
175        // Exactly the anchor's width, and no taller than what is left of
176        // the window below it — a long list is cut off by the window
177        // edge rather than drawn past it.
178        let room = (bounds.height - self.at.y).max(0.0);
179        let limits = layout::Limits::new(Size::new(self.width, 0.0), Size::new(self.width, room));
180        self.content
181            .as_widget_mut()
182            .layout(self.tree, renderer, &limits)
183            .move_to(self.at)
184    }
185
186    fn draw(
187        &self,
188        renderer: &mut Renderer,
189        theme: &Theme,
190        style: &renderer::Style,
191        layout: Layout<'_>,
192        cursor: mouse::Cursor,
193    ) {
194        let bounds = layout.bounds();
195        self.content.as_widget().draw(self.tree, renderer, theme, style, layout, cursor, &bounds);
196    }
197
198    fn operate(&mut self, layout: Layout<'_>, renderer: &Renderer, operation: &mut dyn Operation) {
199        self.content.as_widget_mut().operate(self.tree, layout, renderer, operation);
200    }
201
202    fn update(
203        &mut self,
204        event: &Event,
205        layout: Layout<'_>,
206        cursor: mouse::Cursor,
207        renderer: &Renderer,
208        clipboard: &mut dyn Clipboard,
209        shell: &mut Shell<'_, Message>,
210    ) {
211        let bounds = layout.bounds();
212        self.content
213            .as_widget_mut()
214            .update(self.tree, event, layout, cursor, renderer, clipboard, shell, &bounds);
215    }
216
217    fn mouse_interaction(&self, layout: Layout<'_>, cursor: mouse::Cursor, renderer: &Renderer) -> mouse::Interaction {
218        let bounds = layout.bounds();
219        self.content.as_widget().mouse_interaction(self.tree, layout, cursor, &bounds, renderer)
220    }
221}