use iced::advanced::layout;
use iced::advanced::mouse;
use iced::advanced::overlay;
use iced::advanced::renderer;
use iced::advanced::widget::{Operation, Tree};
use iced::advanced::{Clipboard, Layout, Shell, Widget};
use iced::{Element, Event, Length, Point, Rectangle, Size, Vector};
pub struct Anchored<'a, Message, Theme = iced::Theme, Renderer = iced::Renderer> {
base: Element<'a, Message, Theme, Renderer>,
below: Option<Element<'a, Message, Theme, Renderer>>,
gap: f32,
}
pub fn anchored<'a, Message, Theme, Renderer>(
base: impl Into<Element<'a, Message, Theme, Renderer>>,
below: Option<Element<'a, Message, Theme, Renderer>>,
gap: f32,
) -> Anchored<'a, Message, Theme, Renderer> {
Anchored { base: base.into(), below, gap }
}
impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer> for Anchored<'_, Message, Theme, Renderer>
where
Renderer: renderer::Renderer,
{
fn children(&self) -> Vec<Tree> {
std::iter::once(&self.base).chain(self.below.as_ref()).map(Tree::new).collect()
}
fn diff(&self, tree: &mut Tree) {
match &self.below {
Some(below) => tree.diff_children(&[&self.base, below]),
None => tree.diff_children(std::slice::from_ref(&self.base)),
}
}
fn size(&self) -> Size<Length> {
self.base.as_widget().size()
}
fn size_hint(&self) -> Size<Length> {
self.base.as_widget().size_hint()
}
fn layout(&mut self, tree: &mut Tree, renderer: &Renderer, limits: &layout::Limits) -> layout::Node {
self.base.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.base.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,
) {
self.base.as_widget_mut().update(
&mut tree.children[0],
event,
layout,
cursor,
renderer,
clipboard,
shell,
viewport,
);
}
fn mouse_interaction(
&self,
tree: &Tree,
layout: Layout<'_>,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
self.base.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.base.as_widget().draw(&tree.children[0], renderer, theme, style, layout, cursor, viewport);
}
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>> {
let mut children = tree.children.iter_mut();
let base_tree = children.next()?;
let own = self.base.as_widget_mut().overlay(base_tree, layout, renderer, viewport, translation);
let hung = match (self.below.as_mut(), children.next()) {
(Some(below), Some(below_tree)) => {
let bounds = layout.bounds();
Some(overlay::Element::new(Box::new(Hung {
content: below,
tree: below_tree,
at: Point::new(bounds.x, bounds.y + bounds.height + self.gap) + translation,
width: bounds.width,
})))
}
_ => None,
};
match (own, hung) {
(None, None) => None,
(Some(one), None) | (None, Some(one)) => Some(one),
(Some(own), Some(hung)) => Some(overlay::Group::with_children(vec![own, hung]).overlay()),
}
}
}
impl<'a, Message, Theme, Renderer> From<Anchored<'a, Message, Theme, Renderer>> for Element<'a, Message, Theme, Renderer>
where
Message: 'a,
Theme: 'a,
Renderer: renderer::Renderer + 'a,
{
fn from(anchored: Anchored<'a, Message, Theme, Renderer>) -> Self {
Element::new(anchored)
}
}
struct Hung<'a, 'b, Message, Theme, Renderer> {
content: &'b mut Element<'a, Message, Theme, Renderer>,
tree: &'b mut Tree,
at: Point,
width: f32,
}
impl<Message, Theme, Renderer> overlay::Overlay<Message, Theme, Renderer> for Hung<'_, '_, Message, Theme, Renderer>
where
Renderer: renderer::Renderer,
{
fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
let room = (bounds.height - self.at.y).max(0.0);
let limits = layout::Limits::new(Size::new(self.width, 0.0), Size::new(self.width, room));
self.content
.as_widget_mut()
.layout(self.tree, renderer, &limits)
.move_to(self.at)
}
fn draw(
&self,
renderer: &mut Renderer,
theme: &Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor: mouse::Cursor,
) {
let bounds = layout.bounds();
self.content.as_widget().draw(self.tree, renderer, theme, style, layout, cursor, &bounds);
}
fn operate(&mut self, layout: Layout<'_>, renderer: &Renderer, operation: &mut dyn Operation) {
self.content.as_widget_mut().operate(self.tree, layout, renderer, operation);
}
fn update(
&mut self,
event: &Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) {
let bounds = layout.bounds();
self.content
.as_widget_mut()
.update(self.tree, event, layout, cursor, renderer, clipboard, shell, &bounds);
}
fn mouse_interaction(&self, layout: Layout<'_>, cursor: mouse::Cursor, renderer: &Renderer) -> mouse::Interaction {
let bounds = layout.bounds();
self.content.as_widget().mouse_interaction(self.tree, layout, cursor, &bounds, renderer)
}
}