Add operation to menu and partial overlay support

src/widgets/menu/menu_bar.rs

@@ -9,7 +9,7 @@ use iced::{
     advanced::{
         layout::{Limits, Node},
         mouse, overlay, renderer,
-        widget::{tree, Tree},
+        widget::{tree, Operation, Tree},
         Clipboard, Layout, Shell, Widget,
     },
     alignment, event, Element, Event, Length, Padding, Rectangle, Size,
@@ -258,6 +258,24 @@ where
         .merge(status)
     }
 
+    fn operate(
+        &self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn Operation<()>,
+    ) {
+        operation.container(None, layout.bounds(), &mut |operation| {
+            self.roots
+                .iter() // [Item...]
+                .zip(tree.children.iter_mut()) // [item_tree...]
+                .zip(layout.children()) // [widget_node...]
+                .for_each(|((child, state), layout)| {
+                    child.operate(state, layout, renderer, operation);
+                });
+        });
+    }
+
     fn mouse_interaction(
         &self,
         tree: &Tree,

src/widgets/menu/menu_bar_overlay.rs

@@ -10,7 +10,7 @@ use iced::{
     advanced::{
         layout::{Limits, Node},
         mouse, overlay, renderer,
-        widget::Tree,
+        widget::{Operation, Tree},
         Clipboard, Layout, Shell,
     },
     event, Event, Point, Rectangle, Size, Vector,
@@ -404,6 +404,64 @@ where
         )
     }
 
+    fn operate(
+        &mut self,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn Operation<()>,
+    ) {
+        let bar = self.tree.state.downcast_ref::<MenuBarState>();
+        let Some(active) = bar.active_root else {
+            return;
+        };
+
+        // let viewport = layout.bounds();
+        let mut lc = layout.children();
+        let _bar_bounds = lc.next().unwrap().bounds();
+        let _roots_layout = lc.next().unwrap();
+
+        // let parent_bounds = roots_layout.children().nth(active).unwrap().bounds();
+        let menu_layouts_layout = lc.next().unwrap(); // Node{0, [menu_node...]}
+        let mut menu_layouts = menu_layouts_layout.children(); // [menu_node...]
+
+        let active_root = &self.roots[active];
+        let active_tree = &mut self.tree.children[active];
+
+        fn rec<'a, 'b, Message, Theme: Catalog, Renderer: renderer::Renderer>(
+            tree: &mut Tree,
+            item: &Item<'a, Message, Theme, Renderer>,
+            layout_iter: &mut impl Iterator<Item = Layout<'b>>,
+            renderer: &Renderer,
+            operation: &mut dyn Operation<()>,
+        ) {
+            let menu = item.menu.as_ref().expect("No menu defined in this item");
+            let menu_tree = &mut tree.children[1];
+
+            let Some(menu_layout) = layout_iter.next() else {
+                return;
+            };
+
+            menu.operate(menu_tree, menu_layout, renderer, operation);
+
+            operation.container(None, menu_layout.bounds(), &mut |operation| {
+                menu.items
+                    .iter() // [Item...]
+                    .zip(menu_tree.children.iter_mut()) // [item_tree...] // [widget_node...]
+                    .for_each(|(child, state)| {
+                        rec(state, child, layout_iter, renderer, operation);
+                    });
+            });
+        }
+
+        rec(
+            active_tree,
+            active_root,
+            &mut menu_layouts,
+            renderer,
+            operation,
+        );
+    }
+
     fn draw(
         &self,
         renderer: &mut Renderer,

src/widgets/menu/menu_tree.rs

@@ -12,10 +12,12 @@
 
 use super::common::*;
 use super::flex;
+use iced::advanced::overlay::Group;
+use iced::advanced::widget::Operation;
 use iced::{
     advanced::{
         layout::{Layout, Limits, Node},
-        mouse, renderer,
+        mouse, overlay, renderer,
         widget::tree::{self, Tree},
         Clipboard, Shell,
     },
@@ -374,6 +376,62 @@ where
         .merge(status)
     }
 
+    pub(super) fn operate(
+        &self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn Operation<()>,
+    ) {
+        let mut lc = layout.children();
+        let slice_layout = lc.next().unwrap();
+        let _prescroll = lc.next().unwrap().bounds();
+        let _offset_bounds = lc.next().unwrap().bounds();
+        let _check_bounds = lc.next().unwrap().bounds();
+
+        let menu_state = tree.state.downcast_mut::<MenuState>();
+        let slice = &menu_state.slice;
+
+        operation.container(None, layout.bounds(), &mut |operation| {
+            self.items[slice.start_index..=slice.end_index] // [item...]
+                .iter()
+                .zip(tree.children[slice.start_index..=slice.end_index].iter_mut()) // [item_tree...]
+                .zip(slice_layout.children())
+                .for_each(|((child, state), layout)| {
+                    child.operate(state, layout, renderer, operation);
+                });
+        });
+    }
+
+    #[allow(dead_code)]
+    pub(super) fn overlay<'b>(
+        &'b mut self,
+        tree: &'b mut Tree,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        translation: Vector,
+    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
+        let mut lc = layout.children();
+        let slice_layout = lc.next()?;
+        let _prescroll = lc.next()?.bounds();
+        let _offset_bounds = lc.next()?.bounds();
+        let _check_bounds = lc.next()?.bounds();
+
+        let menu_state = tree.state.downcast_mut::<MenuState>();
+        let slice = &menu_state.slice;
+
+        let children = self.items[slice.start_index..=slice.end_index] // [item...]
+            .iter_mut()
+            .zip(tree.children[slice.start_index..=slice.end_index].iter_mut()) // [item_tree...]
+            .zip(slice_layout.children())
+            .filter_map(|((child, state), layout)| {
+                child.overlay(state, layout, renderer, translation)
+            })
+            .collect::<Vec<_>>();
+
+        (!children.is_empty()).then(|| Group::with_children(children).overlay())
+    }
+
     /// tree: Tree{ menu_state, \[item_tree...] }
     ///
     /// layout: Node{inf, \[ slice_node, prescroll, offset_bounds, check_bounds ]}
@@ -774,6 +832,31 @@ where
             viewport,
         );
     }
+
+    pub(super) fn operate(
+        &self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn Operation<()>,
+    ) {
+        self.item
+            .as_widget()
+            .operate(&mut tree.children[0], layout, renderer, operation);
+    }
+
+    #[allow(dead_code)]
+    pub(super) fn overlay<'b>(
+        &'b mut self,
+        tree: &'b mut Tree,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        translation: Vector,
+    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
+        self.item
+            .as_widget_mut()
+            .overlay(&mut tree.children[0], layout, renderer, translation)
+    }
 }
 
 /// Adaptive open direction