leyoda/libcosmic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

wip

Browse source
This commit is contained in:
Ashley Wulber 2025-04-24 18:24:10 -04:00
parent 6fb4a4a43e
commit 4fcd09d690
No known key found for this signature in database
GPG key ID: 5216D4F46A90A820
10 changed files with 999 additions and 763 deletions
Download patch file Download diff file Expand all files Collapse all files

51
src/widget/context_menu.rs
View file

@ -13,17 +13,19 @@ use iced_core::widget::{Tree, Widget, tree};
use iced_core::{Length, Point, Size, event, mouse, touch}; use iced_core::{Length, Point, Size, event, mouse, touch};
use std::collections::HashSet; use std::collections::HashSet;
use super::dropdown::menu::State;
/// A context menu is a menu in a graphical user interface that appears upon user interaction, such as a right-click mouse operation. /// A context menu is a menu in a graphical user interface that appears upon user interaction, such as a right-click mouse operation.
pub fn context_menu<'a, Message: 'a>( pub fn context_menu<Message: 'static + Clone>(
content: impl Into<crate::Element<'a, Message>> + 'a, content: impl Into<crate::Element<'static, Message>> + 'static,
// on_context: Message, // on_context: Message,
context_menu: Option<Vec<menu::Tree<'a, Message>>>, context_menu: Option<Vec<menu::Tree<Message>>>,
) -> ContextMenu<'a, Message> { ) -> ContextMenu<'static, Message> {
let mut this = ContextMenu { let mut this = ContextMenu {
content: content.into(), content: content.into(),
context_menu: context_menu.map(|menus| { context_menu: context_menu.map(|menus| {
vec![menu::Tree::with_children( vec![menu::Tree::with_children(
crate::widget::row::<'static, Message>(), crate::Element::from(crate::widget::row::<'static, Message>()),
menus, menus,
)] )]
}), }),
@ -43,10 +45,12 @@ pub struct ContextMenu<'a, Message> {
#[setters(skip)] #[setters(skip)]
content: crate::Element<'a, Message>, content: crate::Element<'a, Message>,
#[setters(skip)] #[setters(skip)]
context_menu: Option<Vec<menu::Tree<'a, Message>>>, context_menu: Option<Vec<menu::Tree<Message>>>,
} }
impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextMenu<'_, Message> { impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
for ContextMenu<'_, Message>
{
fn tag(&self) -> tree::Tag { fn tag(&self) -> tree::Tag {
tree::Tag::of::<LocalState>() tree::Tag::of::<LocalState>()
} }
@ -56,6 +60,7 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
tree::State::new(LocalState { tree::State::new(LocalState {
context_cursor: Point::default(), context_cursor: Point::default(),
fingers_pressed: Default::default(), fingers_pressed: Default::default(),
menu_state: Default::default(),
}) })
} }
@ -75,7 +80,7 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
let flat = root let flat = root
.flattern() .flattern()
.iter() .iter()
.map(|mt| Tree::new(mt.item.as_widget())) .map(|mt| Tree::new(mt.item.clone()))
.collect(); .collect();
tree.children = flat; tree.children = flat;
tree tree
@ -183,10 +188,12 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
&& (right_button_released(&event) || (touch_lifted(&event) && fingers_pressed == 2)) && (right_button_released(&event) || (touch_lifted(&event) && fingers_pressed == 2))
{ {
state.context_cursor = cursor.position().unwrap_or_default(); state.context_cursor = cursor.position().unwrap_or_default();
let menu_state = tree.children[1].state.downcast_mut::<MenuBarState>(); let menu_state = tree.children[1].state.downcast_mut::<MenuBarState>();
menu_state.open = true;
menu_state.view_cursor = cursor; menu_state.inner.with_data_mut(|state| {
state.open = true;
state.view_cursor = cursor;
});
return event::Status::Captured; return event::Status::Captured;
} }
@ -212,23 +219,28 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
translation: Vector, translation: Vector,
) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, crate::Renderer>> { ) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
let state = tree.state.downcast_ref::<LocalState>(); let state = tree.state.downcast_ref::<LocalState>();
let menu_state = state.menu_state.clone();
let Some(context_menu) = self.context_menu.as_mut() else { let Some(context_menu) = self.context_menu.as_mut() else {
return None; return None;
}; };
if !tree.children[1].state.downcast_ref::<MenuBarState>().open { if !tree.children[1]
.state
.downcast_ref::<MenuBarState>()
.inner
.with_data(|state| state.open)
{
return None; return None;
} }
let mut bounds = layout.bounds(); let mut bounds = layout.bounds();
bounds.x = state.context_cursor.x; bounds.x = state.context_cursor.x;
bounds.y = state.context_cursor.y; bounds.y = state.context_cursor.y;
Some( Some(
crate::widget::menu::Menu { crate::widget::menu::Menu {
tree: &mut tree.children[1], tree: menu_state,
menu_roots: context_menu, menu_roots: std::borrow::Cow::Borrowed(context_menu),
bounds_expand: 16, bounds_expand: 16,
menu_overlays_parent: true, menu_overlays_parent: true,
close_condition: CloseCondition { close_condition: CloseCondition {
@ -243,7 +255,7 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
cross_offset: 0, cross_offset: 0,
root_bounds_list: vec![bounds], root_bounds_list: vec![bounds],
path_highlight: Some(PathHighlight::MenuActive), path_highlight: Some(PathHighlight::MenuActive),
style: &crate::theme::menu_bar::MenuBarStyle::Default, style: std::borrow::Cow::Borrowed(&crate::theme::menu_bar::MenuBarStyle::Default),
position: Point::new(translation.x, translation.y), position: Point::new(translation.x, translation.y),
} }
.overlay(), .overlay(),
@ -263,8 +275,10 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
} }
} }
impl<'a, Message: Clone + 'a> From<ContextMenu<'a, Message>> for crate::Element<'a, Message> { impl<'a, Message: Clone + 'static> From<ContextMenu<'static, Message>>
fn from(widget: ContextMenu<'a, Message>) -> Self { for crate::Element<'static, Message>
{
fn from(widget: ContextMenu<'static, Message>) -> Self {
Self::new(widget) Self::new(widget)
} }
} }
@ -283,4 +297,5 @@ fn touch_lifted(event: &Event) -> bool {
pub struct LocalState { pub struct LocalState {
context_cursor: Point, context_cursor: Point,
fingers_pressed: HashSet<Finger>, fingers_pressed: HashSet<Finger>,
menu_state: MenuBarState,
} }

171
src/widget/menu/flex.rs
View file

@ -1,12 +1,14 @@
// From iced_aw, license MIT // From iced_aw, license MIT
use iced_core::widget::Tree; use iced_core::{Widget, widget::Tree};
use iced_widget::core::{ use iced_widget::core::{
Alignment, Element, Padding, Point, Size, Alignment, Element, Padding, Point, Size,
layout::{Limits, Node}, layout::{Limits, Node},
renderer, renderer,
}; };
use crate::widget::RcElementWrapper;
/// The main axis of a flex layout. /// The main axis of a flex layout.
#[derive(Debug)] #[derive(Debug)]
pub enum Axis { pub enum Axis {
@ -217,3 +219,170 @@ where
Node::with_children(size.expand(padding), nodes) Node::with_children(size.expand(padding), nodes)
} }
/// Computes the flex layout with the given axis and limits, applying spacing,
/// padding and alignment to the items as needed.
///
/// It returns a new layout [`Node`].
pub fn resolve_wrapper<'a, Message>(
axis: &Axis,
renderer: &crate::Renderer,
limits: &Limits,
padding: Padding,
spacing: f32,
align_items: Alignment,
items: &[&RcElementWrapper<Message>],
tree: &mut [&mut Tree],
) -> Node {
let limits = limits.shrink(padding);
let total_spacing = spacing * items.len().saturating_sub(1) as f32;
let max_cross = axis.cross(limits.max());
let mut fill_sum = 0;
let mut cross = axis.cross(limits.min()).max(axis.cross(Size::INFINITY));
let mut available = axis.main(limits.max()) - total_spacing;
let mut nodes: Vec<Node> = Vec::with_capacity(items.len());
nodes.resize(items.len(), Node::default());
if align_items == Alignment::Center {
let mut fill_cross = axis.cross(limits.min());
for (child, tree) in items.iter().zip(tree.iter_mut()) {
let c_size = child.size();
let cross_fill_factor = match axis {
Axis::Horizontal => c_size.height,
Axis::Vertical => c_size.width,
}
.fill_factor();
if cross_fill_factor == 0 {
let (max_width, max_height) = axis.pack(available, max_cross);
let child_limits = Limits::new(Size::ZERO, Size::new(max_width, max_height));
let layout = child.layout(tree, renderer, &child_limits);
let size = layout.size();
fill_cross = fill_cross.max(axis.cross(size));
}
}
cross = fill_cross;
}
for (i, (child, tree)) in items.iter().zip(tree.iter_mut()).enumerate() {
let c_size = child.size();
let fill_factor = match axis {
Axis::Horizontal => c_size.width,
Axis::Vertical => c_size.height,
}
.fill_factor();
if fill_factor == 0 {
let (min_width, min_height) = if align_items == Alignment::Center {
axis.pack(0.0, cross)
} else {
axis.pack(0.0, 0.0)
};
let (max_width, max_height) = if align_items == Alignment::Center {
axis.pack(available, cross)
} else {
axis.pack(available, max_cross)
};
let child_limits = Limits::new(
Size::new(min_width, min_height),
Size::new(max_width, max_height),
);
let layout = child.layout(tree, renderer, &child_limits);
let size = layout.size();
available -= axis.main(size);
if align_items != Alignment::Center {
cross = cross.max(axis.cross(size));
}
nodes[i] = layout;
} else {
fill_sum += fill_factor;
}
}
let remaining = available.max(0.0);
for (i, (child, tree)) in items.iter().zip(tree.iter_mut()).enumerate() {
let c_size = child.size();
let fill_factor = match axis {
Axis::Horizontal => c_size.width,
Axis::Vertical => c_size.height,
}
.fill_factor();
if fill_factor != 0 {
let max_main = remaining * f32::from(fill_factor) / f32::from(fill_sum);
let min_main = if max_main.is_infinite() {
0.0
} else {
max_main
};
let (min_width, min_height) = if align_items == Alignment::Center {
axis.pack(min_main, cross)
} else {
axis.pack(min_main, axis.cross(limits.min()))
};
let (max_width, max_height) = if align_items == Alignment::Center {
axis.pack(max_main, cross)
} else {
axis.pack(max_main, max_cross)
};
let child_limits = Limits::new(
Size::new(min_width, min_height),
Size::new(max_width, max_height),
);
let layout = child.layout(tree, renderer, &child_limits);
if align_items != Alignment::Center {
cross = cross.max(axis.cross(layout.size()));
}
nodes[i] = layout;
}
}
let pad = axis.pack(padding.left, padding.top);
let mut main = pad.0;
for (i, node) in nodes.iter_mut().enumerate() {
if i > 0 {
main += spacing;
}
let (x, y) = axis.pack(main, pad.1);
let node_ = node.clone().move_to(Point::new(x, y));
let node_ = match axis {
Axis::Horizontal => node_.align(Alignment::Start, align_items, Size::new(0.0, cross)),
Axis::Vertical => node_.align(align_items, Alignment::Start, Size::new(cross, 0.0)),
};
let size = node_.bounds().size();
*node = node_;
main += axis.main(size);
}
let (width, height) = axis.pack(main - pad.0, cross);
let size = limits.resolve(width, height, Size::new(width, height));
Node::with_children(size.expand(padding), nodes)
}

