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

feat: menu bar popups

Browse source
This commit is contained in:
Ashley Wulber 2025-06-10 12:22:07 -04:00 • committed by GitHub
parent 5b77f37fde
commit 92ec78ba29
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
24 changed files with 1861 additions and 928 deletions
Download patch file Download diff file Expand all files Collapse all files

1
examples/application/Cargo.toml
View file

@ -25,4 +25,5 @@ features = [
"wgpu",
"single-instance",
"multi-window",
"surface-message",
]

195
examples/application/src/main.rs
View file

@ -46,13 +46,19 @@ impl Page {
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Action {
Hi,
Hi2,
Hi3,
}
impl MenuAction for Action {
type Message = Message;
fn message(&self) -> Message {
Message::Hi
match self {
Action::Hi => Message::Hi,
Action::Hi2 => Message::Hi2,
Action::Hi3 => Message::Hi3,
}
}
}
@ -86,6 +92,8 @@ pub enum Message {
ToggleHide,
Surface(cosmic::surface::Action),
Hi,
Hi2,
Hi3,
}
/// The [`App`] stores application-specific state.
@ -176,6 +184,12 @@ impl cosmic::Application for App {
Message::Hi => {
dbg!("hi");
}
Message::Hi2 => {
dbg!("hi 2");
}
Message::Hi3 => {
dbg!("hi 3");
}
}
Task::none()
}
@ -221,119 +235,80 @@ impl cosmic::Application for App {
}
fn header_start(&self) -> Vec<Element<Self::Message>> {
use cosmic::widget::menu::Tree;
#[cfg(not(feature = "wayland"))]
{
vec![cosmic::widget::menu::bar(vec![
Tree::with_children(
menu::root("hiiiiiiiiiiiiiiiiiii 1"),
menu::items(
&self.keybinds,
vec![menu::Item::Button("hi", None, Action::Hi)],
),
vec![cosmic::widget::responsive_menu_bar().into_element(
self.core(),
&self.keybinds,
MENU_ID.clone(),
Message::Surface,
vec![
(
"hi 1".into(),
vec![
menu::Item::Button("hi 12", None, Action::Hi),
menu::Item::Button("hi 13", None, Action::Hi2),
],
),
Tree::with_children(
menu::root("hiiiiiiiiiiiiiiiiii 2"),
menu::items(
&self.keybinds,
vec![menu::Item::Button("hi 2", None, Action::Hi)],
),
(
"hi 2".into(),
vec![
menu::Item::Button("hi 21", None, Action::Hi),
menu::Item::Button("hi 22", None, Action::Hi2),
menu::Item::Folder(
"nest 3 2 >".into(),
vec![
menu::Item::Button("21", None, Action::Hi),
menu::Item::Button("242", None, Action::Hi2),
menu::Item::Button("2443", None, Action::Hi3),
menu::Item::Folder(
"nest 4 2 >".into(),
vec![
menu::Item::Button("243", None, Action::Hi2),
menu::Item::Button("2444", None, Action::Hi),
],
),
],
),
],
),
Tree::with_children(
menu::root("hiiiiiiiiiiiiiiiiiiiii 3"),
menu::items(
&self.keybinds,
vec![
menu::Item::Button("hi 3", None, Action::Hi),
menu::Item::Button("hi 3 #2", None, Action::Hi),
],
),
(
"hi 3".into(),
vec![
menu::Item::Button("hi 31", None, Action::Hi),
menu::Item::Button("hi 332", None, Action::Hi2),
menu::Item::Button("hi 3333", None, Action::Hi3),
menu::Item::Button("hi 33334", None, Action::Hi3),
menu::Item::Button("hi 333335", None, Action::Hi3),
menu::Item::Button("hi 3333336", None, Action::Hi3),
],
),
Tree::with_children(
menu::root("hi 3"),
menu::items(
&self.keybinds,
vec![
menu::Item::Button("hi 3", None, Action::Hi),
menu::Item::Button("hi 3 #2", None, Action::Hi),
menu::Item::Button("hi 3 #3", None, Action::Hi),
],
),
(
"hiiiiiiiiiiiiiiiiiii 4".into(),
vec![
menu::Item::Button("hi 4", None, Action::Hi),
menu::Item::Button("hi 44", None, Action::Hi2),
menu::Item::Button("hi 444", None, Action::Hi3),
menu::Item::Folder(
"nest 4 >".into(),
vec![
menu::Item::Button("hi 41", None, Action::Hi),
menu::Item::Button("hi 442", None, Action::Hi2),
menu::Item::Folder(
"nest 3 4 >".into(),
vec![
menu::Item::Button("hi 443", None, Action::Hi2),
menu::Item::Button("hi 4444", None, Action::Hi),
menu::Item::Button("hi 44444", None, Action::Hi3),
menu::Item::Button("hi 444445", None, Action::Hi3),
menu::Item::Button("hi 4444446", None, Action::Hi3),
menu::Item::Button("hi 44444447", None, Action::Hi3),
],
),
],
),
],
),
Tree::with_children(
menu::root("hi 4"),
menu::items(
&self.keybinds,
vec![
menu::Item::Folder(
"hi 41 extra root",
vec![menu::Item::Button("hi 3", None, Action::Hi)],
),
menu::Item::Button("hi 42", None, Action::Hi),
menu::Item::Button("hi 43", None, Action::Hi),
menu::Item::Button("hi 44", None, Action::Hi),
menu::Item::Button("hi 45", None, Action::Hi),
menu::Item::Button("hi 46", None, Action::Hi),
],
),
),
])
.into()]
}
#[cfg(feature = "wayland")]
{
vec![cosmic::widget::responsive_menu_bar().into_element(
self.core(),
&self.keybinds,
MENU_ID.clone(),
Message::Surface,
vec![
(
"hiiiiiiiiiiiiiiiiiii 1",
vec![menu::Item::Button("hi 1", None, Action::Hi)],
),
(
"hiiiiiiiiiiiiiiiiiii 2".into(),
vec![
menu::Item::Button("hi 2", None, Action::Hi),
menu::Item::Button("hi 22", None, Action::Hi),
],
),
(
"hiiiiiiiiiiiiiiiiiii 3".into(),
vec![
menu::Item::Button("hi 3", None, Action::Hi),
menu::Item::Button("hi 33", None, Action::Hi),
menu::Item::Button("hi 333", None, Action::Hi),
],
),
(
"hiiiiiiiiiiiiiiiiiii 4".into(),
vec![
menu::Item::Button("hi 4", None, Action::Hi),
menu::Item::Button("hi 44", None, Action::Hi),
menu::Item::Button("hi 444", None, Action::Hi),
menu::Item::Folder(
"nest 4".into(),
vec![
menu::Item::Button("hi 4", None, Action::Hi),
menu::Item::Button("hi 44", None, Action::Hi),
menu::Item::Button("hi 444", None, Action::Hi),
menu::Item::Folder(
"nest 2 4".into(),
vec![
menu::Item::Button("hi 4", None, Action::Hi),
menu::Item::Button("hi 44", None, Action::Hi),
menu::Item::Button("hi 444", None, Action::Hi),
],
),
],
),
],
),
],
)]
}
],
)]
}
}

1
examples/calendar/src/main.rs
View file

@ -92,6 +92,7 @@ impl cosmic::Application for App {
|date| Message::DateSelected(date),
|| Message::PrevMonth,
|| Message::NextMonth,
chrono::Weekday::Sun,
);
content = content.push(calendar);

10
examples/context-menu/Cargo.toml
View file

@ -11,4 +11,12 @@ tracing-log = "0.2.0"
[dependencies.libcosmic]
path = "../../"
default-features = false
features = ["debug", "winit", "tokio", "xdg-portal", "multi-window"]
features = [
"debug",
"winit",
"tokio",
"xdg-portal",
"multi-window",
"surface-message",
"wayland",
]

2
examples/context-menu/src/main.rs
View file

@ -93,7 +93,7 @@ impl cosmic::Application for App {
/// Creates a view after each update.
fn view(&self) -> Element<Self::Message> {
let widget = cosmic::widget::context_menu(
cosmic::widget::button::text(&self.button_label).on_press(Message::Clicked),
cosmic::widget::button::text(self.button_label.to_string()).on_press(Message::Clicked),
self.context_menu(),
);

3
examples/menu/src/main.rs
View file

@ -15,6 +15,7 @@ use cosmic::widget::menu::action::MenuAction;
use cosmic::widget::menu::key_bind::KeyBind;
use cosmic::widget::menu::key_bind::Modifier;
use cosmic::widget::menu::{self, ItemHeight, ItemWidth};
use cosmic::widget::RcElementWrapper;
use cosmic::{executor, Element};
/// Runs application with these settings
@ -155,7 +156,7 @@ impl cosmic::Application for App {
pub fn menu_bar<'a>(config: &Config, key_binds: &HashMap<KeyBind, Action>) -> Element<'a, Message> {
menu::bar(vec![menu::Tree::with_children(
menu::root("File"),
RcElementWrapper::new(Element::from(menu::root("File"))),
menu::items(
key_binds,
vec![

4
examples/table-view/src/main.rs
View file

@ -209,11 +209,11 @@ impl cosmic::Application for App {
if size.width < 600.0 {
widget::compact_table(&self.table_model)
.on_item_left_click(Message::ItemSelect)
.item_context(|item| {
.item_context(move |item| {
Some(widget::menu::items(
&HashMap::new(),
vec![widget::menu::Item::Button(
format!("Action on {}", item.name),
format!("Action on {}", item.name.to_string()),
None,
Action::None,
)],

2
iced

@ -1 +1 @@
Subproject commit 70d104a28a87f06eb46d76268b6fa18c407ee2c2
Subproject commit 717bc5dbfbc8f78e367e08e76a9572ee0ebc1f32

2
src/surface/action.rs
View file

@ -85,7 +85,7 @@ pub fn simple_subsurface<Message: 'static, V>(
/// Used to create a popup message from within a widget.
#[cfg(all(feature = "wayland", feature = "winit"))]
#[must_use]
pub fn simple_popup<Message: 'static, V>(
pub fn simple_popup<Message: 'static>(
settings: impl Fn() -> iced_runtime::platform_specific::wayland::popup::SctkPopupSettings
+ Send
+ Sync

2
src/theme/style/menu_bar.rs
View file

@ -42,7 +42,7 @@ pub enum MenuBarStyle {
#[default]
Default,
/// A [`Theme`] that uses a `Custom` palette.
Custom(Arc<dyn StyleSheet<Style = Theme>>),
Custom(Arc<dyn StyleSheet<Style = Theme> + Send + Sync>),
}
impl From<fn(&Theme) -> Appearance> for MenuBarStyle {

1
src/widget/button/widget.rs
View file

@ -460,7 +460,6 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
if !self.selected && matches!(self.style, crate::theme::Button::HeaderBar) {
headerbar_alpha = Some(0.8);
}
theme.hovered(state.is_focused, self.selected, &self.style)
}
} else {

60
src/widget/context_menu.rs
View file

@ -4,26 +4,26 @@
//! A context menu is a menu in a graphical user interface that appears upon user interaction, such as a right-click mouse operation.
use crate::widget::menu::{
self, CloseCondition, ItemHeight, ItemWidth, MenuBarState, PathHighlight,
self, CloseCondition, ItemHeight, ItemWidth, MenuBarState, PathHighlight, menu_roots_diff,
};
use derive_setters::Setters;
use iced::touch::Finger;
use iced::{Event, Vector};
use iced::{Event, Vector, window};
use iced_core::widget::{Tree, Widget, tree};
use iced_core::{Length, Point, Size, event, mouse, touch};
use std::collections::HashSet;
/// 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>(
content: impl Into<crate::Element<'a, Message>> + 'a,
pub fn context_menu<Message: 'static + Clone>(
content: impl Into<crate::Element<'static, Message>> + 'static,
// on_context: Message,
context_menu: Option<Vec<menu::Tree<'a, Message>>>,
) -> ContextMenu<'a, Message> {
context_menu: Option<Vec<menu::Tree<Message>>>,
) -> ContextMenu<'static, Message> {
let mut this = ContextMenu {
content: content.into(),
context_menu: context_menu.map(|menus| {
vec![menu::Tree::with_children(
crate::widget::row::<'static, Message>(),
crate::Element::from(crate::widget::row::<'static, Message>()),
menus,
)]
}),
@ -43,10 +43,12 @@ pub struct ContextMenu<'a, Message> {
#[setters(skip)]
content: crate::Element<'a, Message>,
#[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 {
tree::Tag::of::<LocalState>()
}
@ -56,6 +58,7 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
tree::State::new(LocalState {
context_cursor: Point::default(),
fingers_pressed: Default::default(),
menu_bar_state: Default::default(),
})
}
@ -67,7 +70,6 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
// Assign the context menu's elements as this widget's children.
if let Some(ref context_menu) = self.context_menu {
let mut tree = Tree::empty();
tree.state = tree::State::new(MenuBarState::default());
tree.children = context_menu
.iter()
.map(|root| {
@ -75,7 +77,7 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
let flat = root
.flattern()
.iter()
.map(|mt| Tree::new(mt.item.as_widget()))
.map(|mt| Tree::new(mt.item.clone()))
.collect();
tree.children = flat;
tree
@ -90,6 +92,10 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
fn diff(&mut self, tree: &mut Tree) {
tree.children[0].diff(self.content.as_widget_mut());
let state = tree.state.downcast_mut::<LocalState>();
state.menu_bar_state.inner.with_data_mut(|inner| {
menu_roots_diff(self.context_menu.as_mut().unwrap(), &mut inner.tree);
});
// if let Some(ref mut context_menus) = self.context_menu {
// for (menu, tree) in context_menus
@ -183,10 +189,12 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
&& (right_button_released(&event) || (touch_lifted(&event) && fingers_pressed == 2))
{
state.context_cursor = cursor.position().unwrap_or_default();
let state = tree.state.downcast_mut::<LocalState>();
let menu_state = tree.children[1].state.downcast_mut::<MenuBarState>();
menu_state.open = true;
menu_state.view_cursor = cursor;
state.menu_bar_state.inner.with_data_mut(|state| {
state.open = true;
state.view_cursor = cursor;
});
return event::Status::Captured;
}
@ -213,22 +221,19 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
let state = tree.state.downcast_ref::<LocalState>();
let Some(context_menu) = self.context_menu.as_mut() else {
return None;
};
let context_menu = self.context_menu.as_mut()?;
if !tree.children[1].state.downcast_ref::<MenuBarState>().open {
if !state.menu_bar_state.inner.with_data(|state| state.open) {
return None;
}
let mut bounds = layout.bounds();
bounds.x = state.context_cursor.x;
bounds.y = state.context_cursor.y;
Some(
crate::widget::menu::Menu {
tree: &mut tree.children[1],
menu_roots: context_menu,
tree: state.menu_bar_state.clone(),
menu_roots: std::borrow::Cow::Owned(context_menu.clone()),
bounds_expand: 16,
menu_overlays_parent: true,
close_condition: CloseCondition {
@ -243,8 +248,12 @@ impl<Message: Clone> Widget<Message, crate::Theme, crate::Renderer> for ContextM
cross_offset: 0,
root_bounds_list: vec![bounds],
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),
is_overlay: true,
window_id: window::Id::NONE,
depth: 0,
on_surface_action: None,
}
.overlay(),
)
@ -263,8 +272,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> {
fn from(widget: ContextMenu<'a, Message>) -> Self {
impl<'a, Message: Clone + 'static> From<ContextMenu<'static, Message>>
for crate::Element<'static, Message>
{
fn from(widget: ContextMenu<'static, Message>) -> Self {
Self::new(widget)
}
}
@ -283,4 +294,5 @@ fn touch_lifted(event: &Event) -> bool {
pub struct LocalState {
context_cursor: Point,
fingers_pressed: HashSet<Finger>,
menu_bar_state: MenuBarState,
}

10
src/widget/dropdown/widget.rs
View file

@ -536,15 +536,7 @@ pub fn update<
let on_close = surface::action::destroy_popup(id);
let on_surface_action_clone = on_surface_action.clone();
let translation = layout.virtual_offset();
let get_popup_action = surface::action::simple_popup::<
AppMessage,
Box<
dyn Fn() -> Element<'static, crate::Action<AppMessage>>
+ Send
+ Sync
+ 'static,
>,
>(
let get_popup_action = surface::action::simple_popup::<AppMessage>(
move || {
SctkPopupSettings {
parent,

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

@ -1,12 +1,14 @@
// From iced_aw, license MIT
use iced_core::widget::Tree;
use iced_core::{Widget, widget::Tree};
use iced_widget::core::{
Alignment, Element, Padding, Point, Size,
layout::{Limits, Node},
renderer,
};
use crate::widget::RcElementWrapper;
/// The main axis of a flex layout.
#[derive(Debug)]
pub enum Axis {
@ -217,3 +219,170 @@ where
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)
}

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

@ -1,73 +1,98 @@
// From iced_aw, license MIT
//! A widget that handles menu trees
use std::{collections::HashMap, sync::Arc};
use super::{
menu_inner::{
CloseCondition, Direction, ItemHeight, ItemWidth, Menu, MenuState, PathHighlight,
},
menu_tree::MenuTree,
};
use crate::style::menu_bar::StyleSheet;
use crate::{
Renderer,
style::menu_bar::StyleSheet,
widget::{
RcWrapper,
dropdown::menu::{self, State},
menu::menu_inner::init_root_menu,
},
};
use iced::{Point, Vector};
use iced::{Point, Shadow, Vector, window};
use iced_core::Border;
use iced_widget::core::{
Alignment, Clipboard, Element, Layout, Length, Padding, Rectangle, Shell, Widget, event,
layout::{Limits, Node},
mouse::{self, Cursor},
overlay, renderer, touch,
overlay,
renderer::{self, Renderer as IcedRenderer},
touch,
widget::{Tree, tree},
};
/// A `MenuBar` collects `MenuTree`s and handles all the layout, event processing, and drawing.
pub fn menu_bar<Message, Renderer: iced_core::Renderer>(
menu_roots: Vec<MenuTree<Message, Renderer>>,
) -> MenuBar<Message, Renderer> {
pub fn menu_bar<Message>(menu_roots: Vec<MenuTree<Message>>) -> MenuBar<Message>
where
Message: Clone + 'static,
{
MenuBar::new(menu_roots)
}
#[derive(Clone, Default)]
pub(crate) struct MenuBarState {
pub(crate) inner: RcWrapper<MenuBarStateInner>,
}
pub(crate) struct MenuBarStateInner {
pub(crate) tree: Tree,
pub(crate) popup_id: HashMap<window::Id, window::Id>,
pub(crate) pressed: bool,
pub(crate) bar_pressed: bool,
pub(crate) view_cursor: Cursor,
pub(crate) open: bool,
pub(crate) active_root: Option<usize>,
pub(crate) active_root: Vec<usize>,
pub(crate) horizontal_direction: Direction,
pub(crate) vertical_direction: Direction,
/// List of all menu states
pub(crate) menu_states: Vec<MenuState>,
}
impl MenuBarState {
pub(super) fn get_trimmed_indices(&self) -> impl Iterator<Item = usize> + '_ {
impl MenuBarStateInner {
/// get the list of indices hovered for the menu
pub(super) fn get_trimmed_indices(&self, index: usize) -> impl Iterator<Item = usize> + '_ {
self.menu_states
.iter()
.skip(index)
.take_while(|ms| ms.index.is_some())
.map(|ms| ms.index.expect("No indices were found in the menu state."))
}
pub(super) fn reset(&mut self) {
self.open = false;
self.active_root = None;
self.active_root = Vec::new();
self.menu_states.clear();
}
}
impl Default for MenuBarState {
impl Default for MenuBarStateInner {
fn default() -> Self {
Self {
tree: Tree::empty(),
pressed: false,
view_cursor: Cursor::Available([-0.5, -0.5].into()),
open: false,
active_root: None,
active_root: Vec::new(),
horizontal_direction: Direction::Positive,
vertical_direction: Direction::Positive,
menu_states: Vec::new(),
popup_id: HashMap::new(),
bar_pressed: false,
}
}
}
pub(crate) fn menu_roots_children<Message, Renderer>(
menu_roots: &Vec<MenuTree<'_, Message, Renderer>>,
) -> Vec<Tree>
pub(crate) fn menu_roots_children<Message>(menu_roots: &Vec<MenuTree<Message>>) -> Vec<Tree>
where
Renderer: renderer::Renderer,
Message: Clone + 'static,
{
/*
menu bar
@ -85,7 +110,7 @@ where
let flat = root
.flattern()
.iter()
.map(|mt| Tree::new(mt.item.as_widget()))
.map(|mt| Tree::new(mt.item.clone()))
.collect();
tree.children = flat;
tree
@ -94,11 +119,9 @@ where
}
#[allow(invalid_reference_casting)]
pub(crate) fn menu_roots_diff<Message, Renderer>(
menu_roots: &mut Vec<MenuTree<'_, Message, Renderer>>,
tree: &mut Tree,
) where
Renderer: renderer::Renderer,
pub(crate) fn menu_roots_diff<Message>(menu_roots: &mut Vec<MenuTree<Message>>, tree: &mut Tree)
where
Message: Clone + 'static,
{
if tree.children.len() > menu_roots.len() {
tree.children.truncate(menu_roots.len());
@ -112,7 +135,7 @@ pub(crate) fn menu_roots_diff<Message, Renderer>(
.flattern()
.iter()
.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_mut =
widget_ptr as *mut dyn Widget<Message, crate::Theme, Renderer>;
@ -130,7 +153,7 @@ pub(crate) fn menu_roots_diff<Message, Renderer>(
let flat = root
.flattern()
.iter()
.map(|mt| Tree::new(mt.item.as_widget()))
.map(|mt| Tree::new(mt.item.clone()))
.collect();
tree.children = flat;
tree
@ -139,12 +162,18 @@ pub(crate) fn menu_roots_diff<Message, Renderer>(
}
}
pub fn get_mut_or_default<T: Default>(vec: &mut Vec<T>, index: usize) -> &mut T {
if index < vec.len() {
&mut vec[index]
} else {
vec.resize_with(index + 1, T::default);
&mut vec[index]
}
}
/// A `MenuBar` collects `MenuTree`s and handles all the layout, event processing, and drawing.
#[allow(missing_debug_implementations)]
pub struct MenuBar<'a, Message, Renderer = crate::Renderer>
where
Renderer: renderer::Renderer,
{
pub struct MenuBar<Message> {
width: Length,
height: Length,
spacing: f32,
@ -156,17 +185,22 @@ where
item_width: ItemWidth,
item_height: ItemHeight,
path_highlight: Option<PathHighlight>,
menu_roots: Vec<MenuTree<'a, Message, Renderer>>,
menu_roots: Vec<MenuTree<Message>>,
style: <crate::Theme as StyleSheet>::Style,
window_id: window::Id,
#[cfg(all(feature = "wayland", feature = "winit"))]
positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner,
pub(crate) on_surface_action:
Option<Arc<dyn Fn(crate::surface::Action) -> Message + Send + Sync + 'static>>,
}
impl<'a, Message, Renderer> MenuBar<'a, Message, Renderer>
impl<Message> MenuBar<Message>
where
Renderer: renderer::Renderer,
Message: Clone + 'static,
{
/// Creates a new [`MenuBar`] with the given menu roots
#[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;
menu_roots.iter_mut().for_each(MenuTree::set_index);
@ -188,6 +222,10 @@ where
path_highlight: Some(PathHighlight::MenuActive),
menu_roots,
style: <crate::Theme as StyleSheet>::Style::default(),
window_id: window::Id::NONE,
#[cfg(all(feature = "wayland", feature = "winit"))]
positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner::default(),
on_surface_action: None,
}
}
@ -278,17 +316,196 @@ where
self.width = width;
self
}
#[cfg(all(feature = "wayland", feature = "winit"))]
pub fn with_positioner(
mut self,
positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner,
) -> Self {
self.positioner = positioner;
self
}
#[must_use]
pub fn window_id(mut self, id: window::Id) -> Self {
self.window_id = id;
self
}
#[must_use]
pub fn window_id_maybe(mut self, id: Option<window::Id>) -> Self {
if let Some(id) = id {
self.window_id = id;
}
self
}
#[must_use]
pub fn on_surface_action(
mut self,
handler: impl Fn(crate::surface::Action) -> Message + Send + Sync + 'static,
) -> Self {
self.on_surface_action = Some(Arc::new(handler));
self
}
#[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
#[allow(clippy::too_many_lines)]
fn create_popup(
&mut self,
layout: Layout<'_>,
view_cursor: Cursor,
renderer: &Renderer,
shell: &mut Shell<'_, Message>,
viewport: &Rectangle,
my_state: &mut MenuBarState,
) {
if self.window_id != window::Id::NONE && self.on_surface_action.is_some() {
use crate::surface::action::destroy_popup;
use iced_runtime::platform_specific::wayland::popup::{
SctkPopupSettings, SctkPositioner,
};
let surface_action = self.on_surface_action.as_ref().unwrap();
let old_active_root = my_state
.inner
.with_data(|state| state.active_root.get(0).copied());
// if position is not on menu bar button skip.
let hovered_root = layout
.children()
.position(|lo| view_cursor.is_over(lo.bounds()));
if old_active_root
.zip(hovered_root)
.is_some_and(|r| r.0 == r.1)
{
return;
}
let (id, root_list) = my_state.inner.with_data_mut(|state| {
if let Some(id) = state.popup_id.get(&self.window_id).copied() {
// close existing popups
state.menu_states.clear();
state.active_root.clear();
shell.publish(surface_action(destroy_popup(id)));
state.view_cursor = view_cursor;
(id, layout.children().map(|lo| lo.bounds()).collect())
} else {
(
window::Id::unique(),
layout.children().map(|lo| lo.bounds()).collect(),
)
}
});
let mut popup_menu: Menu<'static, _> = Menu {
tree: my_state.clone(),
menu_roots: std::borrow::Cow::Owned(self.menu_roots.clone()),
bounds_expand: self.bounds_expand,
menu_overlays_parent: false,
close_condition: self.close_condition,
item_width: self.item_width,
item_height: self.item_height,
bar_bounds: layout.bounds(),
main_offset: self.main_offset,
cross_offset: self.cross_offset,
root_bounds_list: root_list,
path_highlight: self.path_highlight,
style: std::borrow::Cow::Owned(self.style.clone()),
position: Point::new(0., 0.),
is_overlay: false,
window_id: id,
depth: 0,
on_surface_action: self.on_surface_action.clone(),
};
init_root_menu(
&mut popup_menu,
renderer,
shell,
view_cursor.position().unwrap(),
viewport.size(),
Vector::new(0., 0.),
layout.bounds(),
self.main_offset as f32,
);
let (anchor_rect, gravity) = my_state.inner.with_data_mut(|state| {
state.popup_id.insert(self.window_id, id);
(state
.menu_states
.iter()
.find(|s| s.index.is_none())
.map(|s| s.menu_bounds.parent_bounds)
.map_or_else(
|| {
let bounds = layout.bounds();
Rectangle {
x: bounds.x as i32,
y: bounds.y as i32,
width: bounds.width as i32,
height: bounds.height as i32,
}
},
|r| Rectangle {
x: r.x as i32,
y: r.y as i32,
width: r.width as i32,
height: r.height as i32,
},
), match (state.horizontal_direction, state.vertical_direction) {
(Direction::Positive, Direction::Positive) => cctk::wayland_protocols::xdg::shell::client::xdg_positioner::Gravity::BottomRight,
(Direction::Positive, Direction::Negative) => cctk::wayland_protocols::xdg::shell::client::xdg_positioner::Gravity::TopRight,
(Direction::Negative, Direction::Positive) => cctk::wayland_protocols::xdg::shell::client::xdg_positioner::Gravity::BottomLeft,
(Direction::Negative, Direction::Negative) => cctk::wayland_protocols::xdg::shell::client::xdg_positioner::Gravity::TopLeft,
})
});
let menu_node = popup_menu.layout(renderer, Limits::NONE.min_width(1.).min_height(1.));
let popup_size = menu_node.size();
let positioner = SctkPositioner {
size: Some((
popup_size.width.ceil() as u32 + 2,
popup_size.height.ceil() as u32 + 2,
)),
anchor_rect,
anchor:
cctk::wayland_protocols::xdg::shell::client::xdg_positioner::Anchor::BottomLeft,
gravity,
reactive: true,
..Default::default()
};
let parent = self.window_id;
shell.publish((surface_action)(crate::surface::action::simple_popup(
move || SctkPopupSettings {
parent,
id,
positioner: positioner.clone(),
parent_size: None,
grab: true,
close_with_children: false,
input_zone: None,
},
Some(move || {
Element::from(crate::widget::container(popup_menu.clone()).center(Length::Fill))
.map(crate::action::app)
}),
)));
}
}
}
impl<Message, Renderer> Widget<Message, crate::Theme, Renderer> for MenuBar<'_, Message, Renderer>
impl<Message> Widget<Message, crate::Theme, Renderer> for MenuBar<Message>
where
Renderer: renderer::Renderer,
Message: Clone + 'static,
{
fn size(&self) -> iced_core::Size<Length> {
iced_core::Size::new(self.width, self.height)
}
fn diff(&mut self, tree: &mut Tree) {
menu_roots_diff(&mut self.menu_roots, tree);
let state = tree.state.downcast_mut::<MenuBarState>();
state
.inner
.with_data_mut(|inner| menu_roots_diff(&mut self.menu_roots, &mut inner.tree));
}
fn tag(&self) -> tree::Tag {
@ -318,7 +535,7 @@ where
.iter_mut()
.map(|t| &mut t.children[0])
.collect::<Vec<_>>();
flex::resolve(
flex::resolve_wrapper(
&flex::Axis::Horizontal,
renderer,
&limits,
@ -330,6 +547,7 @@ where
)
}
#[allow(clippy::too_many_lines)]
fn on_event(
&mut self,
tree: &mut Tree,
@ -357,19 +575,70 @@ where
viewport,
);
let state = tree.state.downcast_mut::<MenuBarState>();
let my_state = tree.state.downcast_mut::<MenuBarState>();
// XXX this should reset the state if there are no other copies of the state, which implies no dropdown menus open.
let reset = self.window_id != window::Id::NONE
&& my_state
.inner
.with_data(|d| !d.open && !d.active_root.is_empty());
let open = my_state.inner.with_data_mut(|state| {
if reset {
if let Some(popup_id) = state.popup_id.get(&self.window_id).copied() {
if let Some(handler) = self.on_surface_action.as_ref() {
shell.publish((handler)(crate::surface::Action::DestroyPopup(popup_id)));
state.reset();
}
}
}
state.open
});
match event {
Mouse(ButtonReleased(Left)) | Touch(FingerLifted { .. } | FingerLost { .. }) => {
if state.menu_states.is_empty() && view_cursor.is_over(layout.bounds()) {
state.view_cursor = view_cursor;
state.open = true;
// #[cfg(feature = "wayland")]
// TODO emit Message to open menu
let create_popup = my_state.inner.with_data_mut(|state| {
let mut create_popup = false;
if state.menu_states.is_empty() && view_cursor.is_over(layout.bounds()) {
state.view_cursor = view_cursor;
state.open = true;
create_popup = true;
} else if let Some(_id) = state.popup_id.remove(&self.window_id) {
state.menu_states.clear();
state.active_root.clear();
state.open = false;
#[cfg(all(
feature = "wayland",
feature = "winit",
feature = "surface-message"
))]
{
let surface_action = self.on_surface_action.as_ref().unwrap();
shell.publish(surface_action(crate::surface::action::destroy_popup(
_id,
)));
}
state.view_cursor = view_cursor;
}
create_popup
});
if !create_popup {
return event::Status::Ignored;
}
#[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
self.create_popup(layout, view_cursor, renderer, shell, viewport, my_state);
}
Mouse(mouse::Event::CursorMoved { .. } | mouse::Event::CursorEntered)
if open && view_cursor.is_over(layout.bounds()) =>
{
#[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
self.create_popup(layout, view_cursor, renderer, shell, viewport, my_state);
}
_ => (),
}
root_status
}
@ -385,49 +654,51 @@ where
) {
let state = tree.state.downcast_ref::<MenuBarState>();
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.view_cursor
} else {
view_cursor
};
state.inner.with_data_mut(|state| {
let position = if state.open && (cursor_pos.x < 0.0 || cursor_pos.y < 0.0) {
state.view_cursor
} else {
view_cursor
};
// draw path highlight
if self.path_highlight.is_some() {
let styling = theme.appearance(&self.style);
if let Some(active) = state.active_root {
let active_bounds = layout
.children()
.nth(active)
.expect("Active child not found in menu?")
.bounds();
let path_quad = renderer::Quad {
bounds: active_bounds,
border: Border {
radius: styling.bar_border_radius.into(),
..Default::default()
},
shadow: Default::default(),
};
// draw path highlight
if self.path_highlight.is_some() {
let styling = theme.appearance(&self.style);
if let Some(active) = state.active_root.first() {
let active_bounds = layout
.children()
.nth(*active)
.expect("Active child not found in menu?")
.bounds();
let path_quad = renderer::Quad {
bounds: active_bounds,
border: Border {
radius: styling.bar_border_radius.into(),
..Default::default()
},
shadow: Shadow::default(),
};
renderer.fill_quad(path_quad, styling.path);
renderer.fill_quad(path_quad, styling.path);
}
}
}
self.menu_roots
.iter()
.zip(&tree.children)
.zip(layout.children())
.for_each(|((root, t), lo)| {
root.item.as_widget().draw(
&t.children[root.index],
renderer,
theme,
style,
lo,
position,
viewport,
);
});
self.menu_roots
.iter()
.zip(&tree.children)
.zip(layout.children())
.for_each(|((root, t), lo)| {
root.item.draw(
&t.children[root.index],
renderer,
theme,
style,
lo,
position,
viewport,
);
});
});
}
fn overlay<'b>(
@ -437,18 +708,18 @@ where
_renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, crate::Theme, Renderer>> {
// #[cfg(feature = "wayland")]
// return None;
#[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
return None;
let state = tree.state.downcast_ref::<MenuBarState>();
if !state.open {
if state.inner.with_data(|state| !state.open) {
return None;
}
Some(
Menu {
tree,
menu_roots: &mut self.menu_roots,
tree: state.clone(),
menu_roots: std::borrow::Cow::Owned(self.menu_roots.clone()),
bounds_expand: self.bounds_expand,
menu_overlays_parent: false,
close_condition: self.close_condition,
@ -459,27 +730,30 @@ where
cross_offset: self.cross_offset,
root_bounds_list: layout.children().map(|lo| lo.bounds()).collect(),
path_highlight: self.path_highlight,
style: &self.style,
style: std::borrow::Cow::Borrowed(&self.style),
position: Point::new(translation.x, translation.y),
is_overlay: true,
window_id: window::Id::NONE,
depth: 0,
on_surface_action: self.on_surface_action.clone(),
}
.overlay(),
)
}
}
impl<'a, Message, Renderer> From<MenuBar<'a, Message, Renderer>>
for Element<'a, Message, crate::Theme, Renderer>
impl<Message> From<MenuBar<Message>> for Element<'_, Message, crate::Theme, Renderer>
where
Message: 'a,
Renderer: 'a + renderer::Renderer,
Message: Clone + 'static,
{
fn from(value: MenuBar<'a, Message, Renderer>) -> Self {
fn from(value: MenuBar<Message>) -> Self {
Self::new(value)
}
}
#[allow(unused_results, clippy::too_many_arguments)]
fn process_root_events<Message, Renderer>(
menu_roots: &mut [MenuTree<'_, Message, Renderer>],
fn process_root_events<Message>(
menu_roots: &mut [MenuTree<Message>],
view_cursor: Cursor,
tree: &mut Tree,
event: &event::Event,
@ -490,7 +764,6 @@ fn process_root_events<Message, Renderer>(
viewport: &Rectangle,
) -> event::Status
where
Renderer: renderer::Renderer,
{
menu_roots
.iter_mut()
@ -498,7 +771,7 @@ where
.zip(layout.children())
.map(|((root, t), lo)| {
// assert!(t.tag == tree::Tag::stateless());
root.item.as_widget_mut().on_event(
root.item.on_event(
&mut t.children[root.index],
event.clone(),
lo,

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

File diff suppressed because it is too large Load diff

116
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::widget::menu::action::MenuAction;
use crate::widget::menu::key_bind::KeyBind;
use crate::widget::{Button, icon};
use crate::widget::{Button, RcElementWrapper, icon};
use crate::{theme, widget};
/// 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
/// has children, it's a menu, otherwise it's an item
#[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 `index` field is the index of the item in that vector
pub(crate) index: usize,
/// 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
pub(crate) children: Vec<MenuTree<'a, Message, Renderer>>,
pub(crate) children: Vec<MenuTree<Message>>,
/// The width of the menu tree
pub(crate) width: Option<u16>,
/// The height of the menu tree
pub(crate) height: Option<u16>,
}
impl<'a, Message, Renderer> MenuTree<'a, Message, Renderer>
where
Renderer: renderer::Renderer,
{
impl<Message: Clone + 'static> MenuTree<Message> {
/// 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 {
index: 0,
item: item.into(),
@ -55,8 +53,8 @@ where
/// Create a menu tree from a widget and a vector of sub trees
pub fn with_children(
item: impl Into<Element<'a, Message, crate::Theme, Renderer>>,
children: Vec<impl Into<MenuTree<'a, Message, Renderer>>>,
item: impl Into<RcElementWrapper<Message>>,
children: Vec<impl Into<MenuTree<Message>>>,
) -> Self {
Self {
index: 0,
@ -92,7 +90,7 @@ where
/// Set the index of each item
pub(crate) fn set_index(&mut self) {
/// 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
mt.children.iter_mut().for_each(|c| {
c.index = *count;
@ -109,18 +107,18 @@ where
}
/// Flatten the menu tree
pub(crate) fn flattern(&'a self) -> Vec<&Self> {
pub(crate) fn flattern(&self) -> Vec<&Self> {
/// Inner flattening function
fn rec<'a, Message, Renderer>(
mt: &'a MenuTree<'a, Message, Renderer>,
flat: &mut Vec<&MenuTree<'a, Message, Renderer>>,
fn rec<'a, Message: Clone + 'static>(
mt: &'a MenuTree<Message>,
flat: &mut Vec<&'a MenuTree<Message>>,
) {
mt.children.iter().for_each(|c| {
flat.push(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>>
for MenuTree<'a, Message, Renderer>
where
Renderer: renderer::Renderer,
{
fn from(value: Element<'a, Message, crate::Theme, Renderer>) -> Self {
Self::new(value)
impl<Message: Clone + 'static> From<crate::Element<'static, Message>> for MenuTree<Message> {
fn from(value: crate::Element<'static, Message>) -> Self {
Self::new(RcElementWrapper::new(value))
}
}
@ -160,6 +154,7 @@ where
.class(theme::Button::MenuItem)
}
#[derive(Clone)]
/// 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.
@ -215,20 +210,15 @@ where
///
/// # Returns
/// - A vector of `MenuTree`.
#[must_use]
pub fn menu_items<
'a,
A: MenuAction<Message = Message>,
L: Into<Cow<'static, str>> + 'static,
Message,
Renderer: renderer::Renderer + 'a,
Message: 'static + std::clone::Clone,
>(
key_binds: &HashMap<KeyBind, A>,
children: Vec<MenuItem<A, L>>,
) -> Vec<MenuTree<'a, Message, Renderer>>
where
Element<'a, Message, crate::Theme, Renderer>: From<widget::button::Button<'a, Message>>,
Message: 'a + Clone,
{
) -> Vec<MenuTree<Message>> {
fn find_key<A: MenuAction>(action: &A, key_binds: &HashMap<KeyBind, A>) -> String {
for (key_bind, key_action) in key_binds {
if action == key_action {
@ -249,9 +239,10 @@ where
match item {
MenuItem::Button(label, icon, action) => {
let l: Cow<'static, str> = label.into();
let key = find_key(&action, key_binds);
let mut items = vec![
widget::text(label).into(),
widget::text(l.clone()).into(),
widget::horizontal_space().into(),
widget::text(key).into(),
];
@ -261,15 +252,18 @@ where
items.insert(1, widget::Space::with_width(spacing.space_xxs).into());
}
// dbg!("button with action...", 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) => {
let l: Cow<'static, str> = label.into();
let key = find_key(&action, key_binds);
let mut items = vec![
widget::text(label).into(),
widget::text(l.clone()).into(),
widget::horizontal_space().into(),
widget::text(key).into(),
];
@ -281,7 +275,7 @@ where
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) => {
let key = find_key(&action, key_binds);
@ -311,36 +305,42 @@ where
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) => {
trees.push(MenuTree::<Message, Renderer>::with_children(
menu_button(vec![
widget::text(label).into(),
widget::horizontal_space().into(),
widget::icon::from_name("pan-end-symbolic")
.size(16)
.icon()
.into(),
])
.class(
// Menu folders have no on_press so they take on the disabled style by default
if children.is_empty() {
// This will make the folder use the disabled style if it has no children
theme::Button::MenuItem
} else {
// This will make the folder use the enabled style if it has children
theme::Button::MenuFolder
},
),
let l: Cow<'static, str> = label.into();
trees.push(MenuTree::<Message>::with_children(
RcElementWrapper::new(crate::Element::from(
menu_button::<'static, _>(vec![
widget::text(l.clone()).into(),
widget::horizontal_space().into(),
widget::icon::from_name("pan-end-symbolic")
.size(16)
.icon()
.into(),
])
.class(
// Menu folders have no on_press so they take on the disabled style by default
if children.is_empty() {
// This will make the folder use the disabled style if it has no children
theme::Button::MenuItem
} else {
// This will make the folder use the enabled style if it has children
theme::Button::MenuFolder
},
),
)),
menu_items(key_binds, children),
));
}
MenuItem::Divider => {
if i != size - 1 {
trees.push(MenuTree::<Message, Renderer>::new(
trees.push(MenuTree::<Message>::from(Element::from(
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]
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
}

24
src/widget/responsive_menu_bar.rs
View file

@ -9,6 +9,7 @@ use crate::{
use super::menu::{self, ItemHeight, ItemWidth};
#[must_use]
pub fn responsive_menu_bar() -> ResponsiveMenuBar {
ResponsiveMenuBar::default()
}
@ -33,18 +34,21 @@ impl Default for ResponsiveMenuBar {
impl ResponsiveMenuBar {
/// Set the item width
#[must_use]
pub fn item_width(mut self, item_width: ItemWidth) -> Self {
self.item_width = item_width;
self
}
/// Set the item height
#[must_use]
pub fn item_height(mut self, item_height: ItemHeight) -> Self {
self.item_height = item_height;
self
}
/// Set the spacing
#[must_use]
pub fn spacing(mut self, spacing: f32) -> Self {
self.spacing = spacing;
self
@ -56,14 +60,14 @@ impl ResponsiveMenuBar {
pub fn into_element<
'a,
Message: Clone + 'static,
A: menu::Action<Message = Message>,
A: menu::Action<Message = Message> + Clone,
S: Into<std::borrow::Cow<'static, str>> + 'static,
>(
self,
core: &Core,
key_binds: &HashMap<menu::KeyBind, A>,
id: crate::widget::Id,
action_message: impl Fn(crate::surface::Action) -> Message + 'static,
action_message: impl Fn(crate::surface::Action) -> Message + Send + Sync + Clone + 'static,
trees: Vec<(S, Vec<menu::Item<A, S>>)>,
) -> Element<'a, Message> {
use crate::widget::id_container;
@ -80,17 +84,21 @@ impl ResponsiveMenuBar {
menu::bar(
trees
.into_iter()
.map(|mt| {
.map(|mt: (S, Vec<menu::Item<A, S>>)| {
menu::Tree::<_>::with_children(
menu::root(mt.0),
menu::items(key_binds, mt.1.into()),
crate::widget::RcElementWrapper::new(Element::from(
menu::root(mt.0),
)),
menu::items(key_binds, mt.1),
)
})
.collect(),
)
.item_width(self.item_width)
.item_height(self.item_height)
.spacing(self.spacing),
.spacing(self.spacing)
.on_surface_action(action_message.clone())
.window_id_maybe(core.main_window_id()),
crate::widget::Id::new(format!("menu_bar_expanded_{id}")),
),
id,
@ -123,7 +131,9 @@ impl ResponsiveMenuBar {
)])
.item_height(self.item_height)
.item_width(self.collapsed_item_width)
.spacing(self.spacing),
.spacing(self.spacing)
.on_surface_action(action_message.clone())
.window_id_maybe(core.main_window_id()),
crate::widget::Id::new(format!("menu_bar_collapsed_{id}")),
),
id,

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

@ -17,7 +17,7 @@ use iced::clipboard::mime::AllowedMimeTypes;
use iced::touch::Finger;
use iced::{
Alignment, Background, Color, Event, Length, Padding, Rectangle, Size, Task, Vector, alignment,
event, keyboard, mouse, touch,
event, keyboard, mouse, touch, window,
};
use iced_core::mouse::ScrollDelta;
use iced_core::text::{LineHeight, Renderer as TextRenderer, Shaping, Wrapping};
@ -127,7 +127,7 @@ where
pub(super) style: Style,
/// The context menu to display when a context is activated
#[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.
#[setters(skip)]
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
Message: 'static,
Message: Clone + 'static,
{
self.context_menu = context_menu.map(|menus| {
vec![menu::Tree::with_children(
crate::widget::row::<'static, Message>(),
crate::Element::from(crate::widget::row::<'static, Message>()),
menus,
)]
});
@ -577,6 +577,7 @@ where
fn state(&self) -> tree::State {
#[allow(clippy::default_trait_access)]
tree::State::new(LocalState {
menu_state: Default::default(),
paragraphs: SecondaryMap::new(),
text_hashes: SecondaryMap::new(),
buttons_visible: Default::default(),
@ -955,8 +956,10 @@ where
let menu_state =
tree.children[0].state.downcast_mut::<MenuBarState>();
menu_state.open = true;
menu_state.view_cursor = cursor_position;
menu_state.inner.with_data_mut(|data| {
data.open = true;
data.view_cursor = cursor_position;
});
shell.publish(on_context(key));
return event::Status::Captured;
@ -1346,7 +1349,11 @@ where
let center_y = bounds.center_y();
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_hovered = self.button_is_hovered(state, key);
@ -1556,6 +1563,7 @@ where
translation: Vector,
) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, Renderer>> {
let state = tree.state.downcast_ref::<LocalState>();
let menu_state = state.menu_state.clone();
let Some(entity) = state.show_context else {
return None;
@ -1575,7 +1583,12 @@ where
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;
}
@ -1584,8 +1597,8 @@ where
Some(
crate::widget::menu::Menu {
tree: &mut tree.children[0],
menu_roots: context_menu,
tree: menu_state,
menu_roots: std::borrow::Cow::Borrowed(context_menu),
bounds_expand: 16,
menu_overlays_parent: true,
close_condition: CloseCondition {
@ -1600,8 +1613,12 @@ where
cross_offset: 0,
root_bounds_list: vec![bounds],
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),
is_overlay: true,
window_id: window::Id::NONE,
depth: 0,
on_surface_action: None,
}
.overlay(),
)
@ -1653,6 +1670,8 @@ where
/// State that is maintained by each individual widget.
pub struct LocalState {
/// Menu state
pub(crate) menu_state: MenuBarState,
/// Defines how many buttons to show at a time.
pub(super) buttons_visible: usize,
/// Button visibility offset, when collapsed.

12
src/widget/table/mod.rs
View file

@ -20,9 +20,9 @@ pub type MultiSelectTableView<'a, Item, Category, Message> =
TableView<'a, MultiSelect, Item, Category, Message>;
pub type MultiSelectModel<Item, Category> = Model<MultiSelect, Item, Category>;
pub fn table<'a, SelectionMode, Item, Category, Message>(
model: &'a Model<SelectionMode, Item, Category>,
) -> TableView<'a, SelectionMode, Item, Category, Message>
pub fn table<SelectionMode, Item, Category, Message>(
model: &Model<SelectionMode, Item, Category>,
) -> TableView<'_, SelectionMode, Item, Category, Message>
where
Message: Clone,
SelectionMode: Default,
@ -33,9 +33,9 @@ where
TableView::new(model)
}
pub fn compact_table<'a, SelectionMode, Item, Category, Message>(
model: &'a Model<SelectionMode, Item, Category>,
) -> CompactTableView<'a, SelectionMode, Item, Category, Message>
pub fn compact_table<SelectionMode, Item, Category, Message>(
model: &Model<SelectionMode, Item, Category>,
) -> CompactTableView<'_, SelectionMode, Item, Category, Message>
where
Message: Clone,
SelectionMode: Default,

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

@ -44,7 +44,7 @@ where
#[setters(skip)]
pub(super) on_item_mb_right: Option<Box<dyn Fn(Entity) -> Message + 'static>>,
#[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>
@ -97,7 +97,7 @@ where
]
})
.flatten()
.collect::<Vec<Element<'a, Message>>>();
.collect::<Vec<Element<'static, Message>>>();
elements.pop();
elements
.apply(widget::row::with_children)
@ -247,7 +247,7 @@ where
pub fn item_context<F>(mut self, context_menu_builder: F) -> Self
where
F: Fn(&Item) -> Option<Vec<menu::Tree<'a, Message>>> + 'static,
F: Fn(&Item) -> Option<Vec<menu::Tree<Message>>> + 'static,
Message: 'static,
{
self.item_context_builder = Box::new(context_menu_builder);

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

@ -51,7 +51,7 @@ where
#[setters(skip)]
pub(super) on_item_mb_right: Option<Box<dyn Fn(Entity) -> Message + 'static>>,
#[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
// === Category Interaction ===
@ -64,8 +64,7 @@ where
#[setters(skip)]
pub(super) on_category_mb_right: Option<Box<dyn Fn(Category) -> Message + 'static>>,
#[setters(skip)]
pub(super) category_context_builder:
Box<dyn Fn(Category) -> Option<Vec<menu::Tree<'a, Message>>>>,
pub(super) category_context_builder: Box<dyn Fn(Category) -> Option<Vec<menu::Tree<Message>>>>,
}
impl<'a, SelectionMode, Item, Category, Message>
@ -83,7 +82,7 @@ where
.model
.categories
.iter()
.cloned()
.copied()
.map(|category| {
let cat_context_tree = (val.category_context_builder)(category);
@ -167,7 +166,7 @@ where
.align_y(Alignment::Center)
.apply(Element::from)
})
.collect::<Vec<Element<'a, Message>>>()
.collect::<Vec<Element<'static, Message>>>()
.apply(widget::row::with_children)
.apply(container)
.padding(val.item_padding)
@ -328,7 +327,7 @@ where
pub fn item_context<F>(mut self, context_menu_builder: F) -> Self
where
F: Fn(&Item) -> Option<Vec<menu::Tree<'a, Message>>> + 'static,
F: Fn(&Item) -> Option<Vec<menu::Tree<Message>>> + 'static,
Message: 'static,
{
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
where
F: Fn(Category) -> Option<Vec<menu::Tree<'a, Message>>> + 'static,
F: Fn(Category) -> Option<Vec<menu::Tree<Message>>> + 'static,
Message: 'static,
{
self.category_context_builder = Box::new(context_menu_builder);

13
src/widget/wrapper.rs
View file

@ -1,4 +1,5 @@
use std::{
borrow::Borrow,
cell::RefCell,
rc::Rc,
thread::{self, ThreadId},
@ -14,6 +15,12 @@ pub struct RcWrapper<T> {
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> {
fn clone(&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> {
fn size(&self) -> Size<Length> {
self.element.with_data(|e| e.as_widget().size())