me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Use layout with children for nesting

Browse source
This commit is contained in:
Cory Forsstrom 2023-02-18 16:08:05 -08:00 • committed by Héctor Ramón Jiménez
parent 12c623f35b
commit 3e6f6eedcb
No known key found for this signature in database
GPG key ID: 140CC052C94F138E
1 changed files with 71 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

130
runtime/src/user_interface/overlay.rs
View file

@ -9,7 +9,6 @@ use crate::core::{
};
use std::cell::RefCell;
use std::iter::Peekable;
/// An [`Overlay`] container that displays nested overlays
#[allow(missing_debug_implementations)]
@ -55,7 +54,7 @@ where
renderer: &Renderer,
bounds: Size,
position: Point,
) -> Vec<layout::Node>
) -> layout::Node
where
Renderer: renderer::Renderer,
{
@ -63,23 +62,23 @@ where
let node = element.layout(renderer, bounds, translation);
if let Some(mut overlay) =
if let Some(mut nested) =
element.overlay(Layout::new(&node), renderer)
{
vec![node]
.into_iter()
.chain(recurse(&mut overlay, renderer, bounds, position))
.collect()
layout::Node::with_children(
node.size(),
vec![
node,
recurse(&mut nested, renderer, bounds, position),
],
)
} else {
vec![node]
layout::Node::with_children(node.size(), vec![node])
}
}
self.overlay.with_element_mut(|element| {
layout::Node::with_children(
bounds,
recurse(element, renderer, bounds, position),
)
recurse(element, renderer, bounds, position)
})
}
@ -91,9 +90,9 @@ where
layout: Layout<'_>,
cursor: mouse::Cursor,
) {
fn recurse<'a, Message, Renderer>(
fn recurse<Message, Renderer>(
element: &mut overlay::Element<'_, Message, Renderer>,
mut layouts: Peekable<impl Iterator<Item = Layout<'a>>>,
layout: Layout<'_>,
renderer: &mut Renderer,
theme: &<Renderer as renderer::Renderer>::Theme,
style: &renderer::Style,
@ -101,18 +100,21 @@ where
) where
Renderer: renderer::Renderer,
{
let mut layouts = layout.children();
if let Some(layout) = layouts.next() {
let nested_layout = layouts.next();
let is_over = cursor
.position()
.and_then(|cursor_position| {
layouts.peek().and_then(|nested_layout| {
element.overlay(layout, renderer).map(|overlay| {
overlay.is_over(
*nested_layout,
renderer,
cursor_position,
)
})
.zip(nested_layout)
.and_then(|(cursor_position, nested_layout)| {
element.overlay(layout, renderer).map(|nested| {
nested.is_over(
nested_layout,
renderer,
cursor_position,
)
})
})
.unwrap_or_default();
@ -131,10 +133,12 @@ where
);
});
if let Some(mut overlay) = element.overlay(layout, renderer) {
if let Some((mut nested, nested_layout)) =
element.overlay(layout, renderer).zip(nested_layout)
{
recurse(
&mut overlay,
layouts,
&mut nested,
nested_layout,
renderer,
theme,
style,
@ -145,9 +149,7 @@ where
}
self.overlay.with_element_mut(|element| {
let layouts = layout.children().peekable();
recurse(element, layouts, renderer, theme, style, cursor);
recurse(element, layout, renderer, theme, style, cursor);
})
}
@ -157,26 +159,28 @@ where
renderer: &Renderer,
operation: &mut dyn widget::Operation<Message>,
) {
fn recurse<'a, Message, Renderer>(
fn recurse<Message, Renderer>(
element: &mut overlay::Element<'_, Message, Renderer>,
mut layouts: impl Iterator<Item = Layout<'a>>,
layout: Layout<'_>,
renderer: &Renderer,
operation: &mut dyn widget::Operation<Message>,
) where
Renderer: renderer::Renderer,
{
let mut layouts = layout.children();
if let Some(layout) = layouts.next() {
element.operate(layout, renderer, operation);
if let Some(mut overlay) = element.overlay(layout, renderer) {
recurse(&mut overlay, layouts, renderer, operation);
if let Some((mut nested, nested_layout)) =
element.overlay(layout, renderer).zip(layouts.next())
{
recurse(&mut nested, nested_layout, renderer, operation);
}
}
}
let layouts = layout.children();
recurse(self.overlay.0.get_mut(), layouts, renderer, operation)
recurse(self.overlay.0.get_mut(), layout, renderer, operation)
}
fn on_event(
@ -188,9 +192,9 @@ where
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) -> event::Status {
fn recurse<'a, Message, Renderer>(
fn recurse<Message, Renderer>(
element: &mut overlay::Element<'_, Message, Renderer>,
mut layouts: impl Iterator<Item = Layout<'a>>,
layout: Layout<'_>,
event: Event,
cursor: mouse::Cursor,
renderer: &Renderer,
@ -200,13 +204,15 @@ where
where
Renderer: renderer::Renderer,
{
let mut layouts = layout.children();
if let Some(layout) = layouts.next() {
let status = if let Some(mut overlay) =
element.overlay(layout, renderer)
let status = if let Some((mut nested, nested_layout)) =
element.overlay(layout, renderer).zip(layouts.next())
{
recurse(
&mut overlay,
layouts,
&mut nested,
nested_layout,
event.clone(),
cursor,
renderer,
@ -229,11 +235,9 @@ where
}
}
let layouts = layout.children();
recurse(
self.overlay.0.get_mut(),
layouts,
layout,
event,
cursor,
renderer,
@ -249,9 +253,9 @@ where
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
fn recurse<'a, Message, Renderer>(
fn recurse<Message, Renderer>(
element: &mut overlay::Element<'_, Message, Renderer>,
mut layouts: impl Iterator<Item = Layout<'a>>,
layout: Layout<'_>,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
@ -259,6 +263,8 @@ where
where
Renderer: renderer::Renderer,
{
let mut layouts = layout.children();
let layout = layouts.next()?;
let cursor_position = cursor.position()?;
@ -269,10 +275,11 @@ where
Some(
element
.overlay(layout, renderer)
.and_then(|mut overlay| {
.zip(layouts.next())
.and_then(|(mut overlay, layout)| {
recurse(
&mut overlay,
layouts,
layout,
cursor,
viewport,
renderer,
@ -288,9 +295,7 @@ where
self.overlay
.with_element_mut(|element| {
let layouts = layout.children();
recurse(element, layouts, cursor, viewport, renderer)
recurse(element, layout, cursor, viewport, renderer)
})
.unwrap_or_default()
}
@ -301,22 +306,31 @@ where
renderer: &Renderer,
cursor_position: Point,
) -> bool {
fn recurse<'a, Message, Renderer>(
fn recurse<Message, Renderer>(
element: &mut overlay::Element<'_, Message, Renderer>,
mut layouts: impl Iterator<Item = Layout<'a>>,
layout: Layout<'_>,
renderer: &Renderer,
cursor_position: Point,
) -> bool
where
Renderer: renderer::Renderer,
{
let mut layouts = layout.children();
if let Some(layout) = layouts.next() {
if element.is_over(layout, renderer, cursor_position) {
return true;
}
if let Some(mut overlay) = element.overlay(layout, renderer) {
recurse(&mut overlay, layouts, renderer, cursor_position)
if let Some((mut nested, nested_layout)) =
element.overlay(layout, renderer).zip(layouts.next())
{
recurse(
&mut nested,
nested_layout,
renderer,
cursor_position,
)
} else {
false
}
@ -326,9 +340,7 @@ where
}
self.overlay.with_element_mut(|element| {
let layouts = layout.children();
recurse(element, layouts, renderer, cursor_position)
recurse(element, layout, renderer, cursor_position)
})
}