Separators in menus

examples/menu.rs

@@ -44,5 +44,6 @@ fn menu(top: bool) -> Menu<MenuOptions> {
         })
         .with(MenuItem::new(MenuOptions::First, "First"))
         .with(MenuItem::new(MenuOptions::Second, "Second"))
+        .with_separator()
         .with(third)
 }

src/widgets/menu.rs

@@ -7,7 +7,7 @@ use std::time::Duration;
 use alot::LotId;
 use figures::units::{Px, UPx};
 use figures::{Angle, IntoSigned, Point, Rect, Round, ScreenScale, Size, Zero};
-use kludgine::shapes::{PathBuilder, Shape};
+use kludgine::shapes::{PathBuilder, Shape, StrokeOptions};
 use kludgine::DrawableExt;
 use parking_lot::Mutex;
 
@@ -30,6 +30,12 @@ use crate::widget::{
 };
 use crate::ConstraintLimit;
 
+#[derive(Debug, Clone)]
+enum ItemKind<T> {
+    Item(T),
+    Separator,
+}
+
 /// An overlayable menu of selectable items.
 ///
 /// This widget is designed to implement Cushy's contextual menu system. When
@@ -37,7 +43,7 @@ use crate::ConstraintLimit;
 /// or at a specific location.
 #[derive(Debug, Clone)]
 pub struct Menu<T, Handler = MenuHandler<T>> {
-    items: Vec<MenuItem<T>>,
+    items: Vec<ItemKind<MenuItem<T>>>,
     on_click: Handler,
 }
 
@@ -84,7 +90,14 @@ where
     /// Adds another menu `item` that is displayed using `widget`.
     #[must_use]
     pub fn with(mut self, item: impl Into<MenuItem<T>>) -> Self {
-        self.items.push(item.into());
+        self.items.push(ItemKind::Item(item.into()));
+        self
+    }
+
+    /// Adds a separator after the last item and returns self.
+    #[must_use]
+    pub fn with_separator(mut self) -> Self {
+        self.items.push(ItemKind::Separator);
         self
     }
 }
@@ -109,22 +122,24 @@ where
         let handle = OpenMenuHandle(Dynamic::new(None));
         let items = items
             .iter()
