1662 lines
57 KiB
Rust
1662 lines
57 KiB
Rust
// From iced_aw, license MIT
|
|
|
|
//! Menu tree overlay
|
|
use std::borrow::Cow;
|
|
|
|
use super::{menu_bar::MenuBarState, menu_tree::MenuTree};
|
|
use crate::style::menu_bar::StyleSheet;
|
|
|
|
use iced::window;
|
|
use iced_core::{Border, Renderer as IcedRenderer, Shadow, Widget};
|
|
use iced_widget::core::{
|
|
Clipboard, Layout, Length, Padding, Point, Rectangle, Shell, Size, Vector, event,
|
|
layout::{Limits, Node},
|
|
mouse::{self, Cursor},
|
|
overlay, renderer, touch,
|
|
widget::Tree,
|
|
};
|
|
|
|
/// The condition of when to close a menu
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub struct CloseCondition {
|
|
/// Close menus when the cursor moves outside the check bounds
|
|
pub leave: bool,
|
|
|
|
/// Close menus when the cursor clicks outside the check bounds
|
|
pub click_outside: bool,
|
|
|
|
/// Close menus when the cursor clicks inside the check bounds
|
|
pub click_inside: bool,
|
|
}
|
|
|
|
/// The width of an item
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub enum ItemWidth {
|
|
/// Use uniform width
|
|
Uniform(u16),
|
|
/// Static tries to use the width value of each menu(menu tree with children),
|
|
/// the widths of items(menu tree with empty children) will be the same as the menu they're in,
|
|
/// if that value is None,
|
|
/// the default value will be used instead,
|
|
/// which is the value of the Static variant
|
|
Static(u16),
|
|
}
|
|
|
|
/// The height of an item
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub enum ItemHeight {
|
|
/// Use uniform height.
|
|
Uniform(u16),
|
|
/// Static tries to use `MenuTree.height` as item height,
|
|
/// when it's `None` it'll fallback to the value of the `Static` variant.
|
|
Static(u16),
|
|
/// Dynamic tries to automatically choose the proper item height for you,
|
|
/// but it only works in certain cases:
|
|
///
|
|
/// - Fixed height
|
|
/// - Shrink height
|
|
/// - Menu tree height
|
|
///
|
|
/// If none of these is the case, it'll fallback to the value of the `Dynamic` variant.
|
|
Dynamic(u16),
|
|
}
|
|
|
|
/// Methods for drawing path highlight
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub enum PathHighlight {
|
|
/// Draw the full path,
|
|
Full,
|
|
/// Omit the active item(the last item in the path)
|
|
OmitActive,
|
|
/// Omit the active item if it's not a menu
|
|
MenuActive,
|
|
}
|
|
|
|
/// X+ goes right and Y+ goes down
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub(crate) enum Direction {
|
|
Positive,
|
|
Negative,
|
|
}
|
|
|
|
/// Adaptive open direction
|
|
#[derive(Debug)]
|
|
#[allow(clippy::struct_excessive_bools)]
|
|
struct Aod {
|
|
// whether or not to use aod
|
|
horizontal: bool,
|
|
vertical: bool,
|
|
|
|
// whether or not to use overlap
|
|
horizontal_overlap: bool,
|
|
vertical_overlap: bool,
|
|
|
|
// default direction
|
|
horizontal_direction: Direction,
|
|
vertical_direction: Direction,
|
|
|
|
// Offset of the child in the default direction
|
|
horizontal_offset: f32,
|
|
vertical_offset: f32,
|
|
}
|
|
impl Aod {
|
|
/// Returns child position and offset position
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn adaptive(
|
|
parent_pos: f32,
|
|
parent_size: f32,
|
|
child_size: f32,
|
|
max_size: f32,
|
|
offset: f32,
|
|
on: bool,
|
|
overlap: bool,
|
|
direction: Direction,
|
|
) -> (f32, f32) {
|
|
/*
|
|
Imagine there're two sticks, parent and child
|
|
parent: o-----o
|
|
child: o----------o
|
|
|
|
Now we align the child to the parent in one dimension
|
|
There are 4 possibilities:
|
|
|
|
1. to the right
|
|
o-----oo----------o
|
|
|
|
2. to the right but allow overlaping
|
|
o-----o
|
|
o----------o
|
|
|
|
3. to the left
|
|
o----------oo-----o
|
|
|
|
4. to the left but allow overlaping
|
|
o-----o
|
|
o----------o
|
|
|
|
The child goes to the default direction by default,
|
|
if the space on the default direction runs out it goes to the the other,
|
|
whether to use overlap is the caller's decision
|
|
|
|
This can be applied to any direction
|
|
*/
|
|
|
|
match direction {
|
|
Direction::Positive => {
|
|
let space_negative = parent_pos;
|
|
let space_positive = max_size - parent_pos - parent_size;
|
|
|
|
if overlap {
|
|
let overshoot = child_size - parent_size;
|
|
if on && space_negative > space_positive && overshoot > space_positive {
|
|
(parent_pos - overshoot, parent_pos - overshoot)
|
|
} else {
|
|
(parent_pos, parent_pos)
|
|
}
|
|
} else {
|
|
let overshoot = child_size + offset;
|
|
if on && space_negative > space_positive && overshoot > space_positive {
|
|
(parent_pos - overshoot, parent_pos - offset)
|
|
} else {
|
|
(parent_pos + parent_size + offset, parent_pos + parent_size)
|
|
}
|
|
}
|
|
}
|
|
Direction::Negative => {
|
|
let space_positive = parent_pos;
|
|
let space_negative = max_size - parent_pos - parent_size;
|
|
|
|
if overlap {
|
|
let overshoot = child_size - parent_size;
|
|
if on && space_negative > space_positive && overshoot > space_positive {
|
|
(parent_pos, parent_pos)
|
|
} else {
|
|
(parent_pos - overshoot, parent_pos - overshoot)
|
|
}
|
|
} else {
|
|
let overshoot = child_size + offset;
|
|
if on && space_negative > space_positive && overshoot > space_positive {
|
|
(parent_pos + parent_size + offset, parent_pos + parent_size)
|
|
} else {
|
|
(parent_pos - overshoot, parent_pos - offset)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns child position and offset position
|
|
fn resolve(
|
|
&self,
|
|
parent_bounds: Rectangle,
|
|
children_size: Size,
|
|
viewport_size: Size,
|
|
) -> (Point, Point) {
|
|
let (x, ox) = Self::adaptive(
|
|
parent_bounds.x,
|
|
parent_bounds.width,
|
|
children_size.width,
|
|
viewport_size.width,
|
|
self.horizontal_offset,
|
|
self.horizontal,
|
|
self.horizontal_overlap,
|
|
self.horizontal_direction,
|
|
);
|
|
let (y, oy) = Self::adaptive(
|
|
parent_bounds.y,
|
|
parent_bounds.height,
|
|
children_size.height,
|
|
viewport_size.height,
|
|
self.vertical_offset,
|
|
self.vertical,
|
|
self.vertical_overlap,
|
|
self.vertical_direction,
|
|
);
|
|
|
|
([x, y].into(), [ox, oy].into())
|
|
}
|
|
}
|
|
|
|
/// A part of a menu where items are displayed.
|
|
///
|
|
/// When the bounds of a menu exceed the viewport,
|
|
/// only items inside the viewport will be displayed,
|
|
/// when scrolling happens, this should be updated
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub(super) struct MenuSlice {
|
|
pub(super) start_index: usize,
|
|
pub(super) end_index: usize,
|
|
pub(super) lower_bound_rel: f32,
|
|
pub(super) upper_bound_rel: f32,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
/// Menu bounds in overlay space
|
|
struct MenuBounds {
|
|
child_positions: Vec<f32>,
|
|
child_sizes: Vec<Size>,
|
|
children_bounds: Rectangle,
|
|
parent_bounds: Rectangle,
|
|
check_bounds: Rectangle,
|
|
offset_bounds: Rectangle,
|
|
}
|
|
impl MenuBounds {
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn new<Message>(
|
|
menu_tree: &MenuTree<Message>,
|
|
renderer: &crate::Renderer,
|
|
item_width: ItemWidth,
|
|
item_height: ItemHeight,
|
|
viewport_size: Size,
|
|
overlay_offset: Vector,
|
|
aod: &Aod,
|
|
bounds_expand: u16,
|
|
parent_bounds: Rectangle,
|
|
tree: &mut [Tree],
|
|
is_overlay: bool,
|
|
) -> Self {
|
|
let (children_size, child_positions, child_sizes) =
|
|
get_children_layout(menu_tree, renderer, item_width, item_height, tree);
|
|
|
|
// viewport space parent bounds
|
|
let view_parent_bounds = parent_bounds + overlay_offset;
|
|
|
|
// overlay space children position
|
|
let (children_position, offset_position) = {
|
|
let (cp, op) = aod.resolve(view_parent_bounds, children_size, viewport_size);
|
|
if is_overlay {
|
|
(cp - overlay_offset, op - overlay_offset)
|
|
} else {
|
|
(Point::ORIGIN, op - overlay_offset)
|
|
}
|
|
};
|
|
|
|
// calc offset bounds
|
|
let delta = children_position - offset_position;
|
|
let offset_size = if delta.x.abs() > delta.y.abs() {
|
|
Size::new(delta.x, children_size.height)
|
|
} else {
|
|
Size::new(children_size.width, delta.y)
|
|
};
|
|
let offset_bounds = Rectangle::new(offset_position, offset_size);
|
|
|
|
let children_bounds = Rectangle::new(children_position, children_size);
|
|
let check_bounds = pad_rectangle(children_bounds, bounds_expand.into());
|
|
|
|
Self {
|
|
child_positions,
|
|
child_sizes,
|
|
children_bounds,
|
|
parent_bounds,
|
|
check_bounds,
|
|
offset_bounds,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub(crate) struct MenuState {
|
|
/// The index of the active menu item
|
|
pub(super) index: Option<usize>,
|
|
scroll_offset: f32,
|
|
menu_bounds: MenuBounds,
|
|
}
|
|
impl MenuState {
|
|
pub(super) fn layout<Message>(
|
|
&self,
|
|
overlay_offset: Vector,
|
|
slice: MenuSlice,
|
|
renderer: &crate::Renderer,
|
|
menu_tree: &[MenuTree<Message>],
|
|
tree: &mut [Tree],
|
|
) -> Node {
|
|
let MenuSlice {
|
|
start_index,
|
|
end_index,
|
|
lower_bound_rel,
|
|
upper_bound_rel,
|
|
} = slice;
|
|
|
|
// assert_eq!(
|
|
// menu_tree.children.len(),
|
|
// self.menu_bounds.child_positions.len()
|
|
// );
|
|
|
|
// for mt in &menu_tree.children[start_index..=end_index] {
|
|
// dbg!(mt.index);
|
|
// }
|
|
dbg!((start_index, end_index, menu_tree.len()));
|
|
|
|
// viewport space children bounds
|
|
let children_bounds = self.menu_bounds.children_bounds + overlay_offset;
|
|
dbg!(children_bounds);
|
|
let child_nodes = self.menu_bounds.child_positions[start_index..=end_index]
|
|
.iter()
|
|
.zip(self.menu_bounds.child_sizes[start_index..=end_index].iter())
|
|
.zip(menu_tree[start_index..=end_index].iter())
|
|
.enumerate()
|
|
.map(|(i, ((cp, size), mt))| {
|
|
let mut position = *cp;
|
|
let mut size = *size;
|
|
dbg!(position, size);
|
|
|
|
if position < lower_bound_rel && (position + size.height) > lower_bound_rel {
|
|
size.height = position + size.height - lower_bound_rel;
|
|
position = lower_bound_rel;
|
|
} else if position <= upper_bound_rel && (position + size.height) > upper_bound_rel
|
|
{
|
|
size.height = upper_bound_rel - position;
|
|
}
|
|
// dbg!(size);
|
|
|
|
let limits = Limits::new(size, size);
|
|
dbg!(i, mt.index, tree.len());
|
|
for child in &mt.children {
|
|
dbg!(child.index);
|
|
}
|
|
|
|
mt.item
|
|
.layout(&mut tree[mt.index], renderer, &limits)
|
|
.move_to(Point::new(0.0, position + self.scroll_offset))
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
// dbg!(children_bounds.size());
|
|
let node = Node::with_children(children_bounds.size(), child_nodes)
|
|
.move_to(children_bounds.position());
|
|
// dbg!(&node);
|
|
node
|
|
}
|
|
|
|
fn layout_single<Message>(
|
|
&self,
|
|
overlay_offset: Vector,
|
|
index: usize,
|
|
renderer: &crate::Renderer,
|
|
menu_tree: &MenuTree<Message>,
|
|
tree: &mut Tree,
|
|
) -> Node {
|
|
// viewport space children bounds
|
|
let children_bounds = self.menu_bounds.children_bounds + overlay_offset;
|
|
|
|
let position = self.menu_bounds.child_positions[index];
|
|
let limits = Limits::new(Size::ZERO, self.menu_bounds.child_sizes[index]);
|
|
let parent_offset = children_bounds.position() - Point::ORIGIN;
|
|
let node = menu_tree.item.layout(tree, renderer, &limits);
|
|
node.clone().move_to(Point::new(
|
|
parent_offset.x,
|
|
parent_offset.y + position + self.scroll_offset,
|
|
))
|
|
}
|
|
|
|
/// returns a slice of the menu items that are inside the viewport
|
|
pub(super) fn slice(
|
|
&self,
|
|
viewport_size: Size,
|
|
overlay_offset: Vector,
|
|
item_height: ItemHeight,
|
|
) -> MenuSlice {
|
|
// viewport space children bounds
|
|
let children_bounds = self.menu_bounds.children_bounds + overlay_offset;
|
|
|
|
let max_index = self.menu_bounds.child_positions.len().saturating_sub(1);
|
|
|
|
// viewport space absolute bounds
|
|
let lower_bound = children_bounds.y.max(0.0);
|
|
let upper_bound = (children_bounds.y + children_bounds.height).min(viewport_size.height);
|
|
|
|
// menu space relative bounds
|
|
let lower_bound_rel = lower_bound - (children_bounds.y + self.scroll_offset);
|
|
let upper_bound_rel = upper_bound - (children_bounds.y + self.scroll_offset);
|
|
|
|
// index range
|
|
let (start_index, end_index) = match item_height {
|
|
ItemHeight::Uniform(u) => {
|
|
let start_index = (lower_bound_rel / f32::from(u)).floor() as usize;
|
|
let end_index = ((upper_bound_rel / f32::from(u)).floor() as usize).min(max_index);
|
|
(start_index, end_index)
|
|
}
|
|
ItemHeight::Static(_) | ItemHeight::Dynamic(_) => {
|
|
let positions = &self.menu_bounds.child_positions;
|
|
let sizes = &self.menu_bounds.child_sizes;
|
|
|
|
let start_index = search_bound(0, 0, max_index, lower_bound_rel, positions, sizes);
|
|
let end_index = search_bound(
|
|
max_index,
|
|
start_index,
|
|
max_index,
|
|
upper_bound_rel,
|
|
positions,
|
|
sizes,
|
|
)
|
|
.min(max_index);
|
|
|
|
(start_index, end_index)
|
|
}
|
|
};
|
|
|
|
MenuSlice {
|
|
start_index,
|
|
end_index,
|
|
lower_bound_rel,
|
|
upper_bound_rel,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) struct Menu<'b, Message: std::clone::Clone> {
|
|
pub(crate) tree: MenuBarState,
|
|
// Flattened menu tree
|
|
pub(crate) menu_roots: Cow<'b, Vec<MenuTree<Message>>>,
|
|
pub(crate) bounds_expand: u16,
|
|
/// Allows menu overlay items to overlap the parent
|
|
pub(crate) menu_overlays_parent: bool,
|
|
pub(crate) close_condition: CloseCondition,
|
|
pub(crate) item_width: ItemWidth,
|
|
pub(crate) item_height: ItemHeight,
|
|
pub(crate) bar_bounds: Rectangle,
|
|
pub(crate) main_offset: i32,
|
|
pub(crate) cross_offset: i32,
|
|
pub(crate) root_bounds_list: Vec<Rectangle>,
|
|
pub(crate) path_highlight: Option<PathHighlight>,
|
|
pub(crate) style: Cow<'b, <crate::Theme as StyleSheet>::Style>,
|
|
pub(crate) position: Point,
|
|
pub(crate) is_overlay: bool,
|
|
/// window id for this popup
|
|
pub(crate) window_id: window::Id,
|
|
pub(crate) depth: usize,
|
|
}
|
|
impl<'b, Message: Clone + 'static> Menu<'b, Message> {
|
|
pub(crate) fn overlay(self) -> overlay::Element<'b, Message, crate::Theme, crate::Renderer> {
|
|
overlay::Element::new(Box::new(self))
|
|
}
|
|
|
|
fn layout(&mut self, renderer: &crate::Renderer, limits: Limits) -> Node {
|
|
// layout children;
|
|
let position = self.position;
|
|
let mut intrinsic_size = Size::ZERO;
|
|
|
|
dbg!(self.depth);
|
|
let empty = Vec::new();
|
|
self.tree.inner.with_data_mut(|data| {
|
|
let overlay_offset = Point::ORIGIN - position;
|
|
let tree_children = &mut data.tree.children;
|
|
dbg!(&data.active_root,);
|
|
let children = data
|
|
.active_root
|
|
.get(self.depth)
|
|
.cloned()
|
|
.map(|active_root| {
|
|
if active_root.is_empty() || self.menu_roots.is_empty() {
|
|
return (&empty, vec![]);
|
|
}
|
|
let (active_tree, roots) = active_root.iter().take(self.depth).fold(
|
|
(
|
|
&mut tree_children[active_root[0]].children,
|
|
&self.menu_roots[active_root[0]].children,
|
|
),
|
|
|(tree, mt), next_active_root| (tree, &mt[*next_active_root].children),
|
|
);
|
|
|
|
dbg!(roots.len());
|
|
dbg!(&active_root);
|
|
dbg!(active_tree.len());
|
|
// dbg!(
|
|
// self.window_id,
|
|
// limits.max(),
|
|
// my_ref_mut.menu_states[&self.window_id].len()
|
|
// );
|
|
// dbg!(my_ref_mut.active_root.get(&self.window_id));
|
|
// for (i, active_tree) in active_tree.iter().enumerate() {
|
|
// dbg!(i);
|
|
// for (i2, active_tree) in active_tree.children.iter().enumerate() {
|
|
// dbg!(i2);
|
|
// for (i3, active_tree) in active_tree.children.iter().enumerate() {
|
|
// dbg!(i3);
|
|
// }
|
|
// }
|
|
// }
|
|
if let Some(ms) = data.menu_states.get(self.depth) {
|
|
ms.iter()
|
|
.enumerate()
|
|
.filter(|ms| self.is_overlay || ms.0 < active_root.len())
|
|
.fold((roots, Vec::new()), |(menu_root, mut nodes), (_i, ms)| {
|
|
dbg!(ms.index);
|
|
let slice =
|
|
ms.slice(limits.max(), overlay_offset, self.item_height);
|
|
let _start_index = slice.start_index;
|
|
let _end_index = slice.end_index;
|
|
dbg!(&self.depth, &self.window_id, menu_root.len());
|
|
let children_node = ms.layout(
|
|
overlay_offset,
|
|
slice,
|
|
renderer,
|
|
menu_root,
|
|
active_tree,
|
|
);
|
|
let node_size = children_node.size();
|
|
// dbg!(node_size.height);
|
|
intrinsic_size.height += node_size.height;
|
|
intrinsic_size.width = intrinsic_size.width.max(node_size.width);
|
|
nodes.push(children_node);
|
|
// if popup just use len 1?
|
|
// only the last menu can have a None active index
|
|
// dbg!(ms.index);
|
|
(
|
|
ms.index
|
|
.map_or(menu_root, |active| &menu_root[active].children),
|
|
nodes,
|
|
)
|
|
})
|
|
} else {
|
|
(&empty, vec![])
|
|
}
|
|
})
|
|
.map(|(_, l)| l)
|
|
.unwrap_or_default();
|
|
// dbg!(intrinsic_size);
|
|
// overlay space viewport rectangle
|
|
Node::with_children(
|
|
limits.resolve(Length::Shrink, Length::Shrink, intrinsic_size),
|
|
children,
|
|
)
|
|
.translate(Point::ORIGIN - position)
|
|
})
|
|
}
|
|
|
|
fn on_event(
|
|
&mut self,
|
|
event: event::Event,
|
|
layout: Layout<'_>,
|
|
view_cursor: Cursor,
|
|
renderer: &crate::Renderer,
|
|
clipboard: &mut dyn Clipboard,
|
|
shell: &mut Shell<'_, Message>,
|
|
) -> (Option<(usize, MenuState)>, event::Status) {
|
|
use event::{
|
|
Event::{Mouse, Touch},
|
|
Status::{Captured, Ignored},
|
|
};
|
|
use mouse::{
|
|
Button::Left,
|
|
Event::{ButtonPressed, ButtonReleased, CursorMoved, WheelScrolled},
|
|
};
|
|
use touch::Event::{FingerLifted, FingerMoved, FingerPressed};
|
|
|
|
if !self.tree.inner.with_data(|data| data.open) {
|
|
return (None, Ignored);
|
|
};
|
|
|
|
let viewport = layout.bounds();
|
|
let viewport_size = viewport.size();
|
|
let overlay_offset = Point::ORIGIN - viewport.position();
|
|
let overlay_cursor = view_cursor.position().unwrap_or_default() - overlay_offset;
|
|
let menu_roots = match &mut self.menu_roots {
|
|
Cow::Borrowed(_) => panic!(),
|
|
Cow::Owned(o) => o.as_mut_slice(),
|
|
};
|
|
let menu_status = process_menu_events(
|
|
self,
|
|
event.clone(),
|
|
view_cursor,
|
|
renderer,
|
|
clipboard,
|
|
shell,
|
|
overlay_offset,
|
|
);
|
|
|
|
dbg!("init_root_menu");
|
|
init_root_menu(
|
|
self,
|
|
renderer,
|
|
shell,
|
|
overlay_cursor,
|
|
viewport_size,
|
|
overlay_offset,
|
|
self.bar_bounds,
|
|
self.main_offset as f32,
|
|
);
|
|
|
|
let ret = match event {
|
|
Mouse(WheelScrolled { delta }) => {
|
|
process_scroll_events(self, delta, overlay_cursor, viewport_size, overlay_offset)
|
|
.merge(menu_status)
|
|
}
|
|
|
|
Mouse(ButtonPressed(Left)) | Touch(FingerPressed { .. }) => {
|
|
self.tree.inner.with_data_mut(|data| {
|
|
data.pressed = true;
|
|
data.view_cursor = view_cursor;
|
|
});
|
|
Captured
|
|
}
|
|
|
|
Mouse(CursorMoved { position }) | Touch(FingerMoved { position, .. }) => {
|
|
let view_cursor = Cursor::Available(position);
|
|
let overlay_cursor = view_cursor.position().unwrap_or_default() - overlay_offset;
|
|
if !(self.is_overlay || view_cursor.is_over(viewport)) {
|
|
return (None, menu_status);
|
|
}
|
|
// dbg!(view_cursor, viewport, self.window_id);
|
|
|
|
let (new_root, status) = process_overlay_events(
|
|
self,
|
|
renderer,
|
|
viewport_size,
|
|
overlay_offset,
|
|
view_cursor,
|
|
overlay_cursor,
|
|
self.cross_offset as f32,
|
|
self.is_overlay,
|
|
);
|
|
return (new_root, status.merge(menu_status));
|
|
}
|
|
|
|
Mouse(ButtonReleased(_)) | Touch(FingerLifted { .. }) => {
|
|
self.tree.inner.with_data_mut(|state| {
|
|
state.pressed = false;
|
|
|
|
// process close condition
|
|
if state
|
|
.view_cursor
|
|
.position()
|
|
.unwrap_or_default()
|
|
.distance(view_cursor.position().unwrap_or_default())
|
|
< 2.0
|
|
{
|
|
let is_inside = state.menu_states[self.depth]
|
|
.iter()
|
|
.any(|ms| ms.menu_bounds.check_bounds.contains(overlay_cursor));
|
|
|
|
if self.close_condition.click_inside
|
|
&& is_inside
|
|
&& matches!(
|
|
event,
|
|
Mouse(ButtonReleased(Left)) | Touch(FingerLifted { .. })
|
|
)
|
|
{
|
|
state.reset();
|
|
return Captured;
|
|
}
|
|
|
|
if self.close_condition.click_outside && !is_inside {
|
|
state.reset();
|
|
return Captured;
|
|
}
|
|
}
|
|
|
|
// close all menus when clicking inside the menu bar
|
|
if self.bar_bounds.contains(overlay_cursor) {
|
|
state.reset();
|
|
Captured
|
|
} else {
|
|
menu_status
|
|
}
|
|
})
|
|
}
|
|
|
|
_ => menu_status,
|
|
};
|
|
(None, ret)
|
|
}
|
|
|
|
#[allow(unused_results)]
|
|
fn draw(
|
|
&self,
|
|
renderer: &mut crate::Renderer,
|
|
theme: &crate::Theme,
|
|
style: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
view_cursor: Cursor,
|
|
) {
|
|
self.tree.inner.with_data(|state| {
|
|
let Some(active_root) = state.active_root.get(self.depth) else {
|
|
// dbg!(self.window_id);
|
|
return;
|
|
};
|
|
dbg!(active_root);
|
|
let viewport = layout.bounds();
|
|
let viewport_size = viewport.size();
|
|
let overlay_offset = Point::ORIGIN - viewport.position();
|
|
|
|
let render_bounds = if self.is_overlay {
|
|
Rectangle::new(Point::ORIGIN, viewport.size())
|
|
} else {
|
|
Rectangle::new(Point::ORIGIN, Size::INFINITY)
|
|
};
|
|
// dbg!(self.window_id, &active_root);
|
|
|
|
let styling = theme.appearance(&self.style);
|
|
let (active_tree, roots) = active_root.iter().take(self.depth).fold(
|
|
(
|
|
&state.tree.children[active_root[0]].children,
|
|
&self.menu_roots[active_root[0]].children,
|
|
),
|
|
|(tree, mt), next_active_root| (tree, &mt[*next_active_root].children),
|
|
);
|
|
|
|
dbg!(
|
|
state.tree.children.len(),
|
|
state.tree.children[active_root[0]].children.len()
|
|
);
|
|
// let tree = &state.tree.children[active_root].children;
|
|
// let root = &self.menu_roots[active_root];
|
|
dbg!(&active_root.len());
|
|
|
|
let indices = state.get_trimmed_indices(self.depth).collect::<Vec<_>>();
|
|
dbg!(self.depth);
|
|
|
|
dbg!(
|
|
self.window_id,
|
|
state.menu_states.len(),
|
|
state.menu_states[self.depth].len(),
|
|
layout.children().count(),
|
|
layout.bounds()
|
|
);
|
|
state.menu_states[self.depth]
|
|
.iter()
|
|
.zip(layout.children())
|
|
.enumerate()
|
|
.filter(|ms: &(usize, (&MenuState, Layout<'_>))| {
|
|
self.is_overlay || ms.0 < active_root.len()
|
|
})
|
|
.fold(roots, |menu_roots, (i, (ms, children_layout))| {
|
|
let draw_path = self.path_highlight.as_ref().map_or(false, |ph| match ph {
|
|
PathHighlight::Full => true,
|
|
PathHighlight::OmitActive => !indices.is_empty() && i < indices.len() - 1,
|
|
PathHighlight::MenuActive => i < state.menu_states.len() - 1,
|
|
});
|
|
|
|
// react only to the last menu
|
|
let view_cursor = if i == state.menu_states.len() - 1 {
|
|
view_cursor
|
|
} else {
|
|
Cursor::Available([-1.0; 2].into())
|
|
};
|
|
|
|
let draw_menu = |r: &mut crate::Renderer| {
|
|
// calc slice
|
|
let slice = ms.slice(viewport_size, overlay_offset, self.item_height);
|
|
let start_index = slice.start_index;
|
|
let end_index = slice.end_index;
|
|
|
|
let children_bounds = children_layout.bounds();
|
|
|
|
// draw menu background
|
|
// let bounds = pad_rectangle(children_bounds, styling.background_expand.into());
|
|
// println!("cursor: {:?}", view_cursor);
|
|
// println!("bg_bounds: {:?}", bounds);
|
|
// println!("color: {:?}\n", styling.background);
|
|
let menu_quad = renderer::Quad {
|
|
bounds: pad_rectangle(
|
|
children_bounds,
|
|
styling.background_expand.into(),
|
|
),
|
|
border: Border {
|
|
radius: styling.menu_border_radius.into(),
|
|
width: styling.border_width,
|
|
color: styling.border_color,
|
|
},
|
|
shadow: Shadow::default(),
|
|
};
|
|
let menu_color = styling.background;
|
|
r.fill_quad(menu_quad, menu_color);
|
|
|
|
// draw path hightlight
|
|
if let (true, Some(active)) = (draw_path, ms.index) {
|
|
if let Some(active_layout) = children_layout
|
|
.children()
|
|
.nth(active.saturating_sub(start_index))
|
|
{
|
|
let path_quad = renderer::Quad {
|
|
bounds: active_layout.bounds(),
|
|
border: Border {
|
|
radius: styling.menu_border_radius.into(),
|
|
..Default::default()
|
|
},
|
|
shadow: Shadow::default(),
|
|
};
|
|
|
|
r.fill_quad(path_quad, styling.path);
|
|
}
|
|
}
|
|
if start_index < menu_roots.len() {
|
|
dbg!(start_index, end_index, menu_roots.len());
|
|
// draw item
|
|
menu_roots[start_index..=end_index]
|
|
.iter()
|
|
.zip(children_layout.children())
|
|
.for_each(|(mt, clo)| {
|
|
mt.item.draw(
|
|
&active_tree[mt.index],
|
|
r,
|
|
theme,
|
|
style,
|
|
clo,
|
|
view_cursor,
|
|
&children_layout.bounds(),
|
|
);
|
|
});
|
|
}
|
|
};
|
|
|
|
renderer.with_layer(render_bounds, draw_menu);
|
|
|
|
// only the last menu can have a None active index
|
|
ms.index
|
|
.map_or(menu_roots, |active| &menu_roots[active].children)
|
|
});
|
|
})
|
|
}
|
|
}
|
|
impl<Message: Clone + 'static> overlay::Overlay<Message, crate::Theme, crate::Renderer>
|
|
for Menu<'_, Message>
|
|
{
|
|
fn layout(&mut self, renderer: &crate::Renderer, bounds: Size) -> iced_core::layout::Node {
|
|
Menu::layout(
|
|
self,
|
|
renderer,
|
|
Limits::NONE
|
|
.min_width(bounds.width)
|
|
.max_width(bounds.width)
|
|
.min_height(bounds.height)
|
|
.max_height(bounds.height),
|
|
)
|
|
}
|
|
|
|
fn on_event(
|
|
&mut self,
|
|
event: iced::Event,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
renderer: &crate::Renderer,
|
|
clipboard: &mut dyn Clipboard,
|
|
shell: &mut Shell<'_, Message>,
|
|
) -> event::Status {
|
|
self.on_event(event, layout, cursor, renderer, clipboard, shell)
|
|
.1
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
renderer: &mut crate::Renderer,
|
|
theme: &crate::Theme,
|
|
style: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
) {
|
|
self.draw(renderer, theme, style, layout, cursor);
|
|
}
|
|
}
|
|
|
|
fn pad_rectangle(rect: Rectangle, padding: Padding) -> Rectangle {
|
|
Rectangle {
|
|
x: rect.x - padding.left,
|
|
y: rect.y - padding.top,
|
|
width: rect.width + padding.horizontal(),
|
|
height: rect.height + padding.vertical(),
|
|
}
|
|
}
|
|
|
|
pub(super) fn init_root_menu<Message: Clone>(
|
|
menu: &mut Menu<'_, Message>,
|
|
renderer: &crate::Renderer,
|
|
shell: &mut Shell<'_, Message>,
|
|
overlay_cursor: Point,
|
|
viewport_size: Size,
|
|
overlay_offset: Vector,
|
|
bar_bounds: Rectangle,
|
|
main_offset: f32,
|
|
) {
|
|
menu.tree.inner.with_data_mut(|state| {
|
|
if !(state
|
|
.menu_states
|
|
.get(menu.depth)
|
|
.is_none_or(|s| s.is_empty())
|
|
&& (!menu.is_overlay || bar_bounds.contains(overlay_cursor)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
println!(
|
|
"init root menu {} {} {:?}",
|
|
menu.depth, menu.window_id, &menu.root_bounds_list
|
|
);
|
|
dbg!(menu.menu_roots.len());
|
|
dbg!(
|
|
state
|
|
.menu_states
|
|
.get(menu.depth)
|
|
.is_none_or(|s| s.is_empty())
|
|
);
|
|
dbg!(
|
|
menu.menu_roots
|
|
.as_slice()
|
|
.iter()
|
|
.map(|r| r.index)
|
|
.collect::<Vec<_>>()
|
|
);
|
|
|
|
dbg!(
|
|
state
|
|
.active_root
|
|
.get(menu.depth)
|
|
.into_iter()
|
|
.flatten()
|
|
.count()
|
|
.saturating_sub(1)
|
|
);
|
|
let root = state
|
|
.active_root
|
|
.get(menu.depth)
|
|
.iter()
|
|
.map(|l| l.into_iter())
|
|
.flatten()
|
|
.take(
|
|
state
|
|
.active_root
|
|
.get(menu.depth)
|
|
.into_iter()
|
|
.flatten()
|
|
.count()
|
|
.saturating_sub(1),
|
|
)
|
|
.fold(menu.menu_roots.as_slice(), |m, i| {
|
|
dbg!(m.len());
|
|
m[*i].children.as_slice()
|
|
});
|
|
dbg!(root.len());
|
|
|
|
let mut set = false;
|
|
for (i, (&root_bounds, mt)) in menu
|
|
.root_bounds_list
|
|
.iter()
|
|
.zip(menu.menu_roots.iter())
|
|
.enumerate()
|
|
{
|
|
if mt.children.is_empty() {
|
|
// dbg!("skipping menu with no children");
|
|
continue;
|
|
}
|
|
dbg!(mt.children.len());
|
|
dbg!(i, root_bounds.contains(overlay_cursor));
|
|
if root_bounds.contains(overlay_cursor) {
|
|
dbg!(root_bounds);
|
|
// dbg!(i, root_bounds, mt.width, mt.height);
|
|
let view_center = viewport_size.width * 0.5;
|
|
let rb_center = root_bounds.center_x();
|
|
|
|
state.horizontal_direction = if rb_center > view_center {
|
|
Direction::Negative
|
|
} else {
|
|
Direction::Positive
|
|
};
|
|
|
|
let aod = Aod {
|
|
horizontal: true,
|
|
vertical: true,
|
|
horizontal_overlap: true,
|
|
vertical_overlap: false,
|
|
horizontal_direction: state.horizontal_direction,
|
|
vertical_direction: state.vertical_direction,
|
|
horizontal_offset: 0.0,
|
|
vertical_offset: main_offset,
|
|
};
|
|
let menu_bounds = MenuBounds::new(
|
|
mt,
|
|
renderer,
|
|
menu.item_width,
|
|
menu.item_height,
|
|
viewport_size,
|
|
overlay_offset,
|
|
&aod,
|
|
menu.bounds_expand,
|
|
root_bounds,
|
|
&mut state.tree.children[0].children,
|
|
menu.is_overlay,
|
|
);
|
|
set = true;
|
|
dbg!(i);
|
|
|
|
dbg!("inserting root menu state");
|
|
dbg!(&menu_bounds.children_bounds);
|
|
dbg!((&menu_bounds.child_positions));
|
|
state.active_root.insert(menu.depth, vec![i]);
|
|
// do we need to insert the rest now too?
|
|
let ms = MenuState {
|
|
index: None,
|
|
scroll_offset: 0.0,
|
|
menu_bounds,
|
|
};
|
|
dbg!("pushing to menu states...");
|
|
let v = super::menu_bar::get_mut_or_default(&mut state.menu_states, menu.depth);
|
|
v.push(ms);
|
|
|
|
// Hack to ensure menu opens properly
|
|
shell.invalidate_layout();
|
|
|
|
break;
|
|
}
|
|
}
|
|
if !set {
|
|
dbg!(overlay_cursor);
|
|
panic!("huh");
|
|
}
|
|
});
|
|
}
|
|
|
|
pub(super) fn init_root_popup_menu<Message>(
|
|
menu: &mut Menu<'_, Message>,
|
|
renderer: &crate::Renderer,
|
|
shell: &mut Shell<'_, Message>,
|
|
overlay_cursor: Point,
|
|
viewport_size: Size,
|
|
overlay_offset: Vector,
|
|
bar_bounds: Rectangle,
|
|
main_offset: f32,
|
|
) where
|
|
Message: std::clone::Clone,
|
|
{
|
|
menu.tree.inner.with_data_mut(|state| {
|
|
if !(state
|
|
.menu_states
|
|
.get(menu.depth)
|
|
.is_none_or(|s| s.is_empty())
|
|
&& (!menu.is_overlay || bar_bounds.contains(overlay_cursor)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
println!(
|
|
"init root menu {} {:?}",
|
|
menu.window_id, menu.root_bounds_list
|
|
);
|
|
// dbg!(state
|
|
// .menu_states
|
|
// .get(&menu.window_id)
|
|
// .is_none_or(|s| s.is_empty()));
|
|
// dbg!(menu
|
|
// .menu_roots
|
|
// .as_slice()
|
|
// .iter()
|
|
// .map(|r| r.index)
|
|
// .collect::<Vec<_>>());
|
|
|
|
// dbg!(state
|
|
// .active_root
|
|
// .get(&menu.window_id)
|
|
// .into_iter()
|
|
// .flatten()
|
|
// .count());
|
|
let active_roots = state
|
|
.active_root
|
|
.get(menu.depth)
|
|
.cloned()
|
|
.unwrap_or_default();
|
|
dbg!(&active_roots);
|
|
dbg!(menu.menu_roots.len());
|
|
let root = active_roots
|
|
.iter()
|
|
.take(active_roots.iter().count().saturating_sub(1))
|
|
.fold(menu.menu_roots.as_slice(), |m, i| {
|
|
// dbg!(m.len());
|
|
m[*i].children.as_slice()
|
|
});
|
|
// dbg!(root.len());
|
|
|
|
let mut set = false;
|
|
for (i, (&root_bounds, mt)) in menu.root_bounds_list.iter().zip(root.iter()).enumerate() {
|
|
if mt.children.is_empty() {
|
|
// dbg!("skipping menu with no children");
|
|
continue;
|
|
}
|
|
// dbg!(i, root_bounds.contains(overlay_cursor));
|
|
if root_bounds.contains(overlay_cursor) {
|
|
// dbg!(i, root_bounds, mt.width, mt.height);
|
|
let view_center = viewport_size.width * 0.5;
|
|
let rb_center = root_bounds.center_x();
|
|
|
|
state.horizontal_direction = if rb_center > view_center {
|
|
Direction::Negative
|
|
} else {
|
|
Direction::Positive
|
|
};
|
|
|
|
let aod = Aod {
|
|
horizontal: true,
|
|
vertical: true,
|
|
horizontal_overlap: true,
|
|
vertical_overlap: false,
|
|
horizontal_direction: state.horizontal_direction,
|
|
vertical_direction: state.vertical_direction,
|
|
horizontal_offset: 0.0,
|
|
vertical_offset: main_offset,
|
|
};
|
|
|
|
// dbg!(
|
|
// state.tree.children.len(),
|
|
// state.tree.children[0].children.len(),
|
|
// );
|
|
|
|
let menu_bounds = MenuBounds::new(
|
|
mt,
|
|
renderer,
|
|
menu.item_width,
|
|
menu.item_height,
|
|
viewport_size,
|
|
overlay_offset,
|
|
&aod,
|
|
menu.bounds_expand,
|
|
root_bounds,
|
|
// TODO how to select the tree for the popup
|
|
&mut state.tree.children[0].children,
|
|
menu.is_overlay,
|
|
);
|
|
set = true;
|
|
|
|
let ms = MenuState {
|
|
index: None,
|
|
scroll_offset: 0.0,
|
|
menu_bounds,
|
|
};
|
|
let v = super::menu_bar::get_mut_or_default(&mut state.menu_states, menu.depth);
|
|
v.push(ms);
|
|
|
|
// Hack to ensure menu opens properly
|
|
shell.invalidate_layout();
|
|
|
|
break;
|
|
}
|
|
}
|
|
if !set {
|
|
dbg!(overlay_cursor);
|
|
}
|
|
})
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn process_menu_events<'b, Message: std::clone::Clone>(
|
|
menu: &'b mut Menu<Message>,
|
|
event: event::Event,
|
|
view_cursor: Cursor,
|
|
renderer: &crate::Renderer,
|
|
clipboard: &mut dyn Clipboard,
|
|
shell: &mut Shell<'_, Message>,
|
|
overlay_offset: Vector,
|
|
) -> event::Status {
|
|
use event::Status;
|
|
|
|
let window_id = menu.window_id;
|
|
let is_overlay = menu.is_overlay;
|
|
let my_state = &mut menu.tree;
|
|
let menu_roots = match &mut menu.menu_roots {
|
|
Cow::Borrowed(_) => panic!(),
|
|
Cow::Owned(o) => o.as_mut_slice(),
|
|
};
|
|
my_state.inner.with_data_mut(|state| {
|
|
let Some(active_root) = state.active_root.get(menu.depth).cloned() else {
|
|
return Status::Ignored;
|
|
};
|
|
|
|
let indices = state.get_trimmed_indices(menu.depth);
|
|
|
|
let indices = if is_overlay {
|
|
indices.collect::<Vec<_>>()
|
|
} else {
|
|
indices.take(1).collect::<Vec<_>>()
|
|
};
|
|
|
|
if indices.is_empty() {
|
|
return Status::Ignored;
|
|
}
|
|
|
|
// get active item
|
|
// let mt = indices.iter().fold(root | mt, &i | &mut mt.children[i]);
|
|
let (tree, mt) = active_root.iter().take(menu.depth).fold(
|
|
(
|
|
&mut state.tree.children[active_root[0]].children,
|
|
&mut menu_roots[active_root[0]],
|
|
),
|
|
|(tree, mt), next_active_root| (tree, &mut mt.children[*next_active_root]),
|
|
);
|
|
|
|
// widget tree
|
|
let tree = &mut tree[mt.index];
|
|
|
|
// get layout
|
|
let last_ms = &state.menu_states[menu.depth][indices.len() - 1];
|
|
let child_node = last_ms.layout_single(
|
|
overlay_offset,
|
|
last_ms.index.expect("missing index within menu state."),
|
|
renderer,
|
|
mt,
|
|
tree,
|
|
);
|
|
let child_layout = Layout::new(&child_node);
|
|
|
|
// process only the last widget
|
|
mt.item.on_event(
|
|
tree,
|
|
event,
|
|
child_layout,
|
|
view_cursor,
|
|
renderer,
|
|
clipboard,
|
|
shell,
|
|
&Rectangle::default(),
|
|
)
|
|
})
|
|
}
|
|
|
|
#[allow(unused_results, clippy::too_many_lines, clippy::too_many_arguments)]
|
|
fn process_overlay_events<Message>(
|
|
menu: &mut Menu<Message>,
|
|
renderer: &crate::Renderer,
|
|
viewport_size: Size,
|
|
overlay_offset: Vector,
|
|
view_cursor: Cursor,
|
|
overlay_cursor: Point,
|
|
cross_offset: f32,
|
|
is_overlay: bool,
|
|
) -> (Option<(usize, MenuState)>, event::Status)
|
|
where
|
|
Message: std::clone::Clone,
|
|
{
|
|
use event::Status::{Captured, Ignored};
|
|
/*
|
|
if no active root || pressed:
|
|
return
|
|
else:
|
|
remove invalid menus // overlay space
|
|
update active item
|
|
if active item is a menu:
|
|
add menu // viewport space
|
|
*/
|
|
let mut new_menu_root = None;
|
|
|
|
menu.tree.inner.with_data_mut(|state| {
|
|
let Some(active_root) = state.active_root.get(menu.depth).clone() else {
|
|
if is_overlay && !menu.bar_bounds.contains(overlay_cursor) {
|
|
state.reset();
|
|
}
|
|
return (new_menu_root, Ignored);
|
|
};
|
|
|
|
if state.pressed {
|
|
return (new_menu_root, Ignored);
|
|
}
|
|
|
|
/* When overlay is running, cursor_position in any widget method will go negative
|
|
but I still want Widget::draw() to react to cursor movement */
|
|
state.view_cursor = view_cursor;
|
|
|
|
// * remove invalid menus
|
|
let mut prev_bounds = std::iter::once(menu.bar_bounds)
|
|
.chain(
|
|
state.menu_states[menu.depth][..state.menu_states.len().saturating_sub(1).min(1)]
|
|
.iter()
|
|
.map(|ms| ms.menu_bounds.children_bounds),
|
|
)
|
|
.collect::<Vec<_>>();
|
|
let menu_states = state.menu_states.get_mut(menu.depth).unwrap();
|
|
|
|
if menu.close_condition.leave {
|
|
for i in (0..menu_states.len()).rev() {
|
|
let mb = &menu_states[i].menu_bounds;
|
|
|
|
if mb.parent_bounds.contains(overlay_cursor)
|
|
|| is_overlay && mb.children_bounds.contains(overlay_cursor)
|
|
|| mb.offset_bounds.contains(overlay_cursor)
|
|
|| (mb.check_bounds.contains(overlay_cursor)
|
|
&& prev_bounds.iter().all(|pvb| !pvb.contains(overlay_cursor)))
|
|
{
|
|
break;
|
|
}
|
|
prev_bounds.pop();
|
|
menu_states.pop();
|
|
}
|
|
} else {
|
|
for i in (0..menu_states.len()).rev() {
|
|
let mb = &menu_states[i].menu_bounds;
|
|
|
|
if mb.parent_bounds.contains(overlay_cursor)
|
|
|| mb.children_bounds.contains(overlay_cursor)
|
|
|| prev_bounds.iter().all(|pvb| !pvb.contains(overlay_cursor))
|
|
{
|
|
break;
|
|
}
|
|
// dbg!(menu_states.len());
|
|
prev_bounds.pop();
|
|
menu_states.pop();
|
|
}
|
|
}
|
|
|
|
// get indices
|
|
let indices = menu_states.iter().map(|ms| ms.index).collect::<Vec<_>>();
|
|
let should_add = is_overlay || menu_states.len() < 2;
|
|
|
|
// * update active item
|
|
let Some(last_menu_state) = menu_states.last_mut() else {
|
|
// no menus left
|
|
// TODO do we want to avoid this for popups?
|
|
state.active_root.remove(menu.depth);
|
|
|
|
// keep state.open when the cursor is still inside the menu bar
|
|
// this allows the overlay to keep drawing when the cursor is
|
|
// moving aroung the menu bar
|
|
if !menu.bar_bounds.contains(overlay_cursor) {
|
|
state.open = false;
|
|
}
|
|
return (new_menu_root, Captured);
|
|
};
|
|
|
|
let last_menu_bounds = &last_menu_state.menu_bounds;
|
|
let last_parent_bounds = last_menu_bounds.parent_bounds;
|
|
let last_children_bounds = last_menu_bounds.children_bounds;
|
|
|
|
if (is_overlay && !menu.menu_overlays_parent && last_parent_bounds.contains(overlay_cursor))
|
|
// cursor is in the parent part
|
|
|| is_overlay && !last_children_bounds.contains(overlay_cursor)
|
|
// cursor is outside
|
|
{
|
|
last_menu_state.index = None;
|
|
return (new_menu_root, Captured);
|
|
}
|
|
// cursor is in the children part
|
|
|
|
// calc new index
|
|
let height_diff = (overlay_cursor.y
|
|
- (last_children_bounds.y + last_menu_state.scroll_offset))
|
|
.clamp(0.0, last_children_bounds.height - 0.001);
|
|
// dbg!(height_diff);
|
|
// let (tree, active_menu_root) = active_root.iter().skip(1).fold(
|
|
// (
|
|
// &mut state.tree.children[active_root[0]].children,
|
|
// &menu.menu_roots[active_root[0]],
|
|
// ),
|
|
// |(tree, mr), next_active_root| (tree, &mr.children[*next_active_root]),
|
|
// );
|
|
let (active_tree, roots) = active_root.iter().take(menu.depth).fold(
|
|
(
|
|
&mut state.tree.children[active_root[0]].children,
|
|
&menu.menu_roots[active_root[0]].children,
|
|
),
|
|
|(tree, mt), next_active_root| (tree, &mt[*next_active_root].children),
|
|
);
|
|
let active_menu = if is_overlay {
|
|
indices[0..indices.len().saturating_sub(1)]
|
|
.iter()
|
|
.fold(roots, |mt, i| {
|
|
&mt[i.expect("missing active child index in menu")].children
|
|
})
|
|
} else {
|
|
// popup does one layer deep
|
|
roots
|
|
};
|
|
// dbg!(active_menu.children.len());
|
|
// dbg!(menu.window_id);
|
|
let new_index = match menu.item_height {
|
|
ItemHeight::Uniform(u) => (height_diff / f32::from(u)).floor() as usize,
|
|
ItemHeight::Static(_) | ItemHeight::Dynamic(_) => {
|
|
let max_index = active_menu.len() - 1;
|
|
search_bound(
|
|
0,
|
|
0,
|
|
max_index,
|
|
height_diff,
|
|
&last_menu_bounds.child_positions,
|
|
&last_menu_bounds.child_sizes,
|
|
)
|
|
}
|
|
};
|
|
|
|
let item = &active_menu[new_index];
|
|
// dbg!(new_index);
|
|
// dbg!(item.index);
|
|
// if the index changes, get a new root
|
|
// if !last_menu_state.index.is_some_and(|old| old == new_index) && !item.children.is_empty() {
|
|
// dbg!(&indices);
|
|
// dbg!(new_index);
|
|
// dbg!(item.children.len());
|
|
// dbg!(menu.window_id);
|
|
// new_menu_root = Some(new_index);
|
|
// }
|
|
|
|
// set new index
|
|
let old_index = last_menu_state.index.replace(new_index);
|
|
// dbg!(should_add);
|
|
|
|
// get new active item
|
|
// * add new menu if the new item is a menu
|
|
if !item.children.is_empty() {
|
|
// dbg!("its a menu");
|
|
let item_position = Point::new(
|
|
0.0,
|
|
last_menu_bounds.child_positions[new_index] + last_menu_state.scroll_offset,
|
|
);
|
|
let item_size = last_menu_bounds.child_sizes[new_index];
|
|
|
|
// overlay space item bounds
|
|
let item_bounds = Rectangle::new(item_position, item_size)
|
|
+ (last_menu_bounds.children_bounds.position() - Point::ORIGIN);
|
|
|
|
let aod = Aod {
|
|
horizontal: true,
|
|
vertical: true,
|
|
horizontal_overlap: false,
|
|
vertical_overlap: true,
|
|
horizontal_direction: state.horizontal_direction,
|
|
vertical_direction: state.vertical_direction,
|
|
horizontal_offset: cross_offset,
|
|
vertical_offset: 0.0,
|
|
};
|
|
let ms = MenuState {
|
|
index: None,
|
|
scroll_offset: 0.0,
|
|
menu_bounds: MenuBounds::new(
|
|
item,
|
|
renderer,
|
|
menu.item_width,
|
|
menu.item_height,
|
|
viewport_size,
|
|
overlay_offset,
|
|
&aod,
|
|
menu.bounds_expand,
|
|
item_bounds,
|
|
active_tree,
|
|
menu.is_overlay,
|
|
),
|
|
};
|
|
if !old_index.is_some_and(|old| old == new_index) {
|
|
// dbg!("adding new menu");
|
|
new_menu_root = Some((new_index, ms.clone()));
|
|
}
|
|
if should_add {
|
|
let v = super::menu_bar::get_mut_or_default(&mut state.menu_states, menu.depth);
|
|
v.push(ms);
|
|
}
|
|
}
|
|
|
|
(new_menu_root, Captured)
|
|
})
|
|
}
|
|
|
|
fn process_scroll_events<Message>(
|
|
menu: &mut Menu<'_, Message>,
|
|
delta: mouse::ScrollDelta,
|
|
overlay_cursor: Point,
|
|
viewport_size: Size,
|
|
overlay_offset: Vector,
|
|
) -> event::Status
|
|
where
|
|
Message: Clone,
|
|
{
|
|
use event::Status::{Captured, Ignored};
|
|
use mouse::ScrollDelta;
|
|
|
|
menu.tree.inner.with_data_mut(|state| {
|
|
let delta_y = match delta {
|
|
ScrollDelta::Lines { y, .. } => y * 60.0,
|
|
ScrollDelta::Pixels { y, .. } => y,
|
|
};
|
|
|
|
let calc_offset_bounds = |menu_state: &MenuState, viewport_size: Size| -> (f32, f32) {
|
|
// viewport space children bounds
|
|
let children_bounds = menu_state.menu_bounds.children_bounds + overlay_offset;
|
|
|
|
let max_offset = (0.0 - children_bounds.y).max(0.0);
|
|
let min_offset =
|
|
(viewport_size.height - (children_bounds.y + children_bounds.height)).min(0.0);
|
|
(max_offset, min_offset)
|
|
};
|
|
let menu_states = state.menu_states.get_mut(menu.depth).unwrap();
|
|
|
|
// update
|
|
if menu_states.is_empty() {
|
|
return Ignored;
|
|
} else if menu_states.len() == 1 {
|
|
let last_ms = &mut menu_states[0];
|
|
|
|
if last_ms.index.is_none() {
|
|
return Captured;
|
|
}
|
|
|
|
let (max_offset, min_offset) = calc_offset_bounds(last_ms, viewport_size);
|
|
last_ms.scroll_offset = (last_ms.scroll_offset + delta_y).clamp(min_offset, max_offset);
|
|
} else {
|
|
// >= 2
|
|
let max_index = menu_states.len() - 1;
|
|
let last_two = &mut menu_states[max_index - 1..=max_index];
|
|
|
|
if last_two[1].index.is_some() {
|
|
// scroll the last one
|
|
let (max_offset, min_offset) = calc_offset_bounds(&last_two[1], viewport_size);
|
|
last_two[1].scroll_offset =
|
|
(last_two[1].scroll_offset + delta_y).clamp(min_offset, max_offset);
|
|
} else {
|
|
if !last_two[0]
|
|
.menu_bounds
|
|
.children_bounds
|
|
.contains(overlay_cursor)
|
|
{
|
|
return Captured;
|
|
}
|
|
|
|
// scroll the second last one
|
|
let (max_offset, min_offset) = calc_offset_bounds(&last_two[0], viewport_size);
|
|
let scroll_offset =
|
|
(last_two[0].scroll_offset + delta_y).clamp(min_offset, max_offset);
|
|
let clamped_delta_y = scroll_offset - last_two[0].scroll_offset;
|
|
last_two[0].scroll_offset = scroll_offset;
|
|
|
|
// update the bounds of the last one
|
|
last_two[1].menu_bounds.parent_bounds.y += clamped_delta_y;
|
|
last_two[1].menu_bounds.children_bounds.y += clamped_delta_y;
|
|
last_two[1].menu_bounds.check_bounds.y += clamped_delta_y;
|
|
}
|
|
}
|
|
Captured
|
|
})
|
|
}
|
|
|
|
#[allow(clippy::pedantic)]
|
|
/// Returns (children_size, child_positions, child_sizes)
|
|
fn get_children_layout<Message>(
|
|
menu_tree: &MenuTree<Message>,
|
|
renderer: &crate::Renderer,
|
|
item_width: ItemWidth,
|
|
item_height: ItemHeight,
|
|
tree: &mut [Tree],
|
|
) -> (Size, Vec<f32>, Vec<Size>) {
|
|
let width = match item_width {
|
|
ItemWidth::Uniform(u) => f32::from(u),
|
|
ItemWidth::Static(s) => f32::from(menu_tree.width.unwrap_or(s)),
|
|
};
|
|
|
|
let child_sizes: Vec<Size> = match item_height {
|
|
ItemHeight::Uniform(u) => {
|
|
let count = menu_tree.children.len();
|
|
(0..count).map(|_| Size::new(width, f32::from(u))).collect()
|
|
}
|
|
ItemHeight::Static(s) => menu_tree
|
|
.children
|
|
.iter()
|
|
.map(|mt| Size::new(width, f32::from(mt.height.unwrap_or(s))))
|
|
.collect(),
|
|
ItemHeight::Dynamic(d) => menu_tree
|
|
.children
|
|
.iter()
|
|
.map(|mt| {
|
|
mt.item
|
|
.element
|
|
.with_data(|w| match w.as_widget().size().height {
|
|
Length::Fixed(f) => Size::new(width, f),
|
|
Length::Shrink => {
|
|
let l_height = w
|
|
.as_widget()
|
|
.layout(
|
|
&mut tree[mt.index],
|
|
renderer,
|
|
&Limits::new(Size::ZERO, Size::new(width, f32::MAX)),
|
|
)
|
|
.size()
|
|
.height;
|
|
|
|
let height = if (f32::MAX - l_height) < 0.001 {
|
|
f32::from(d)
|
|
} else {
|
|
l_height
|
|
};
|
|
|
|
Size::new(width, height)
|
|
}
|
|
_ => mt.height.map_or_else(
|
|
|| Size::new(width, f32::from(d)),
|
|
|h| Size::new(width, f32::from(h)),
|
|
),
|
|
})
|
|
})
|
|
.collect(),
|
|
};
|
|
|
|
let max_index = menu_tree.children.len() - 1;
|
|
let child_positions: Vec<f32> = std::iter::once(0.0)
|
|
.chain(child_sizes[0..max_index].iter().scan(0.0, |acc, x| {
|
|
*acc += x.height;
|
|
Some(*acc)
|
|
}))
|
|
.collect();
|
|
|
|
let height = child_sizes.iter().fold(0.0, |acc, x| acc + x.height);
|
|
|
|
(Size::new(width, height), child_positions, child_sizes)
|
|
}
|
|
|
|
fn search_bound(
|
|
default: usize,
|
|
default_left: usize,
|
|
default_right: usize,
|
|
bound: f32,
|
|
positions: &[f32],
|
|
sizes: &[Size],
|
|
) -> usize {
|
|
// binary search
|
|
let mut left = default_left;
|
|
let mut right = default_right;
|
|
|
|
let mut index = default;
|
|
while left != right {
|
|
let m = ((left + right) / 2) + 1;
|
|
if positions[m] > bound {
|
|
right = m - 1;
|
|
} else {
|
|
left = m;
|
|
}
|
|
}
|
|
// let height = f32::from(menu_tree.children[left].height.unwrap_or(default_height));
|
|
let height = sizes[left].height;
|
|
if positions[left] + height > bound {
|
|
index = left;
|
|
}
|
|
index
|
|
}
|