219
src/widget/menu/menu_bar.rs
View file

@ -7,26 +7,42 @@ use super::{
}, },
menu_tree::MenuTree, menu_tree::MenuTree,
}; };
use crate::style::menu_bar::StyleSheet; use crate::{
Renderer,
style::menu_bar::StyleSheet,
widget::{
RcWrapper,
dropdown::menu::{self, State},
},
};
use iced::{Point, Vector}; use iced::{Point, Vector, window};
use iced_core::Border; use iced_core::Border;
use iced_widget::core::{ use iced_widget::core::{
Alignment, Clipboard, Element, Layout, Length, Padding, Rectangle, Shell, Widget, event, Alignment, Clipboard, Element, Layout, Length, Padding, Rectangle, Shell, Widget, event,
layout::{Limits, Node}, layout::{Limits, Node},
mouse::{self, Cursor}, mouse::{self, Cursor},
overlay, renderer, touch, overlay,
renderer::{self, Renderer as IcedRenderer},
touch,
widget::{Tree, tree}, widget::{Tree, tree},
}; };
/// A `MenuBar` collects `MenuTree`s and handles all the layout, event processing, and drawing. /// A `MenuBar` collects `MenuTree`s and handles all the layout, event processing, and drawing.
pub fn menu_bar<Message, Renderer: iced_core::Renderer>( pub fn menu_bar<Message>(menu_roots: Vec<MenuTree<Message>>) -> MenuBar<Message>
menu_roots: Vec<MenuTree<Message, Renderer>>, where
) -> MenuBar<Message, Renderer> { Message: Clone + 'static,
{
MenuBar::new(menu_roots) MenuBar::new(menu_roots)
} }
#[derive(Clone, Default)]
pub(crate) struct MenuBarState { pub(crate) struct MenuBarState {
pub(crate) inner: RcWrapper<MenuBarStateInner>,
}
pub(crate) struct MenuBarStateInner {
pub(crate) tree: Tree,
pub(crate) pressed: bool, pub(crate) pressed: bool,
pub(crate) view_cursor: Cursor, pub(crate) view_cursor: Cursor,
pub(crate) open: bool, pub(crate) open: bool,
@ -35,7 +51,7 @@ pub(crate) struct MenuBarState {
pub(crate) vertical_direction: Direction, pub(crate) vertical_direction: Direction,
pub(crate) menu_states: Vec<MenuState>, pub(crate) menu_states: Vec<MenuState>,
} }
impl MenuBarState { impl MenuBarStateInner {
pub(super) fn get_trimmed_indices(&self) -> impl Iterator<Item = usize> + '_ { pub(super) fn get_trimmed_indices(&self) -> impl Iterator<Item = usize> + '_ {
self.menu_states self.menu_states
.iter() .iter()
@ -49,9 +65,10 @@ impl MenuBarState {
self.menu_states.clear(); self.menu_states.clear();
} }
} }
impl Default for MenuBarState { impl Default for MenuBarStateInner {
fn default() -> Self { fn default() -> Self {
Self { Self {
tree: Tree::empty(),
pressed: false, pressed: false,
view_cursor: Cursor::Available([-0.5, -0.5].into()), view_cursor: Cursor::Available([-0.5, -0.5].into()),
open: false, open: false,
@ -63,11 +80,9 @@ impl Default for MenuBarState {
} }
} }
pub(crate) fn menu_roots_children<Message, Renderer>( pub(crate) fn menu_roots_children<Message>(menu_roots: &Vec<MenuTree<Message>>) -> Vec<Tree>
menu_roots: &Vec<MenuTree<'_, Message, Renderer>>,
) -> Vec<Tree>
where where
Renderer: renderer::Renderer, Message: Clone + 'static,
{ {
/* /*
menu bar menu bar
@ -85,7 +100,7 @@ where
let flat = root let flat = root
.flattern() .flattern()
.iter() .iter()
.map(|mt| Tree::new(mt.item.as_widget())) .map(|mt| Tree::new(mt.item.clone()))
.collect(); .collect();
tree.children = flat; tree.children = flat;
tree tree
@ -94,11 +109,9 @@ where
} }
#[allow(invalid_reference_casting)] #[allow(invalid_reference_casting)]
pub(crate) fn menu_roots_diff<Message, Renderer>( pub(crate) fn menu_roots_diff<Message>(menu_roots: &mut Vec<MenuTree<Message>>, tree: &mut Tree)
menu_roots: &mut Vec<MenuTree<'_, Message, Renderer>>, where
tree: &mut Tree, Message: Clone + 'static,
) where
Renderer: renderer::Renderer,
{ {
if tree.children.len() > menu_roots.len() { if tree.children.len() > menu_roots.len() {
tree.children.truncate(menu_roots.len()); tree.children.truncate(menu_roots.len());
@ -112,7 +125,7 @@ pub(crate) fn menu_roots_diff<Message, Renderer>(
.flattern() .flattern()
.iter() .iter()
.map(|mt| { .map(|mt| {
let widget = mt.item.as_widget(); let widget = &mt.item;
let widget_ptr = widget as *const dyn Widget<Message, crate::Theme, Renderer>; let widget_ptr = widget as *const dyn Widget<Message, crate::Theme, Renderer>;
let widget_ptr_mut = let widget_ptr_mut =
widget_ptr as *mut dyn Widget<Message, crate::Theme, Renderer>; widget_ptr as *mut dyn Widget<Message, crate::Theme, Renderer>;
@ -130,7 +143,7 @@ pub(crate) fn menu_roots_diff<Message, Renderer>(
let flat = root let flat = root
.flattern() .flattern()
.iter() .iter()
.map(|mt| Tree::new(mt.item.as_widget())) .map(|mt| Tree::new(mt.item.clone()))
.collect(); .collect();
tree.children = flat; tree.children = flat;
tree tree
@ -141,10 +154,7 @@ pub(crate) fn menu_roots_diff<Message, Renderer>(
/// A `MenuBar` collects `MenuTree`s and handles all the layout, event processing, and drawing. /// A `MenuBar` collects `MenuTree`s and handles all the layout, event processing, and drawing.
#[allow(missing_debug_implementations)] #[allow(missing_debug_implementations)]
pub struct MenuBar<'a, Message, Renderer = crate::Renderer> pub struct MenuBar<Message> {
where
Renderer: renderer::Renderer,
{
width: Length, width: Length,
height: Length, height: Length,
spacing: f32, spacing: f32,
@ -156,17 +166,20 @@ where
item_width: ItemWidth, item_width: ItemWidth,
item_height: ItemHeight, item_height: ItemHeight,
path_highlight: Option<PathHighlight>, path_highlight: Option<PathHighlight>,
menu_roots: Vec<MenuTree<'a, Message, Renderer>>, menu_roots: Vec<MenuTree<Message>>,
style: <crate::Theme as StyleSheet>::Style, style: <crate::Theme as StyleSheet>::Style,
window_id: window::Id,
#[cfg(feature = "wayland")]
positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner,
} }
impl<'a, Message, Renderer> MenuBar<'a, Message, Renderer> impl<Message> MenuBar<Message>
where where
Renderer: renderer::Renderer, Message: Clone + 'static,
{ {
/// Creates a new [`MenuBar`] with the given menu roots /// Creates a new [`MenuBar`] with the given menu roots
#[must_use] #[must_use]
pub fn new(menu_roots: Vec<MenuTree<'a, Message, Renderer>>) -> Self { pub fn new(menu_roots: Vec<MenuTree<Message>>) -> Self {
let mut menu_roots = menu_roots; let mut menu_roots = menu_roots;
menu_roots.iter_mut().for_each(MenuTree::set_index); menu_roots.iter_mut().for_each(MenuTree::set_index);
@ -188,6 +201,9 @@ where
path_highlight: Some(PathHighlight::MenuActive), path_highlight: Some(PathHighlight::MenuActive),
menu_roots, menu_roots,
style: <crate::Theme as StyleSheet>::Style::default(), style: <crate::Theme as StyleSheet>::Style::default(),
window_id: window::Id::NONE,
#[cfg(feature = "wayland")]
positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner::default(),
} }
} }
@ -278,10 +294,31 @@ where
self.width = width; self.width = width;
self self
} }
#[cfg(feature = "wayland")]
pub fn with_positioner(
mut self,
positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner,
) -> Self {
self.positioner = positioner;
self
}
pub fn window_id(mut self, id: window::Id) -> Self {
self.window_id = id;
self
}
pub fn window_id_maybe(mut self, id: Option<window::Id>) -> Self {
if let Some(id) = id {
self.window_id = id;
}
self
}
} }
impl<Message, Renderer> Widget<Message, crate::Theme, Renderer> for MenuBar<'_, Message, Renderer> impl<Message> Widget<Message, crate::Theme, Renderer> for MenuBar<Message>
where where
Renderer: renderer::Renderer, Message: Clone + 'static,
{ {
fn size(&self) -> iced_core::Size<Length> { fn size(&self) -> iced_core::Size<Length> {
iced_core::Size::new(self.width, self.height) iced_core::Size::new(self.width, self.height)
@ -318,7 +355,7 @@ where
.iter_mut() .iter_mut()
.map(|t| &mut t.children[0]) .map(|t| &mut t.children[0])
.collect::<Vec<_>>(); .collect::<Vec<_>>();
flex::resolve( flex::resolve_wrapper(
&flex::Axis::Horizontal, &flex::Axis::Horizontal,
renderer, renderer,
&limits, &limits,
@ -361,12 +398,14 @@ where
match event { match event {
Mouse(ButtonReleased(Left)) | Touch(FingerLifted { .. } | FingerLost { .. }) => { Mouse(ButtonReleased(Left)) | Touch(FingerLifted { .. } | FingerLost { .. }) => {
if state.menu_states.is_empty() && view_cursor.is_over(layout.bounds()) { state.inner.with_data_mut(|state| {
state.view_cursor = view_cursor; if state.menu_states.is_empty() && view_cursor.is_over(layout.bounds()) {
state.open = true; state.view_cursor = view_cursor;
// #[cfg(feature = "wayland")] state.open = true;
// TODO emit Message to open menu // #[cfg(feature = "wayland")]
} // TODO emit Message to open menu
}
});
} }
_ => (), _ => (),
} }
@ -385,49 +424,51 @@ where
) { ) {
let state = tree.state.downcast_ref::<MenuBarState>(); let state = tree.state.downcast_ref::<MenuBarState>();
let cursor_pos = view_cursor.position().unwrap_or_default(); let cursor_pos = view_cursor.position().unwrap_or_default();
let position = if state.open && (cursor_pos.x < 0.0 || cursor_pos.y < 0.0) { state.inner.with_data_mut(|state| {
state.view_cursor let position = if state.open && (cursor_pos.x < 0.0 || cursor_pos.y < 0.0) {
} else { state.view_cursor
view_cursor } else {
}; view_cursor
};
// draw path highlight // draw path highlight
if self.path_highlight.is_some() { if self.path_highlight.is_some() {
let styling = theme.appearance(&self.style); let styling = theme.appearance(&self.style);
if let Some(active) = state.active_root { if let Some(active) = state.active_root {
let active_bounds = layout let active_bounds = layout
.children() .children()
.nth(active) .nth(active)
.expect("Active child not found in menu?") .expect("Active child not found in menu?")
.bounds(); .bounds();
let path_quad = renderer::Quad { let path_quad = renderer::Quad {
bounds: active_bounds, bounds: active_bounds,
border: Border { border: Border {
radius: styling.bar_border_radius.into(), radius: styling.bar_border_radius.into(),
..Default::default() ..Default::default()
}, },
shadow: Default::default(), shadow: Default::default(),
}; };
renderer.fill_quad(path_quad, styling.path); renderer.fill_quad(path_quad, styling.path);
}
} }
}
self.menu_roots self.menu_roots
.iter() .iter()
.zip(&tree.children) .zip(&tree.children)
.zip(layout.children()) .zip(layout.children())
.for_each(|((root, t), lo)| { .for_each(|((root, t), lo)| {
root.item.as_widget().draw( root.item.draw(
&t.children[root.index], &t.children[root.index],
renderer, renderer,
theme, theme,
style, style,
lo, lo,
position, position,
viewport, viewport,
); );
}); });
});
} }
fn overlay<'b>( fn overlay<'b>(
@ -441,14 +482,14 @@ where
// return None; // return None;
let state = tree.state.downcast_ref::<MenuBarState>(); let state = tree.state.downcast_ref::<MenuBarState>();
if !state.open { if state.inner.with_data_mut(|state| !state.open) {
return None; return None;
} };
Some( Some(
Menu { Menu {
tree, tree: state.clone(),
menu_roots: &mut self.menu_roots, menu_roots: std::borrow::Cow::Borrowed(&mut self.menu_roots),
bounds_expand: self.bounds_expand, bounds_expand: self.bounds_expand,
menu_overlays_parent: false, menu_overlays_parent: false,
close_condition: self.close_condition, close_condition: self.close_condition,
@ -459,27 +500,26 @@ where
cross_offset: self.cross_offset, cross_offset: self.cross_offset,
root_bounds_list: layout.children().map(|lo| lo.bounds()).collect(), root_bounds_list: layout.children().map(|lo| lo.bounds()).collect(),
path_highlight: self.path_highlight, path_highlight: self.path_highlight,
style: &self.style, style: std::borrow::Cow::Borrowed(&self.style),
position: Point::new(translation.x, translation.y), position: Point::new(translation.x, translation.y),
} }
.overlay(), .overlay(),
) )
} }
} }
impl<'a, Message, Renderer> From<MenuBar<'a, Message, Renderer>>
for Element<'a, Message, crate::Theme, Renderer> impl<'a, Message> From<MenuBar<Message>> for Element<'a, Message, crate::Theme, Renderer>
where where
Message: 'a, Message: Clone + 'static,
Renderer: 'a + renderer::Renderer,
{ {
fn from(value: MenuBar<'a, Message, Renderer>) -> Self { fn from(value: MenuBar<Message>) -> Self {
Self::new(value) Self::new(value)
} }
} }
#[allow(unused_results, clippy::too_many_arguments)] #[allow(unused_results, clippy::too_many_arguments)]
fn process_root_events<Message, Renderer>( fn process_root_events<Message>(
menu_roots: &mut [MenuTree<'_, Message, Renderer>], menu_roots: &mut [MenuTree<Message>],
view_cursor: Cursor, view_cursor: Cursor,
tree: &mut Tree, tree: &mut Tree,
event: &event::Event, event: &event::Event,
@ -490,7 +530,6 @@ fn process_root_events<Message, Renderer>(
viewport: &Rectangle, viewport: &Rectangle,
) -> event::Status ) -> event::Status
where where
Renderer: renderer::Renderer,
{ {
menu_roots menu_roots
.iter_mut() .iter_mut()
@ -498,7 +537,7 @@ where
.zip(layout.children()) .zip(layout.children())
.map(|((root, t), lo)| { .map(|((root, t), lo)| {
// assert!(t.tag == tree::Tag::stateless()); // assert!(t.tag == tree::Tag::stateless());
root.item.as_widget_mut().on_event( root.item.on_event(
&mut t.children[root.index], &mut t.children[root.index],
event.clone(), event.clone(),
lo, lo,

1124
src/widget/menu/menu_inner.rs
View file

File diff suppressed because it is too large Load diff

105
src/widget/menu/menu_tree.rs
View file

@ -11,7 +11,7 @@ use iced_widget::core::{Element, renderer};
use crate::iced_core::{Alignment, Length}; use crate::iced_core::{Alignment, Length};
use crate::widget::menu::action::MenuAction; use crate::widget::menu::action::MenuAction;
use crate::widget::menu::key_bind::KeyBind; use crate::widget::menu::key_bind::KeyBind;
use crate::widget::{Button, icon}; use crate::widget::{Button, RcElementWrapper, icon};
use crate::{theme, widget}; use crate::{theme, widget};
/// Nested menu is essentially a tree of items, a menu is a collection of items /// Nested menu is essentially a tree of items, a menu is a collection of items
@ -23,27 +23,25 @@ use crate::{theme, widget};
/// but there's no need to explicitly distinguish them here, if a menu tree /// but there's no need to explicitly distinguish them here, if a menu tree
/// has children, it's a menu, otherwise it's an item /// has children, it's a menu, otherwise it's an item
#[allow(missing_debug_implementations)] #[allow(missing_debug_implementations)]
pub struct MenuTree<'a, Message, Renderer = crate::Renderer> { #[derive(Clone)]
pub struct MenuTree<Message> {
/// The menu tree will be flatten into a vector to build a linear widget tree, /// The menu tree will be flatten into a vector to build a linear widget tree,
/// the `index` field is the index of the item in that vector /// the `index` field is the index of the item in that vector
pub(crate) index: usize, pub(crate) index: usize,
/// The item of the menu tree /// The item of the menu tree
pub(crate) item: Element<'a, Message, crate::Theme, Renderer>, pub(crate) item: RcElementWrapper<Message>,
/// The children of the menu tree /// The children of the menu tree
pub(crate) children: Vec<MenuTree<'a, Message, Renderer>>, pub(crate) children: Vec<MenuTree<Message>>,
/// The width of the menu tree /// The width of the menu tree
pub(crate) width: Option<u16>, pub(crate) width: Option<u16>,
/// The height of the menu tree /// The height of the menu tree
pub(crate) height: Option<u16>, pub(crate) height: Option<u16>,
} }
impl<'a, Message, Renderer> MenuTree<'a, Message, Renderer> impl<Message: Clone + 'static> MenuTree<Message> {
where
Renderer: renderer::Renderer,
{
/// Create a new menu tree from a widget /// Create a new menu tree from a widget
pub fn new(item: impl Into<Element<'a, Message, crate::Theme, Renderer>>) -> Self { pub fn new(item: impl Into<RcElementWrapper<Message>>) -> Self {
Self { Self {
index: 0, index: 0,
item: item.into(), item: item.into(),
@ -55,8 +53,8 @@ where
/// Create a menu tree from a widget and a vector of sub trees /// Create a menu tree from a widget and a vector of sub trees
pub fn with_children( pub fn with_children(
item: impl Into<Element<'a, Message, crate::Theme, Renderer>>, item: impl Into<RcElementWrapper<Message>>,
children: Vec<impl Into<MenuTree<'a, Message, Renderer>>>, children: Vec<impl Into<MenuTree<Message>>>,
) -> Self { ) -> Self {
Self { Self {
index: 0, index: 0,
@ -92,7 +90,7 @@ where
/// Set the index of each item /// Set the index of each item
pub(crate) fn set_index(&mut self) { pub(crate) fn set_index(&mut self) {
/// inner counting function. /// inner counting function.
fn rec<Message, Renderer>(mt: &mut MenuTree<'_, Message, Renderer>, count: &mut usize) { fn rec<Message: Clone + 'static>(mt: &mut MenuTree<Message>, count: &mut usize) {
// keep items under the same menu line up // keep items under the same menu line up
mt.children.iter_mut().for_each(|c| { mt.children.iter_mut().for_each(|c| {
c.index = *count; c.index = *count;
@ -109,18 +107,18 @@ where
} }
/// Flatten the menu tree /// Flatten the menu tree
pub(crate) fn flattern(&'a self) -> Vec<&Self> { pub(crate) fn flattern(&self) -> Vec<&Self> {
/// Inner flattening function /// Inner flattening function
fn rec<'a, Message, Renderer>( fn rec<'a, Message: Clone + 'static>(
mt: &'a MenuTree<'a, Message, Renderer>, mt: &'a MenuTree<Message>,
flat: &mut Vec<&MenuTree<'a, Message, Renderer>>, flat: &mut Vec<&'a MenuTree<Message>>,
) { ) {
mt.children.iter().for_each(|c| { mt.children.iter().for_each(|c| {
flat.push(c); flat.push(c);
}); });
mt.children.iter().for_each(|c| { mt.children.iter().for_each(|c| {
rec(c, flat); rec(&c, flat);
}); });
} }
@ -132,13 +130,9 @@ where
} }
} }
impl<'a, Message, Renderer> From<Element<'a, Message, crate::Theme, Renderer>> impl<Message: Clone + 'static> From<crate::Element<'static, Message>> for MenuTree<Message> {
for MenuTree<'a, Message, Renderer> fn from(value: crate::Element<'static, Message>) -> Self {
where Self::new(RcElementWrapper::new(value))
Renderer: renderer::Renderer,
{
fn from(value: Element<'a, Message, crate::Theme, Renderer>) -> Self {
Self::new(value)
} }
} }
@ -160,6 +154,7 @@ where
.class(theme::Button::MenuItem) .class(theme::Button::MenuItem)
} }
#[derive(Clone)]
/// Represents a menu item that performs an action when selected or a separator between menu items. /// Represents a menu item that performs an action when selected or a separator between menu items.
/// ///
/// - `Action` - Represents a menu item that performs an action when selected. /// - `Action` - Represents a menu item that performs an action when selected.
@ -216,19 +211,13 @@ where
/// # Returns /// # Returns
/// - A vector of `MenuTree`. /// - A vector of `MenuTree`.
pub fn menu_items< pub fn menu_items<
'a,
A: MenuAction<Message = Message>, A: MenuAction<Message = Message>,
L: Into<Cow<'static, str>> + 'static, L: Into<Cow<'static, str>> + 'static,
Message, Message: 'static + std::clone::Clone,
Renderer: renderer::Renderer + 'a,
>( >(
key_binds: &HashMap<KeyBind, A>, key_binds: &HashMap<KeyBind, A>,
children: Vec<MenuItem<A, L>>, children: Vec<MenuItem<A, L>>,
) -> Vec<MenuTree<'a, Message, Renderer>> ) -> Vec<MenuTree<Message>> {
where
Element<'a, Message, crate::Theme, Renderer>: From<widget::button::Button<'a, Message>>,
Message: 'a + Clone,
{
fn find_key<A: MenuAction>(action: &A, key_binds: &HashMap<KeyBind, A>) -> String { fn find_key<A: MenuAction>(action: &A, key_binds: &HashMap<KeyBind, A>) -> String {
for (key_bind, key_action) in key_binds { for (key_bind, key_action) in key_binds {
if action == key_action { if action == key_action {
@ -263,7 +252,7 @@ where
let menu_button = menu_button(items).on_press(action.message()); let menu_button = menu_button(items).on_press(action.message());
trees.push(MenuTree::<Message, Renderer>::new(menu_button)); trees.push(MenuTree::<Message>::from(Element::from(menu_button)));
} }
MenuItem::ButtonDisabled(label, icon, action) => { MenuItem::ButtonDisabled(label, icon, action) => {
let key = find_key(&action, key_binds); let key = find_key(&action, key_binds);
@ -281,7 +270,7 @@ where
let menu_button = menu_button(items); let menu_button = menu_button(items);
trees.push(MenuTree::<Message, Renderer>::new(menu_button)); trees.push(MenuTree::<Message>::from(Element::from(menu_button)));
} }
MenuItem::CheckBox(label, icon, value, action) => { MenuItem::CheckBox(label, icon, value, action) => {
let key = find_key(&action, key_binds); let key = find_key(&action, key_binds);
@ -311,36 +300,40 @@ where
items.insert(2, widget::icon::icon(icon).size(14).into()); items.insert(2, widget::icon::icon(icon).size(14).into());
} }
trees.push(MenuTree::new(menu_button(items).on_press(action.message()))); trees.push(MenuTree::from(Element::from(
menu_button(items).on_press(action.message()),
)));
} }
MenuItem::Folder(label, children) => { MenuItem::Folder(label, children) => {
trees.push(MenuTree::<Message, Renderer>::with_children( trees.push(MenuTree::<Message>::with_children(
menu_button(vec![ RcElementWrapper::new(crate::Element::from(
widget::text(label).into(), menu_button::<'static, _>(vec![
widget::horizontal_space().into(), widget::text(label).into(),
widget::icon::from_name("pan-end-symbolic") widget::horizontal_space().into(),
.size(16) widget::icon::from_name("pan-end-symbolic")
.icon() .size(16)
.into(), .icon()
]) .into(),
.class( ])
// Menu folders have no on_press so they take on the disabled style by default .class(
if children.is_empty() { // Menu folders have no on_press so they take on the disabled style by default
// This will make the folder use the disabled style if it has no children if children.is_empty() {
theme::Button::MenuItem // This will make the folder use the disabled style if it has no children
} else { theme::Button::MenuItem
// This will make the folder use the enabled style if it has children } else {
theme::Button::MenuFolder // This will make the folder use the enabled style if it has children
}, theme::Button::MenuFolder
), },
),
)),
menu_items(key_binds, children), menu_items(key_binds, children),
)); ));
} }
MenuItem::Divider => { MenuItem::Divider => {
if i != size - 1 { if i != size - 1 {
trees.push(MenuTree::<Message, Renderer>::new( trees.push(MenuTree::<Message>::from(Element::from(
widget::divider::horizontal::light(), widget::divider::horizontal::light(),
)); )));
} }
} }
} }

2
src/widget/nav_bar.rs
View file

@ -69,7 +69,7 @@ impl<'a, Message: Clone + 'static> NavBar<'a, Message> {
} }
#[inline] #[inline]
pub fn context_menu(mut self, context_menu: Option<Vec<menu::Tree<'a, Message>>>) -> Self { pub fn context_menu(mut self, context_menu: Option<Vec<menu::Tree<Message>>>) -> Self {
self.segmented_button = self.segmented_button.context_menu(context_menu); self.segmented_button = self.segmented_button.context_menu(context_menu);
self self
} }

37
src/widget/segmented_button/widget.rs
View file

@ -127,7 +127,7 @@ where
pub(super) style: Style, pub(super) style: Style,
/// The context menu to display when a context is activated /// The context menu to display when a context is activated
#[setters(skip)] #[setters(skip)]
pub(super) context_menu: Option<Vec<menu::Tree<'a, Message, crate::Renderer>>>, pub(super) context_menu: Option<Vec<menu::Tree<Message>>>,
/// Emits the ID of the item that was activated. /// Emits the ID of the item that was activated.
#[setters(skip)] #[setters(skip)]
pub(super) on_activate: Option<Box<dyn Fn(Entity) -> Message + 'static>>, pub(super) on_activate: Option<Box<dyn Fn(Entity) -> Message + 'static>>,
@ -198,13 +198,13 @@ where
} }
} }
pub fn context_menu(mut self, context_menu: Option<Vec<menu::Tree<'a, Message>>>) -> Self pub fn context_menu(mut self, context_menu: Option<Vec<menu::Tree<Message>>>) -> Self
where where
Message: 'static, Message: Clone + 'static,
{ {
self.context_menu = context_menu.map(|menus| { self.context_menu = context_menu.map(|menus| {
vec![menu::Tree::with_children( vec![menu::Tree::with_children(
crate::widget::row::<'static, Message>(), crate::Element::from(crate::widget::row::<'static, Message>()),
menus, menus,
)] )]
}); });
@ -577,6 +577,7 @@ where
fn state(&self) -> tree::State { fn state(&self) -> tree::State {
#[allow(clippy::default_trait_access)] #[allow(clippy::default_trait_access)]
tree::State::new(LocalState { tree::State::new(LocalState {
menu_state: Default::default(),
paragraphs: SecondaryMap::new(), paragraphs: SecondaryMap::new(),
text_hashes: SecondaryMap::new(), text_hashes: SecondaryMap::new(),
buttons_visible: Default::default(), buttons_visible: Default::default(),
@ -955,8 +956,10 @@ where
let menu_state = let menu_state =
tree.children[0].state.downcast_mut::<MenuBarState>(); tree.children[0].state.downcast_mut::<MenuBarState>();
menu_state.open = true; menu_state.inner.with_data_mut(|data| {
menu_state.view_cursor = cursor_position; data.open = true;
data.view_cursor = cursor_position;
});
shell.publish(on_context(key)); shell.publish(on_context(key));
return event::Status::Captured; return event::Status::Captured;
@ -1346,7 +1349,11 @@ where
let center_y = bounds.center_y(); let center_y = bounds.center_y();
let menu_open = !tree.children.is_empty() let menu_open = !tree.children.is_empty()
&& tree.children[0].state.downcast_ref::<MenuBarState>().open; && tree.children[0]
.state
.downcast_ref::<MenuBarState>()
.inner
.with_data(|data| data.open);
let key_is_active = self.model.is_active(key); let key_is_active = self.model.is_active(key);
let key_is_hovered = self.button_is_hovered(state, key); let key_is_hovered = self.button_is_hovered(state, key);
@ -1556,6 +1563,7 @@ where
translation: Vector, translation: Vector,
) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, Renderer>> { ) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, Renderer>> {
let state = tree.state.downcast_ref::<LocalState>(); let state = tree.state.downcast_ref::<LocalState>();
let menu_state = state.menu_state.clone();
let Some(entity) = state.show_context else { let Some(entity) = state.show_context else {
return None; return None;
@ -1575,7 +1583,12 @@ where
return None; return None;
}; };
if !tree.children[0].state.downcast_ref::<MenuBarState>().open { if !tree.children[0]
.state
.downcast_ref::<MenuBarState>()
.inner
.with_data(|data| data.open)
{
return None; return None;
} }
@ -1584,8 +1597,8 @@ where
Some( Some(
crate::widget::menu::Menu { crate::widget::menu::Menu {
tree: &mut tree.children[0], tree: menu_state,
menu_roots: context_menu, menu_roots: std::borrow::Cow::Borrowed(context_menu),
bounds_expand: 16, bounds_expand: 16,
menu_overlays_parent: true, menu_overlays_parent: true,
close_condition: CloseCondition { close_condition: CloseCondition {
@ -1600,7 +1613,7 @@ where
cross_offset: 0, cross_offset: 0,
root_bounds_list: vec![bounds], root_bounds_list: vec![bounds],
path_highlight: Some(PathHighlight::MenuActive), path_highlight: Some(PathHighlight::MenuActive),
style: &crate::theme::menu_bar::MenuBarStyle::Default, style: std::borrow::Cow::Borrowed(&crate::theme::menu_bar::MenuBarStyle::Default),
position: Point::new(translation.x, translation.y), position: Point::new(translation.x, translation.y),
} }
.overlay(), .overlay(),
@ -1653,6 +1666,8 @@ where
/// State that is maintained by each individual widget. /// State that is maintained by each individual widget.
pub struct LocalState { pub struct LocalState {
/// Menu state
pub(crate) menu_state: MenuBarState,
/// Defines how many buttons to show at a time. /// Defines how many buttons to show at a time.
pub(super) buttons_visible: usize, pub(super) buttons_visible: usize,
/// Button visibility offset, when collapsed. /// Button visibility offset, when collapsed.

15
src/widget/table/widget/compact.rs
View file

@ -44,11 +44,12 @@ where
#[setters(skip)] #[setters(skip)]
pub(super) on_item_mb_right: Option<Box<dyn Fn(Entity) -> Message + 'static>>, pub(super) on_item_mb_right: Option<Box<dyn Fn(Entity) -> Message + 'static>>,
#[setters(skip)] #[setters(skip)]
pub(super) item_context_builder: Box<dyn Fn(&Item) -> Option<Vec<menu::Tree<'a, Message>>>>, pub(super) item_context_builder: Box<dyn Fn(&Item) -> Option<Vec<menu::Tree<Message>>>>,
} }
impl<'a, SelectionMode, Item, Category, Message> impl<SelectionMode, Item, Category, Message>
From<CompactTableView<'a, SelectionMode, Item, Category, Message>> for Element<'a, Message> From<CompactTableView<'static, SelectionMode, Item, Category, Message>>
for Element<'static, Message>
where where
Category: ItemCategory, Category: ItemCategory,
Item: ItemInterface<Category>, Item: ItemInterface<Category>,
@ -56,7 +57,7 @@ where
SelectionMode: Default, SelectionMode: Default,
Message: Clone + 'static, Message: Clone + 'static,
{ {
fn from(val: CompactTableView<'a, SelectionMode, Item, Category, Message>) -> Self { fn from(val: CompactTableView<'static, SelectionMode, Item, Category, Message>) -> Self {
let cosmic_theme::Spacing { space_xxxs, .. } = theme::spacing(); let cosmic_theme::Spacing { space_xxxs, .. } = theme::spacing();
val.model val.model
.iter() .iter()
@ -97,7 +98,7 @@ where
] ]
}) })
.flatten() .flatten()
.collect::<Vec<Element<'a, Message>>>(); .collect::<Vec<Element<'static, Message>>>();
elements.pop(); elements.pop();
elements elements
.apply(widget::row::with_children) .apply(widget::row::with_children)
@ -171,7 +172,7 @@ where
) )
.apply(Element::from) .apply(Element::from)
}) })
.collect::<Vec<Element<'a, Message>>>() .collect::<Vec<Element<'static, Message>>>()
.apply(widget::column::with_children) .apply(widget::column::with_children)
.spacing(val.item_spacing) .spacing(val.item_spacing)
.padding(val.element_padding) .padding(val.element_padding)
@ -247,7 +248,7 @@ where
pub fn item_context<F>(mut self, context_menu_builder: F) -> Self pub fn item_context<F>(mut self, context_menu_builder: F) -> Self
where where
F: Fn(&Item) -> Option<Vec<menu::Tree<'a, Message>>> + 'static, F: Fn(&Item) -> Option<Vec<menu::Tree<Message>>> + 'static,
Message: 'static, Message: 'static,
{ {
self.item_context_builder = Box::new(context_menu_builder); self.item_context_builder = Box::new(context_menu_builder);

25
src/widget/table/widget/standard.rs
View file

@ -51,7 +51,7 @@ where
#[setters(skip)] #[setters(skip)]
pub(super) on_item_mb_right: Option<Box<dyn Fn(Entity) -> Message + 'static>>, pub(super) on_item_mb_right: Option<Box<dyn Fn(Entity) -> Message + 'static>>,
#[setters(skip)] #[setters(skip)]
pub(super) item_context_builder: Box<dyn Fn(&Item) -> Option<Vec<menu::Tree<'a, Message>>>>, pub(super) item_context_builder: Box<dyn Fn(&Item) -> Option<Vec<menu::Tree<Message>>>>,
// Item DND // Item DND
// === Category Interaction === // === Category Interaction ===
@ -64,12 +64,11 @@ where
#[setters(skip)] #[setters(skip)]
pub(super) on_category_mb_right: Option<Box<dyn Fn(Category) -> Message + 'static>>, pub(super) on_category_mb_right: Option<Box<dyn Fn(Category) -> Message + 'static>>,
#[setters(skip)] #[setters(skip)]
pub(super) category_context_builder: pub(super) category_context_builder: Box<dyn Fn(Category) -> Option<Vec<menu::Tree<Message>>>>,
Box<dyn Fn(Category) -> Option<Vec<menu::Tree<'a, Message>>>>,
} }
impl<'a, SelectionMode, Item, Category, Message> impl<SelectionMode, Item, Category, Message>
From<TableView<'a, SelectionMode, Item, Category, Message>> for Element<'a, Message> From<TableView<'static, SelectionMode, Item, Category, Message>> for Element<'static, Message>
where where
Category: ItemCategory, Category: ItemCategory,
Item: ItemInterface<Category>, Item: ItemInterface<Category>,
@ -77,13 +76,13 @@ where
SelectionMode: Default, SelectionMode: Default,
Message: Clone + 'static, Message: Clone + 'static,
{ {
fn from(val: TableView<'a, SelectionMode, Item, Category, Message>) -> Self { fn from(val: TableView<'static, SelectionMode, Item, Category, Message>) -> Self {
// Header row // Header row
let header_row = val let header_row = val
.model .model
.categories .categories
.iter() .iter()
.cloned() .copied()
.map(|category| { .map(|category| {
let cat_context_tree = (val.category_context_builder)(category); let cat_context_tree = (val.category_context_builder)(category);
@ -126,7 +125,7 @@ where
.apply(|mouse_area| widget::context_menu(mouse_area, cat_context_tree)) .apply(|mouse_area| widget::context_menu(mouse_area, cat_context_tree))
.apply(Element::from) .apply(Element::from)
}) })
.collect::<Vec<Element<'a, Message>>>() .collect::<Vec<Element<'static, Message>>>()
.apply(widget::row::with_children) .apply(widget::row::with_children)
.apply(Element::from); .apply(Element::from);
// Build the items // Build the items
@ -167,7 +166,7 @@ where
.align_y(Alignment::Center) .align_y(Alignment::Center)
.apply(Element::from) .apply(Element::from)
}) })
.collect::<Vec<Element<'a, Message>>>() .collect::<Vec<Element<'static, Message>>>()
.apply(widget::row::with_children) .apply(widget::row::with_children)
.apply(container) .apply(container)
.padding(val.item_padding) .padding(val.item_padding)
@ -235,12 +234,12 @@ where
] ]
}) })
.flatten() .flatten()
.collect::<Vec<Element<'a, Message>>>() .collect::<Vec<Element<'static, Message>>>()
}; };
vec![vec![header_row], items_full] vec![vec![header_row], items_full]
.into_iter() .into_iter()
.flatten() .flatten()
.collect::<Vec<Element<'a, Message>>>() .collect::<Vec<Element<'static, Message>>>()
.apply(widget::column::with_children) .apply(widget::column::with_children)
.width(val.width) .width(val.width)
.height(val.height) .height(val.height)
@ -328,7 +327,7 @@ where
pub fn item_context<F>(mut self, context_menu_builder: F) -> Self pub fn item_context<F>(mut self, context_menu_builder: F) -> Self
where where
F: Fn(&Item) -> Option<Vec<menu::Tree<'a, Message>>> + 'static, F: Fn(&Item) -> Option<Vec<menu::Tree<Message>>> + 'static,
Message: 'static, Message: 'static,
{ {
self.item_context_builder = Box::new(context_menu_builder); self.item_context_builder = Box::new(context_menu_builder);
@ -367,7 +366,7 @@ where
pub fn category_context<F>(mut self, context_menu_builder: F) -> Self pub fn category_context<F>(mut self, context_menu_builder: F) -> Self
where where
F: Fn(Category) -> Option<Vec<menu::Tree<'a, Message>>> + 'static, F: Fn(Category) -> Option<Vec<menu::Tree<Message>>> + 'static,
Message: 'static, Message: 'static,
{ {
self.category_context_builder = Box::new(context_menu_builder); self.category_context_builder = Box::new(context_menu_builder);

13
src/widget/wrapper.rs
View file

@ -1,4 +1,5 @@
use std::{ use std::{
borrow::Borrow,
cell::RefCell, cell::RefCell,
rc::Rc, rc::Rc,
thread::{self, ThreadId}, thread::{self, ThreadId},
@ -14,6 +15,12 @@ pub struct RcWrapper<T> {
pub(crate) thread_id: ThreadId, pub(crate) thread_id: ThreadId,
} }
impl<T: Default> Default for RcWrapper<T> {
fn default() -> Self {
Self::new(T::default())
}
}
impl<T> Clone for RcWrapper<T> { impl<T> Clone for RcWrapper<T> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -75,6 +82,12 @@ impl<M> RcElementWrapper<M> {
} }
} }
impl<M: 'static> Borrow<dyn Widget<M, crate::Theme, crate::Renderer>> for RcElementWrapper<M> {
fn borrow(&self) -> &(dyn Widget<M, crate::Theme, crate::Renderer> + 'static) {
self
}
}
impl<M> Widget<M, crate::Theme, crate::Renderer> for RcElementWrapper<M> { impl<M> Widget<M, crate::Theme, crate::Renderer> for RcElementWrapper<M> {
fn size(&self) -> Size<Length> { fn size(&self) -> Size<Length> {
self.element.with_data(|e| e.as_widget().size()) self.element.with_data(|e| e.as_widget().size())