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

wip: menus

Browse source
This commit is contained in:
Ashley Wulber 2025-01-22 16:31:51 -05:00
parent a406859e65
commit 93e3d4fd42
No known key found for this signature in database
GPG key ID: 5216D4F46A90A820
25 changed files with 1358 additions and 243 deletions
Download patch file Download diff file Expand all files Collapse all files

242
src/widget/dropdown/menu/mod.rs
View file

@ -3,7 +3,11 @@
// SPDX-License-Identifier: MPL-2.0 AND MIT
mod appearance;
use std::borrow::Cow;
use std::sync::{Arc, Mutex};
pub use appearance::{Appearance, StyleSheet};
use iced::advanced::widget;
use crate::widget::{icon, Container};
use iced_core::event::{self, Event};
@ -21,11 +25,12 @@ use iced_widget::scrollable::Scrollable;
pub struct Menu<'a, S, Message>
where
S: AsRef<str>,
[S]: std::borrow::ToOwned,
{
state: &'a mut State,
options: &'a [S],
icons: &'a [icon::Handle],
hovered_option: &'a mut Option<usize>,
state: State,
options: Cow<'a, [S]>,
icons: Cow<'a, [icon::Handle]>,
hovered_option: Arc<Mutex<Option<usize>>>,
selected_option: Option<usize>,
on_selected: Box<dyn FnMut(usize) -> Message + 'a>,
on_option_hovered: Option<&'a dyn Fn(usize) -> Message>,
@ -36,14 +41,17 @@ where
style: (),
}
impl<'a, S: AsRef<str>, Message: 'a> Menu<'a, S, Message> {
impl<'a, S: AsRef<str>, Message: 'a + std::clone::Clone> Menu<'a, S, Message>
where
[S]: std::borrow::ToOwned,
{
/// Creates a new [`Menu`] with the given [`State`], a list of options, and
/// the message to produced when an option is selected.
pub fn new(
state: &'a mut State,
options: &'a [S],
icons: &'a [icon::Handle],
hovered_option: &'a mut Option<usize>,
state: State,
options: Cow<'a, [S]>,
icons: Cow<'a, [icon::Handle]>,
hovered_option: Arc<Mutex<Option<usize>>>,
selected_option: Option<usize>,
on_selected: impl FnMut(usize) -> Message + 'a,
on_option_hovered: Option<&'a dyn Fn(usize) -> Message>,
@ -102,20 +110,35 @@ impl<'a, S: AsRef<str>, Message: 'a> Menu<'a, S, Message> {
) -> overlay::Element<'a, Message, crate::Theme, crate::Renderer> {
overlay::Element::new(Box::new(Overlay::new(self, target_height, position)))
}
/// Turns the [`Menu`] into a popup [`Element`] at the given target
/// position.
///
/// The `target_height` will be used to display the menu either on top
/// of the target or under it, depending on the screen position and the
/// dimensions of the [`Menu`].
#[must_use]
pub fn popup(self, position: Point, target_height: f32) -> crate::Element<'a, Message> {
Overlay::new(self, target_height, position).into()
}
}
/// The local state of a [`Menu`].
#[must_use]
#[derive(Debug)]
#[derive(Debug, Clone)]
pub struct State {
tree: Tree,
pub(crate) tree: Arc<Mutex<Tree>>,
}
// XXX The tree is only used on one thread, but this is needed to make a message
unsafe impl Send for State {}
unsafe impl Sync for State {}
impl State {
/// Creates a new [`State`] for a [`Menu`].
pub fn new() -> Self {
Self {
tree: Tree::empty(),
tree: Arc::new(Mutex::new(Tree::empty())),
}
}
}
@ -127,7 +150,7 @@ impl Default for State {
}
struct Overlay<'a, Message> {
state: &'a mut Tree,
state: Arc<Mutex<Tree>>,
container: Container<'a, Message, crate::Theme, crate::Renderer>,
width: f32,
target_height: f32,
@ -140,7 +163,10 @@ impl<'a, Message: 'a> Overlay<'a, Message> {
menu: Menu<'a, S, Message>,
target_height: f32,
position: Point,
) -> Self {
) -> Self
where
[S]: ToOwned,
{
let Menu {
state,
options,
@ -172,10 +198,11 @@ impl<'a, Message: 'a> Overlay<'a, Message> {
))
.class(crate::style::Container::Dropdown);
state.tree.diff(&mut container as &mut dyn Widget<_, _, _>);
let mut tree_guard = state.tree.lock().unwrap();
tree_guard.diff(&mut container as &mut dyn Widget<_, _, _>);
drop(tree_guard);
Self {
state: &mut state.tree,
state: state.tree.clone(),
container,
width,
target_height,
@ -183,20 +210,17 @@ impl<'a, Message: 'a> Overlay<'a, Message> {
position,
}
}
}
impl<'a, Message> iced_core::Overlay<Message, crate::Theme, crate::Renderer>
for Overlay<'a, Message>
{
fn layout(&mut self, renderer: &crate::Renderer, bounds: Size) -> layout::Node {
let position = self.position;
let space_below = bounds.height - (position.y + self.target_height);
let space_above = position.y;
fn _layout(&self, renderer: &crate::Renderer, bounds: Size) -> layout::Node {
let mut guard = self.state.lock().unwrap();
let space_below = bounds.height - (self.position.y + self.target_height);
let space_above = self.position.y;
let limits = layout::Limits::new(
Size::ZERO,
Size::new(
bounds.width - position.x,
bounds.width - self.position.x,
if space_below > space_above {
space_below
} else {
@ -206,16 +230,16 @@ impl<'a, Message> iced_core::Overlay<Message, crate::Theme, crate::Renderer>
)
.width(self.width);
let node = self.container.layout(self.state, renderer, &limits);
let node = self.container.layout(&mut guard, renderer, &limits);
node.clone().move_to(if space_below > space_above {
position + Vector::new(0.0, self.target_height)
self.position + Vector::new(0.0, self.target_height)
} else {
position - Vector::new(0.0, node.size().height)
self.position - Vector::new(0.0, node.size().height)
})
}
fn on_event(
fn _on_event(
&mut self,
event: Event,
layout: Layout<'_>,
@ -225,24 +249,28 @@ impl<'a, Message> iced_core::Overlay<Message, crate::Theme, crate::Renderer>
shell: &mut Shell<'_, Message>,
) -> event::Status {
let bounds = layout.bounds();
let mut guard = self.state.lock().unwrap();
let state = &mut *guard;
self.container.on_event(
self.state, event, layout, cursor, renderer, clipboard, shell, &bounds,
state, event, layout, cursor, renderer, clipboard, shell, &bounds,
)
}
fn mouse_interaction(
fn _mouse_interaction(
&self,
layout: Layout<'_>,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &crate::Renderer,
) -> mouse::Interaction {
let guard = self.state.lock().unwrap();
self.container
.mouse_interaction(self.state, layout, cursor, viewport, renderer)
.mouse_interaction(&guard, layout, cursor, viewport, renderer)
}
fn draw(
fn _draw(
&self,
renderer: &mut crate::Renderer,
theme: &crate::Theme,
@ -250,6 +278,8 @@ impl<'a, Message> iced_core::Overlay<Message, crate::Theme, crate::Renderer>
layout: Layout<'_>,
cursor: mouse::Cursor,
) {
let state = self.state.lock().unwrap();
let appearance = theme.appearance(&self.style);
let bounds = layout.bounds();
@ -267,14 +297,127 @@ impl<'a, Message> iced_core::Overlay<Message, crate::Theme, crate::Renderer>
);
self.container
.draw(self.state, renderer, theme, style, layout, cursor, &bounds);
.draw(&*state, renderer, theme, style, layout, cursor, &bounds);
}
}
struct List<'a, S: AsRef<str>, Message> {
options: &'a [S],
icons: &'a [icon::Handle],
hovered_option: &'a mut Option<usize>,
impl<'a, Message: 'a> iced_core::Overlay<Message, crate::Theme, crate::Renderer>
for Overlay<'a, Message>
{
fn layout(&mut self, renderer: &crate::Renderer, bounds: Size) -> layout::Node {
let mut guard = self.state.lock().unwrap();
self._layout(renderer, bounds)
}
fn on_event(
&mut self,
event: Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
renderer: &crate::Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) -> event::Status {
self._on_event(event, layout, cursor, renderer, clipboard, shell)
}
fn mouse_interaction(
&self,
layout: Layout<'_>,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &crate::Renderer,
) -> mouse::Interaction {
self._mouse_interaction(layout, cursor, viewport, renderer)
}
fn draw(
&self,
renderer: &mut crate::Renderer,
theme: &crate::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor: mouse::Cursor,
) {
let guard = self.state.lock().unwrap();
self._draw(renderer, theme, style, layout, cursor);
}
}
impl<'a, Message: 'a> crate::widget::Widget<Message, crate::Theme, crate::Renderer>
for Overlay<'a, Message>
{
fn size(&self) -> Size<Length> {
Size::new(Length::Fixed(self.width), Length::Shrink)
}
fn layout(
&self,
_tree: &mut iced_core::widget::Tree,
renderer: &crate::Renderer,
limits: &iced::Limits,
) -> layout::Node {
let mut guard = self.state.lock().unwrap();
let limits = limits.width(self.width);
self.container.layout(&mut guard, renderer, &limits)
}
fn mouse_interaction(
&self,
_tree: &Tree,
layout: Layout<'_>,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &crate::Renderer,
) -> mouse::Interaction {
self._mouse_interaction(layout, cursor, viewport, renderer)
}
fn on_event(
&mut self,
_tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
renderer: &crate::Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
_viewport: &Rectangle,
) -> event::Status {
self._on_event(event, layout, cursor, renderer, clipboard, shell)
}
fn draw(
&self,
tree: &Tree,
renderer: &mut crate::Renderer,
theme: &crate::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
self._draw(renderer, theme, style, layout, cursor);
}
}
impl<'a, Message: Clone + 'a> From<Overlay<'a, Message>> for crate::Element<'a, Message> {
fn from(widget: Overlay<'a, Message>) -> Self {
Element::new(widget)
}
}
struct List<'a, S: AsRef<str>, Message>
where
[S]: std::borrow::ToOwned,
{
options: Cow<'a, [S]>,
icons: Cow<'a, [icon::Handle]>,
hovered_option: Arc<Mutex<Option<usize>>>,
selected_option: Option<usize>,
on_selected: Box<dyn FnMut(usize) -> Message + 'a>,
on_option_hovered: Option<&'a dyn Fn(usize) -> Message>,
@ -285,6 +428,8 @@ struct List<'a, S: AsRef<str>, Message> {
impl<'a, S: AsRef<str>, Message> Widget<Message, crate::Theme, crate::Renderer>
for List<'a, S, Message>
where
[S]: std::borrow::ToOwned,
{
fn size(&self) -> Size<Length> {
Size::new(Length::Fill, Length::Shrink)
@ -330,8 +475,9 @@ impl<'a, S: AsRef<str>, Message> Widget<Message, crate::Theme, crate::Renderer>
) -> event::Status {
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
let hovered_guard = self.hovered_option.lock().unwrap();
if cursor.is_over(layout.bounds()) {
if let Some(index) = *self.hovered_option {
if let Some(index) = *hovered_guard {
shell.publish((self.on_selected)(index));
return event::Status::Captured;
}
@ -348,14 +494,15 @@ impl<'a, S: AsRef<str>, Message> Widget<Message, crate::Theme, crate::Renderer>
+ self.padding.vertical();
let new_hovered_option = (cursor_position.y / option_height) as usize;
let mut hovered_guard = self.hovered_option.lock().unwrap();
if let Some(on_option_hovered) = self.on_option_hovered {
if *self.hovered_option != Some(new_hovered_option) {
if *hovered_guard != Some(new_hovered_option) {
shell.publish(on_option_hovered(new_hovered_option));
}
}
*self.hovered_option = Some(new_hovered_option);
*hovered_guard = Some(new_hovered_option);
}
}
Event::Touch(touch::Event::FingerPressed { .. }) => {
@ -367,10 +514,11 @@ impl<'a, S: AsRef<str>, Message> Widget<Message, crate::Theme, crate::Renderer>
let option_height =
f32::from(self.text_line_height.to_absolute(Pixels(text_size)))
+ self.padding.vertical();
let mut hovered_guard = self.hovered_option.lock().unwrap();
*self.hovered_option = Some((cursor_position.y / option_height) as usize);
*hovered_guard = Some((cursor_position.y / option_height) as usize);
if let Some(index) = *self.hovered_option {
if let Some(index) = *hovered_guard {
shell.publish((self.on_selected)(index));
return event::Status::Captured;
}
@ -434,6 +582,8 @@ impl<'a, S: AsRef<str>, Message> Widget<Message, crate::Theme, crate::Renderer>
height: option_height,
};
let hovered_guard = self.hovered_option.lock().unwrap();
let (color, font) = if self.selected_option == Some(i) {
let item_x = bounds.x + appearance.border_width;
let item_width = appearance.border_width.mul_add(-2.0, bounds.width);
@ -471,7 +621,7 @@ impl<'a, S: AsRef<str>, Message> Widget<Message, crate::Theme, crate::Renderer>
);
(appearance.selected_text_color, crate::font::semibold())
} else if *self.hovered_option == Some(i) {
} else if *hovered_guard == Some(i) {
let item_x = bounds.x + appearance.border_width;
let item_width = appearance.border_width.mul_add(-2.0, bounds.width);
@ -538,6 +688,8 @@ impl<'a, S: AsRef<str>, Message> Widget<Message, crate::Theme, crate::Renderer>
impl<'a, S: AsRef<str>, Message: 'a> From<List<'a, S, Message>>
for Element<'a, Message, crate::Theme, crate::Renderer>
where
[S]: std::borrow::ToOwned,
{
fn from(list: List<'a, S, Message>) -> Self {
Element::new(list)