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