-            .map(|item| {
+            .map(|item| RenderedItem {
-                let MenuItem {
+                y: UPx::ZERO,
+                height: UPx::ZERO,
+                item: match item {
+                    ItemKind::Item(MenuItem {
                         value,
                         widget,
                         submenu,
-                } = item;
+                    }) => ItemKind::Item(OpenItem {
-                OpenItem {
                         value: value.clone(),
                         contents: WidgetRef::new(widget.clone().align_left()),
-                    y: UPx::ZERO,
-                    height: UPx::ZERO,
                         submenu: submenu.clone(),
                         colors: None,
                         color_animation: AnimationHandle::default(),
                         state: VisualState::Normal,
-                }
+                    }),
+                    ItemKind::Separator => ItemKind::Separator,
+                },
             })
             .collect();
 
@@ -408,7 +423,7 @@ pub struct MenuHandler<T>(Arc<Mutex<Callback<ChosenMenuItem<T>>>>);
 
 #[derive(Debug)]
 struct OpenMenu<T> {
-    items: Vec<OpenItem<T>>,
+    items: Vec<RenderedItem<T>>,
     on_click: MenuHandler<T>,
     open_id: LotId,
     padding: UPx,
@@ -423,9 +438,10 @@ struct OpenMenu<T> {
 impl<T> OpenMenu<T> {
     fn handle_mouse_movement(&mut self, location: Point<Px>, context: &mut EventContext<'_>) {
         self.selecting = None;
-        for (index, item) in self.items.iter_mut().enumerate() {
+        for (index, rendered) in self.items.iter_mut().enumerate() {
-            let hovered = location.y >= item.y - self.padding
+            let hovered = location.y >= rendered.y - self.padding
-                && location.y < item.y + item.height + self.padding;
+                && location.y < rendered.y + rendered.height + self.padding;
+            if let ItemKind::Item(item) = &mut rendered.item {
                 let new_state = if hovered {
                     self.selecting = Some(index);
                     if let Some((submenu_index, handle)) = &self.open_submenu {
@@ -439,7 +455,7 @@ impl<T> OpenMenu<T> {
                         let menu_location = Point::new(
                             last_layout.origin.x + last_layout.size.width
                                 - self.padding.into_signed() * 2,
-                        last_layout.origin.y + (item.y - self.padding).into_signed(),
+                            last_layout.origin.y + (rendered.y - self.padding).into_signed(),
                         );
                         self.open_submenu = Some((
                             index,
@@ -478,6 +494,7 @@ impl<T> OpenMenu<T> {
                 }
             }
         }
+    }
 }
 
 impl<T> Widget for OpenMenu<T>
@@ -518,16 +535,27 @@ where
         let pt3 = Point::new(disclosure_size, Px::ZERO).rotate_by(Angle::degrees(240));
 
         let submenu = PathBuilder::new(pt1).line_to(pt2).line_to(pt3).close();
-        for item in &mut self.items {
+
+        let separator = PathBuilder::new(Point::new(self.padding * 2, UPx::ZERO))
+            .line_to(Point::new(full_size.width - self.padding * 2, UPx::ZERO))
+            .close()
+            .stroke(
+                StrokeOptions::mm_wide(1)
+                    .into_upx(context.gfx.scale())
+                    .colored(context.theme().surface.color),
+            );
+        for rendered in &mut self.items {
+            match &mut rendered.item {
+                ItemKind::Item(item) => {
                     let mounted = item.contents.mounted(context);
 
                     if let Some(colors) = &item.colors {
                         let colors = colors.get_tracking_redraw(context);
                         let child_rect = Rect::new(
-                    Point::new(self.padding, item.y - self.padding),
+                            Point::new(self.padding, rendered.y - self.padding),
                             Size::new(
                                 full_size.width - self.padding * 2,
-                        item.height + self.padding * 2,
+                                rendered.height + self.padding * 2,
                             ),
                         )
                         .into_signed();
@@ -542,7 +570,7 @@ where
                         if item.submenu.is_some() {
                             let disclosure_offset = Point::new(
                                 full_size.width - self.disclosure_size / 2 - self.padding * 2,
-                        item.y + item.height / 2,
+                                rendered.y + rendered.height / 2,
                             )
                             .into_signed();
                             context.gfx.draw_shape(
@@ -557,6 +585,14 @@ where
                         context.redraw();
                     }
                 }
+                ItemKind::Separator => {
+                    context.gfx.draw_shape(
+                        separator
+                            .translate_by(Point::new(UPx::ZERO, rendered.y - self.padding / 2)),
+                    );
+                }
+            }
+        }
     }
 
     fn layout(
@@ -570,7 +606,7 @@ where
         self.disclosure_size =
             (context.get(&IndicatorSize).into_upx(context.gfx.scale()) / 2).round();
         let double_padding = self.padding * 2;
-        let submenu_space = if self.items.iter().any(|i| i.submenu.is_some()) {
+        let submenu_space = if self.items.iter().any(|i| i.submenu().is_some()) {
             self.padding + self.disclosure_size
         } else {
             UPx::ZERO
@@ -578,29 +614,38 @@ where
         let available_width = available_space.width.max() - double_padding;
 
         let mut y = self.padding;
-        for item in &mut self.items {
+        for rendered in &mut self.items {
+            let (height, full_height) = match &mut rendered.item {
+                ItemKind::Item(item) => {
                     let mounted = item.contents.mounted(context);
                     let available_width = available_width - submenu_space;
                     let size = context.for_other(&mounted).layout(Size::new(
                         ConstraintLimit::SizeToFit(available_width),
                         ConstraintLimit::SizeToFit(remaining_height),
                     ));
-            item.y = y;
+                    maximum_item_width = maximum_item_width.max(size.width);
-            item.height = size.height;
+                    (size.height, size.height + double_padding)
-            let full_height = size.height + double_padding;
+                }
+                ItemKind::Separator => (UPx::ZERO, self.padding),
+            };
+
+            rendered.y = y;
+            rendered.height = height;
             y += full_height;
 
             remaining_height = remaining_height.saturating_sub(full_height);
-            maximum_item_width = maximum_item_width.max(size.width);
         }
 
-        for item in &mut self.items {
+        for rendered in &mut self.items {
+            let ItemKind::Item(item) = &mut rendered.item else {
+                continue;
+            };
             let mounted = item.contents.mounted(context);
             context.set_child_layout(
                 &mounted,
                 Rect::new(
-                    Point::new(double_padding, item.y),
+                    Point::new(double_padding, rendered.y),
-                    Size::new(maximum_item_width, item.height),
+                    Size::new(maximum_item_width, rendered.height),
                 )
                 .into_signed(),
             );
@@ -667,8 +712,11 @@ where
         _context: &mut crate::context::EventContext<'_>,
     ) {
         if let Some(index) = self.selecting {
+            let ItemKind::Item(item) = &self.items[index].item else {
+                return;
+            };
             self.on_click.0.lock().invoke(ChosenMenuItem {
-                item: self.items[index].value.clone(),
+                item: item.value.clone(),
                 click: None,
             });
             let mut shared = self.shared.lock();
@@ -688,6 +736,9 @@ where
 
         let colors = Button::colors_for_transparent(VisualState::Normal, context);
         for item in &mut self.items {
+            let ItemKind::Item(item) = &mut item.item else {
+                continue;
+            };
             item.colors = Some(Dynamic::new(colors));
         }
     }
@@ -707,12 +758,26 @@ where
     }
 }
 
+#[derive(Debug)]
+struct RenderedItem<T> {
+    item: ItemKind<OpenItem<T>>,
+    y: UPx,
+    height: UPx,
+}
+
+impl<T> RenderedItem<T> {
+    fn submenu(&self) -> Option<&Arc<dyn SubmenuFactory>> {
+        match &self.item {
+            ItemKind::Item(item) => item.submenu.as_ref(),
+            ItemKind::Separator => None,
+        }
+    }
+}
+
 struct OpenItem<T> {
     value: T,
     contents: WidgetRef,
     submenu: Option<Arc<dyn SubmenuFactory>>,
-    y: UPx,
-    height: UPx,
     colors: Option<Dynamic<ButtonColors>>,
     color_animation: AnimationHandle,
     state: VisualState,
@@ -727,7 +792,6 @@ where
             .field("value", &self.value)
             .field("contents", &self.contents)
             .field("submenu", &self.submenu.is_some())
-            .field("height", &self.height)
             .finish_non_exhaustive()
     }
 }