use iced::advanced::layout::{self, Layout};
use iced::advanced::overlay;
use iced::advanced::renderer;
use iced::advanced::text::{self, Text};
use iced::advanced::widget::tree::{self, Tree};
use iced::advanced::widget::Widget;
use iced::advanced::{Clipboard, Shell};
use iced::keyboard;
use iced::keyboard::key::Named;
use iced::mouse;
use iced::overlay::menu::{self, Menu};
use iced::touch;
use iced::window;
use iced::{
alignment, Background, Color, Element, Event, Length, Padding, Pixels, Point, Rectangle, Size,
Theme, Vector,
};
use crate::style;
use crate::theme::{hover_fill, pressed_fill, Tokens};
use crate::typo;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TitleStatus {
Active,
Hovered,
Opened { is_hovered: bool },
}
pub fn title_status(is_open: bool, is_hovered: bool) -> TitleStatus {
if is_open {
TitleStatus::Opened { is_hovered }
} else if is_hovered {
TitleStatus::Hovered
} else {
TitleStatus::Active
}
}
pub fn title_fill(tok: Tokens, status: TitleStatus) -> Color {
match status {
TitleStatus::Active => Color::TRANSPARENT,
TitleStatus::Hovered => hover_fill(tok),
TitleStatus::Opened { .. } => pressed_fill(tok),
}
}
pub fn text_advance(s: &str, size: f32) -> f32 {
s.chars().count() as f32 * size * 0.62
}
pub fn title_extents(title: &str, padding: Padding, text_size: f32, line_height: f32) -> Size {
Size::new(
padding.x() + text_advance(title, text_size) + 4.0,
padding.y() + line_height,
)
}
pub fn overlay_list_width(options: &[impl AsRef<str>], padding: Padding, text_size: f32) -> f32 {
let widest = options
.iter()
.map(|s| text_advance(s.as_ref(), text_size))
.fold(0.0_f32, f32::max);
(widest + padding.x() + 12.0).max(160.0)
}
pub fn press_open_state(is_open: bool, cursor_over_title: bool) -> bool {
if is_open {
false
} else {
cursor_over_title
}
}
pub fn escape_closes(is_open: bool) -> bool {
is_open
}
fn pick_and_close<M>(is_open: &mut bool, on_select: &dyn Fn(String) -> M, option: String) -> M {
*is_open = false;
on_select(option)
}
const TITLE_PAD: [u16; 2] = [4, 10];
pub fn drop_menu<'a, M: Clone + 'a>(
title: impl Into<String>,
options: Vec<String>,
on_select: impl Fn(String) -> M + 'a,
tok: Tokens,
) -> Element<'a, M> {
MenuTitle::new(title.into(), options, on_select, tok).into()
}
struct MenuTitle<'a, Message> {
title: String,
options: Vec<String>,
on_select: Box<dyn Fn(String) -> Message + 'a>,
tok: Tokens,
padding: Padding,
text_size: Pixels,
menu_class: menu::StyleFn<'a, Theme>,
last_status: Option<TitleStatus>,
}
impl<'a, Message> MenuTitle<'a, Message> {
fn new(
title: String,
options: Vec<String>,
on_select: impl Fn(String) -> Message + 'a,
tok: Tokens,
) -> Self {
Self {
title,
options,
on_select: Box::new(on_select),
tok,
padding: Padding::from(TITLE_PAD),
text_size: Pixels::from(typo::BODY),
menu_class: Box::new(style::overlay_menu_style(tok)),
last_status: None,
}
}
}
#[derive(Debug)]
struct State {
menu: menu::State,
is_open: bool,
hovered_option: Option<usize>,
}
impl State {
fn new() -> Self {
Self {
menu: menu::State::default(),
is_open: false,
hovered_option: None,
}
}
}
impl<'a, Message, Renderer> Widget<Message, Theme, Renderer> for MenuTitle<'a, Message>
where
Message: Clone + 'a,
Renderer: text::Renderer<Font = iced::Font> + 'a,
{
fn tag(&self) -> tree::Tag {
tree::Tag::of::<State>()
}
fn state(&self) -> tree::State {
tree::State::new(State::new())
}
fn size(&self) -> Size<Length> {
Size {
width: Length::Shrink,
height: Length::Shrink,
}
}
fn layout(
&mut self,
_tree: &mut Tree,
renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let line = f32::from(text::LineHeight::default().to_absolute(self.text_size));
let intrinsic = title_extents(&self.title, self.padding, self.text_size.0, line);
let size = limits.width(Length::Shrink).height(Length::Shrink).resolve(
Length::Shrink,
Length::Shrink,
intrinsic,
);
let _ = renderer.default_size();
layout::Node::new(size)
}
fn update(
&mut self,
tree: &mut Tree,
event: &Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
_renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
_viewport: &Rectangle,
) {
let state = tree.state.downcast_mut::<State>();
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
| Event::Touch(touch::Event::FingerPressed { .. }) => {
let over = cursor.is_over(layout.bounds());
let next = press_open_state(state.is_open, over);
if next != state.is_open {
state.is_open = next;
if state.is_open {
state.hovered_option = None;
}
shell.capture_event();
}
}
Event::Keyboard(keyboard::Event::KeyPressed { key, .. })
if escape_closes(state.is_open)
&& matches!(key, keyboard::Key::Named(Named::Escape)) =>
{
state.is_open = false;
shell.capture_event();
}
_ => {}
}
let status = title_status(state.is_open, cursor.is_over(layout.bounds()));
if let Event::Window(window::Event::RedrawRequested(_)) = event {
self.last_status = Some(status);
} else if self.last_status.is_some_and(|last| last != status) {
shell.request_redraw();
}
}
fn mouse_interaction(
&self,
_tree: &Tree,
layout: Layout<'_>,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
if cursor.is_over(layout.bounds()) {
mouse::Interaction::Pointer
} else {
mouse::Interaction::default()
}
}
fn draw(
&self,
_tree: &Tree,
renderer: &mut Renderer,
_theme: &Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor: mouse::Cursor,
viewport: &Rectangle,
) {
let bounds = layout.bounds();
let status = self.last_status.unwrap_or(TitleStatus::Active);
renderer.fill_quad(
renderer::Quad {
bounds,
border: iced::Border {
color: Color::TRANSPARENT,
width: 0.0,
radius: crate::chrome::Corner::Tight.radius(),
},
..renderer::Quad::default()
},
Background::Color(title_fill(self.tok, status)),
);
let font = renderer.default_font();
renderer.fill_text(
Text {
content: self.title.clone(),
size: self.text_size,
line_height: text::LineHeight::default(),
font,
bounds: Size::new(
bounds.width - self.padding.x(),
f32::from(text::LineHeight::default().to_absolute(self.text_size)),
),
align_x: text::Alignment::Default,
align_y: alignment::Vertical::Center,
shaping: text::Shaping::default(),
wrapping: text::Wrapping::default(),
},
Point::new(bounds.x + self.padding.left, bounds.center_y()),
self.tok.text,
*viewport,
);
}
fn overlay<'b>(
&'b mut self,
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
viewport: &Rectangle,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
let state = tree.state.downcast_mut::<State>();
if !state.is_open {
return None;
}
let bounds = layout.bounds();
let font = renderer.default_font();
let on_select = &self.on_select;
let width = overlay_list_width(&self.options, self.padding, self.text_size.0);
let menu = Menu::new(
&mut state.menu,
&self.options,
&mut state.hovered_option,
|option| pick_and_close(&mut state.is_open, on_select, option),
None,
&self.menu_class,
)
.width(width)
.padding(self.padding)
.font(font)
.text_size(self.text_size);
Some(menu.overlay(
layout.position() + translation,
*viewport,
bounds.height,
Length::Shrink,
))
}
}
impl<'a, Message> From<MenuTitle<'a, Message>> for Element<'a, Message>
where
Message: Clone + 'a,
{
fn from(value: MenuTitle<'a, Message>) -> Self {
Self::new(value)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::theme::named;
#[test]
fn title_is_not_sized_like_the_longest_item() {
let pad = Padding::from(TITLE_PAD);
let size = 14.0;
let file = title_extents("File", pad, size, 18.0);
let save = overlay_list_width(&["Save ctrl+s", "Open…"], pad, size);
assert!(file.width < 80.0);
assert!(save > file.width);
assert!(save >= 160.0);
assert!(text_advance("File", size) < text_advance("Save ctrl+s", size));
}
#[test]
fn status_and_fill_and_press_and_escape() {
let tok = named("dark").tokens;
assert_eq!(title_status(false, false), TitleStatus::Active);
assert_eq!(title_status(false, true), TitleStatus::Hovered);
assert_eq!(
title_status(true, false),
TitleStatus::Opened { is_hovered: false }
);
assert_eq!(
title_status(true, true),
TitleStatus::Opened { is_hovered: true }
);
assert_eq!(title_fill(tok, TitleStatus::Active).a, 0.0);
assert!(title_fill(tok, TitleStatus::Hovered).a > 0.0);
assert!(title_fill(tok, TitleStatus::Opened { is_hovered: false }).a > 0.0);
assert!(!press_open_state(true, true));
assert!(!press_open_state(true, false));
assert!(press_open_state(false, true));
assert!(!press_open_state(false, false));
assert!(escape_closes(true));
assert!(!escape_closes(false));
}
#[test]
fn drop_menu_builds_an_element() {
let tok = named("dark").tokens;
fn pick(s: String) -> u8 {
crate::pattern::pick_menu_message(&[("Open".into(), 1u8), ("Save".into(), 2)], &s)
}
assert_eq!(pick("Open".into()), 1);
let mut open = true;
assert_eq!(pick_and_close(&mut open, &pick, "Save".into()), 2);
assert!(!open);
let _: Element<'_, u8> = drop_menu("File", vec!["Open".into(), "Save".into()], pick, tok);
let empty: Element<'_, ()> = drop_menu("Help", vec!["About".into()], |_| (), tok);
let _ = empty;
assert!(overlay_list_width(&[] as &[&str], Padding::from(TITLE_PAD), 14.0) >= 160.0);
}
fn key_press(named: Named) -> Event {
Event::Keyboard(keyboard::Event::KeyPressed {
key: keyboard::Key::Named(named),
modified_key: keyboard::Key::Named(named),
physical_key: keyboard::key::Physical::Unidentified(
keyboard::key::NativeCode::Unidentified,
),
location: keyboard::Location::Standard,
modifiers: keyboard::Modifiers::default(),
text: None,
repeat: false,
})
}
#[allow(clippy::too_many_arguments)]
fn pump_title(
widget: &mut MenuTitle<'_, String>,
tree: &mut iced::advanced::widget::Tree,
renderer: &iced_tiny_skia::Renderer,
clipboard: &mut iced::advanced::clipboard::Null,
event: Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
viewport: &Rectangle,
messages: &mut Vec<String>,
) {
use iced::advanced::widget::Widget;
let mut shell = Shell::new(messages);
Widget::<String, Theme, iced_tiny_skia::Renderer>::update(
widget, tree, &event, layout, cursor, renderer, clipboard, &mut shell, viewport,
);
}
#[test]
fn menu_title_opens_overlay_list_on_press() {
use iced::advanced::clipboard;
use iced::advanced::layout::Limits;
use iced::advanced::renderer::Style;
use iced::advanced::widget::{Tree, Widget};
use iced::Font;
let tok = named("dark").tokens;
let mut widget = MenuTitle::new(
"File".into(),
vec!["Open".into(), "Save ctrl+s".into()],
|s| s,
tok,
);
let mut tree = Tree::new(&widget as &dyn Widget<String, Theme, iced_tiny_skia::Renderer>);
let mut renderer = iced_tiny_skia::Renderer::new(Font::DEFAULT, Pixels::from(16u32));
let limits = Limits::new(Size::ZERO, Size::new(800.0, 600.0));
let node = Widget::<String, Theme, iced_tiny_skia::Renderer>::layout(
&mut widget,
&mut tree,
&renderer,
&limits,
);
let layout = Layout::new(&node);
let bounds = layout.bounds();
let over = mouse::Cursor::Available(Point::new(
bounds.x + bounds.width / 2.0,
bounds.y + bounds.height / 2.0,
));
let away = mouse::Cursor::Available(Point::new(400.0, 400.0));
let viewport = Rectangle::new(Point::ORIGIN, Size::new(800.0, 600.0));
let mut clipboard = clipboard::Null;
let style = Style::default();
let theme = Theme::Dark;
assert_eq!(
Widget::<String, Theme, iced_tiny_skia::Renderer>::mouse_interaction(
&widget, &tree, layout, away, &viewport, &renderer,
),
mouse::Interaction::default()
);
assert_eq!(
Widget::<String, Theme, iced_tiny_skia::Renderer>::mouse_interaction(
&widget, &tree, layout, over, &viewport, &renderer,
),
mouse::Interaction::Pointer
);
let mut messages = Vec::new();
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Mouse(mouse::Event::CursorMoved {
position: Point::new(10.0, 10.0),
}),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Window(window::Event::RedrawRequested(std::time::Instant::now())),
layout,
over,
&viewport,
&mut messages,
);
Widget::<String, Theme, iced_tiny_skia::Renderer>::draw(
&widget,
&tree,
&mut renderer,
&theme,
&style,
layout,
over,
&viewport,
);
assert!(Widget::<String, Theme, iced_tiny_skia::Renderer>::overlay(
&mut widget,
&mut tree,
layout,
&renderer,
&viewport,
Vector::ZERO,
)
.is_none());
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
layout,
away,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Window(window::Event::RedrawRequested(std::time::Instant::now())),
layout,
over,
&viewport,
&mut messages,
);
Widget::<String, Theme, iced_tiny_skia::Renderer>::draw(
&widget,
&tree,
&mut renderer,
&theme,
&style,
layout,
over,
&viewport,
);
assert!(Widget::<String, Theme, iced_tiny_skia::Renderer>::overlay(
&mut widget,
&mut tree,
layout,
&renderer,
&viewport,
Vector::ZERO,
)
.is_some());
{
let mut ov = Widget::<String, Theme, iced_tiny_skia::Renderer>::overlay(
&mut widget,
&mut tree,
layout,
&renderer,
&viewport,
Vector::ZERO,
)
.expect("open list");
let node = ov
.as_overlay_mut()
.layout(&renderer, Size::new(800.0, 600.0));
let ol = Layout::new(&node);
let at = Point::new(ol.bounds().x + 8.0, ol.bounds().y + 8.0);
let cursor = mouse::Cursor::Available(at);
{
let mut shell = iced::advanced::Shell::new(&mut messages);
ov.as_overlay_mut().update(
&Event::Mouse(mouse::Event::CursorMoved { position: at }),
ol,
cursor,
&renderer,
&mut clipboard,
&mut shell,
);
ov.as_overlay_mut().update(
&Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
ol,
cursor,
&renderer,
&mut clipboard,
&mut shell,
);
}
}
assert!(messages.contains(&"Open".to_string()));
messages.clear();
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
key_press(Named::ArrowDown),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
key_press(Named::Escape),
layout,
over,
&viewport,
&mut messages,
);
assert!(Widget::<String, Theme, iced_tiny_skia::Renderer>::overlay(
&mut widget,
&mut tree,
layout,
&renderer,
&viewport,
Vector::ZERO,
)
.is_none());
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
key_press(Named::Escape),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Touch(touch::Event::FingerPressed {
id: touch::Finger(0),
position: Point::new(bounds.x + 2.0, bounds.y + 2.0),
}),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Mouse(mouse::Event::CursorMoved {
position: Point::new(400.0, 400.0),
}),
layout,
away,
&viewport,
&mut messages,
);
assert!(messages.is_empty());
}
}