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 std::cell::RefCell;
use std::rc::Rc;
use crate::style;
use crate::theme::{hover_fill, pressed_fill, Tokens};
#[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),
}
}
fn is_wide(c: char) -> bool {
matches!(
c,
'\u{1100}'..='\u{115F}'
| '\u{2E80}'..='\u{303F}'
| '\u{3040}'..='\u{30FF}'
| '\u{3100}'..='\u{312F}'
| '\u{3130}'..='\u{318F}'
| '\u{3190}'..='\u{33FF}'
| '\u{3400}'..='\u{4DBF}'
| '\u{4E00}'..='\u{9FFF}'
| '\u{A960}'..='\u{A97F}'
| '\u{AC00}'..='\u{D7A3}'
| '\u{F900}'..='\u{FAFF}'
| '\u{FE10}'..='\u{FE19}'
| '\u{FE30}'..='\u{FE6F}'
| '\u{FF00}'..='\u{FF60}'
| '\u{FFE0}'..='\u{FFE6}'
| '\u{20000}'..='\u{2FFFD}'
| '\u{30000}'..='\u{3FFFD}'
)
}
fn is_arabic_or_hebrew(c: char) -> bool {
matches!(
c,
'\u{0590}'..='\u{05FF}'
| '\u{0600}'..='\u{06FF}'
| '\u{0750}'..='\u{077F}'
| '\u{08A0}'..='\u{08FF}'
| '\u{FB1D}'..='\u{FDFF}'
| '\u{FE70}'..='\u{FEFF}'
)
}
pub fn text_advance(s: &str, size: f32) -> f32 {
s.chars()
.map(|c| {
if is_wide(c) || is_arabic_or_hebrew(c) {
size
} else {
size * 0.62
}
})
.sum()
}
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,
on_open: &dyn Fn(bool) -> M,
option: String,
) -> (M, M) {
*is_open = false;
(on_open(false), on_select(option))
}
struct NotifyClose<'a, Message, Theme, Renderer> {
content: overlay::Element<'a, Message, Theme, Renderer>,
pending_pick: Rc<RefCell<Option<Message>>>,
}
impl<Message, Theme, Renderer> overlay::Overlay<Message, Theme, Renderer>
for NotifyClose<'_, Message, Theme, Renderer>
where
Renderer: renderer::Renderer,
{
fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
self.content.as_overlay_mut().layout(renderer, bounds)
}
fn draw(
&self,
renderer: &mut Renderer,
theme: &Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor: mouse::Cursor,
) {
self.content
.as_overlay()
.draw(renderer, theme, style, layout, cursor);
}
fn operate(
&mut self,
layout: Layout<'_>,
renderer: &Renderer,
operation: &mut dyn iced::advanced::widget::Operation,
) {
self.content
.as_overlay_mut()
.operate(layout, renderer, operation);
}
fn update(
&mut self,
event: &Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) {
self.content
.as_overlay_mut()
.update(event, layout, cursor, renderer, clipboard, shell);
if let Some(pick) = self.pending_pick.borrow_mut().take() {
shell.publish(pick);
}
}
fn mouse_interaction(
&self,
layout: Layout<'_>,
cursor: mouse::Cursor,
renderer: &Renderer,
) -> mouse::Interaction {
self.content
.as_overlay()
.mouse_interaction(layout, cursor, renderer)
}
fn overlay<'b>(
&'b mut self,
layout: Layout<'b>,
renderer: &Renderer,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
self.content.as_overlay_mut().overlay(layout, renderer)
}
fn index(&self) -> f32 {
self.content.as_overlay().index()
}
}
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,
on_open: impl Fn(bool) -> M + 'a,
tok: Tokens,
) -> Element<'a, M> {
MenuTitle::new(title.into(), options, on_select, on_open, tok).into()
}
struct MenuTitle<'a, Message> {
title: String,
options: Vec<String>,
on_select: Box<dyn Fn(String) -> Message + 'a>,
on_open: Box<dyn Fn(bool) -> Message + 'a>,
tok: Tokens,
padding: Padding,
text_size: Pixels,
menu_class: menu::StyleFn<'a, Theme>,
last_status: Option<TitleStatus>,
pending_pick: Rc<RefCell<Option<Message>>>,
}
impl<'a, Message> MenuTitle<'a, Message> {
fn new(
title: String,
options: Vec<String>,
on_select: impl Fn(String) -> Message + 'a,
on_open: impl Fn(bool) -> Message + 'a,
tok: Tokens,
) -> Self {
Self {
title,
options,
on_select: Box::new(on_select),
on_open: Box::new(on_open),
tok,
padding: Padding::from(TITLE_PAD),
text_size: Pixels::from(tok.body()),
menu_class: Box::new(style::overlay_menu_style(tok)),
last_status: None,
pending_pick: Rc::new(RefCell::new(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.publish((self.on_open)(next));
shell.capture_event();
}
}
Event::Keyboard(keyboard::Event::KeyPressed { key, .. }) if state.is_open => {
match key {
keyboard::Key::Named(Named::Escape) if escape_closes(state.is_open) => {
state.is_open = false;
shell.publish((self.on_open)(false));
shell.capture_event();
}
keyboard::Key::Named(Named::ArrowDown) => {
let n = self.options.len();
if n > 0 {
let i = state.hovered_option.unwrap_or(n - 1);
state.hovered_option = Some((i + 1) % n);
shell.capture_event();
shell.request_redraw();
}
}
keyboard::Key::Named(Named::ArrowUp) => {
let n = self.options.len();
if n > 0 {
let i = state.hovered_option.unwrap_or(0);
state.hovered_option = Some((i + n - 1) % n);
shell.capture_event();
shell.request_redraw();
}
}
keyboard::Key::Named(Named::Enter) => {
if let Some(i) = state.hovered_option {
if let Some(opt) = self.options.get(i).cloned() {
let (shut, pick) = pick_and_close(
&mut state.is_open,
self.on_select.as_ref(),
self.on_open.as_ref(),
opt,
);
shell.publish(shut);
shell.publish(pick);
shell.capture_event();
}
}
}
keyboard::Key::Character(c) => {
let ch = c.chars().next().map(|x| x.to_ascii_lowercase());
if let Some(ch) = ch {
if let Some(i) = self.options.iter().position(|o| {
o.chars()
.next()
.is_some_and(|x| x.to_ascii_lowercase() == ch)
}) {
state.hovered_option = Some(i);
shell.capture_event();
shell.request_redraw();
}
}
}
_ => {}
}
}
_ => {}
}
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: self.tok.radius(crate::m3::shape::Component::AppBar),
},
..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::None,
},
Point::new(bounds.x + self.padding.left, bounds.center_y()),
self.tok.scheme().on_surface,
*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 on_open = &self.on_open;
let pending = Rc::clone(&self.pending_pick);
let is_open = &mut state.is_open;
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,
move |option| {
let (shut, pick) =
pick_and_close(is_open, on_select.as_ref(), on_open.as_ref(), option);
*pending.borrow_mut() = Some(pick);
shut
},
None,
&self.menu_class,
)
.width(width)
.padding(self.padding)
.font(font)
.text_size(self.text_size);
Some(overlay::Element::new(Box::new(NotifyClose {
content: menu.overlay(
layout.position() + translation,
*viewport,
bounds.height,
Length::Shrink,
),
pending_pick: Rc::clone(&self.pending_pick),
})))
}
}
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)
}
}
pub fn split_more<'a, M: Clone + 'a>(
items: Vec<(String, M)>,
tok: Tokens,
disabled: bool,
height: f32,
) -> Element<'a, M> {
SplitMore::new(items, tok, disabled, height).into()
}
struct SplitMore<'a, Message> {
labels: Vec<String>,
on_select: Box<dyn Fn(String) -> Message + 'a>,
tok: Tokens,
disabled: bool,
height: f32,
menu_class: menu::StyleFn<'a, Theme>,
last_status: Option<TitleStatus>,
}
impl<'a, Message: Clone + 'a> SplitMore<'a, Message> {
fn new(items: Vec<(String, Message)>, tok: Tokens, disabled: bool, height: f32) -> Self {
let labels: Vec<String> = items.iter().map(|(s, _)| s.clone()).collect();
let on_select = Box::new(move |option: String| {
items
.iter()
.find(|(s, _)| s == &option)
.map(|(_, m)| m.clone())
.expect("split menu option matches a label")
});
Self {
labels,
on_select,
tok,
disabled,
height,
menu_class: Box::new(style::overlay_menu_style(tok)),
last_status: None,
}
}
}
impl<'a, Message, Renderer> Widget<Message, Theme, Renderer> for SplitMore<'a, Message>
where
Message: Clone + 'a,
Renderer: text::Renderer<Font = iced::Font> + iced::advanced::svg::Renderer + '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::Fixed(self.height),
height: Length::Fixed(self.height),
}
}
fn layout(
&mut self,
_tree: &mut Tree,
_renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let size = limits
.width(Length::Fixed(self.height))
.height(Length::Fixed(self.height))
.resolve(
Length::Fixed(self.height),
Length::Fixed(self.height),
Size::new(self.height, self.height),
);
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,
) {
if self.disabled || self.labels.is_empty() {
return;
}
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();
shell.request_redraw();
}
}
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();
shell.request_redraw();
}
_ => {}
}
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 !self.disabled && 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,
) {
use crate::icon::Icon;
use iced::advanced::svg;
let bounds = layout.bounds();
let status = self.last_status.unwrap_or(TitleStatus::Active);
let fill = if self.disabled {
Color::TRANSPARENT
} else {
title_fill(self.tok, status)
};
renderer.fill_quad(
renderer::Quad {
bounds,
border: iced::Border {
color: Color::TRANSPARENT,
width: 0.0,
radius: self.tok.radius(crate::m3::shape::Component::AppBar),
},
..renderer::Quad::default()
},
Background::Color(fill),
);
let side = 16.0_f32.min(bounds.width).min(bounds.height);
let icon_bounds = Rectangle {
x: bounds.center_x() - side / 2.0,
y: bounds.center_y() - side / 2.0,
width: side,
height: side,
};
let handle = svg::Handle::from_memory(Icon::Chevron.bytes());
let s = self.tok.scheme();
let color = if self.disabled {
s.on_surface_variant
} else {
s.on_surface
};
renderer.draw_svg(svg::Svg::new(handle).color(color), icon_bounds, *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>> {
if self.disabled || self.labels.is_empty() {
return None;
}
let state = tree.state.downcast_mut::<State>();
if !state.is_open {
return None;
}
let bounds = layout.bounds();
let font = renderer.default_font();
let pad = Padding::from(TITLE_PAD);
let width = overlay_list_width(&self.labels, pad, self.tok.body());
let on_select = &self.on_select;
let menu = Menu::new(
&mut state.menu,
&self.labels,
&mut state.hovered_option,
|option| {
state.is_open = false;
on_select(option)
},
None,
&self.menu_class,
)
.width(width)
.padding(pad)
.font(font)
.text_size(Pixels::from(self.tok.body()));
Some(menu.overlay(
layout.position() + translation,
*viewport,
bounds.height,
Length::Shrink,
))
}
}
impl<'a, Message: Clone + 'a> From<SplitMore<'a, Message>> for Element<'a, Message> {
fn from(value: SplitMore<'a, Message>) -> Self {
Self::new(value)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::theme::named;
fn must(ok: bool, msg: impl std::fmt::Display) {
if !ok {
panic!("{msg}");
}
}
#[test]
#[should_panic(expected = "cover-must")]
fn must_rejects_a_failed_check() {
must(false, "cover-must");
}
#[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));
let file_cjk = title_extents("文件", pad, size, 18.0);
let cjk = "two CJK letters need two em so the title does not wrap";
assert!(text_advance("文件", size) >= size * 2.0, "{cjk}");
let latin = "wide glyphs must not use the Latin 0.62 em factor";
assert!(text_advance("文件", size) > 2.0 * size * 0.62, "{latin}");
assert!(file_cjk.width >= pad.x() + size * 2.0);
assert!(text_advance("保存", size) >= size * 2.0);
let arabic = "عرض";
assert!(text_advance(arabic, size) >= size * 3.0);
assert!(title_extents(arabic, pad, size, 18.0).width >= pad.x() + size * 3.0);
assert!(text_advance("שלום", size) >= size * 4.0);
for ch in ['\u{FB1D}', '\u{FE70}'] {
assert_eq!(text_advance(&ch.to_string(), size), size);
}
let draw = include_str!("menubar.rs")
.split("content: self.title.clone()")
.nth(1)
.unwrap()
.split("fn overlay(")
.next()
.unwrap();
assert!(draw.contains("Wrapping::None"));
for ch in [
'\u{A960}',
'한',
'\u{F900}',
'\u{FE10}',
'\u{FE30}',
'A',
'\u{FFE0}',
'\u{20000}',
'\u{30000}',
] {
let s = ch.to_string();
let msg = format!("wide {ch:?} must use one em");
assert!(text_advance(&s, size) >= size, "{msg}");
}
}
#[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;
let on_open = |opened: bool| if opened { 10u8 } else { 11 };
let (shut, picked) = pick_and_close(&mut open, &pick, &on_open, "Save".into());
assert_eq!(shut, 11);
assert_eq!(picked, 2);
assert!(!open);
let _: Element<'_, u8> =
drop_menu("File", vec!["Open".into(), "Save".into()], pick, |_| 0, 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);
let _: Element<'_, u8> = split_more(
vec![("Save As…".into(), 1u8), ("Export…".into(), 2)],
tok,
false,
30.0,
);
let _: Element<'_, u8> = split_more(vec![], tok, true, 30.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,
|open| if open { "OPEN".into() } else { "SHUT".into() },
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());
must(
messages.iter().any(|m| m == "OPEN"),
format!("opening the title publishes on_open(true), got {messages:?}"),
);
{
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);
ov.as_overlay()
.draw(&mut renderer, &theme, &style, ol, over);
let _ = ov.as_overlay().mouse_interaction(ol, over, &renderer);
struct Nop;
impl iced::advanced::widget::Operation for Nop {
fn traverse(
&mut self,
operate: &mut dyn FnMut(&mut dyn iced::advanced::widget::Operation),
) {
operate(self);
}
}
let mut nop = Nop;
iced::advanced::widget::Operation::traverse(&mut nop, &mut |op| {
ov.as_overlay_mut().operate(ol, &renderer, op);
});
let _ = ov.as_overlay_mut().overlay(ol, &renderer);
let _ = ov.as_overlay().index();
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()));
must(
messages.iter().any(|m| m == "SHUT"),
format!("picking a row publishes on_open(false), got {messages:?}"),
);
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,
);
must(
messages.iter().any(|m| m == "SHUT"),
format!("Escape publishes on_open(false), got {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,
key_press(Named::Enter),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Keyboard(keyboard::Event::KeyPressed {
key: keyboard::Key::Character("z".into()),
modified_key: keyboard::Key::Character("z".into()),
physical_key: keyboard::key::Physical::Unidentified(
keyboard::key::NativeCode::Unidentified,
),
location: keyboard::Location::Standard,
modifiers: keyboard::Modifiers::default(),
text: Some("z".into()),
repeat: false,
}),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
key_press(Named::F1),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Keyboard(keyboard::Event::KeyPressed {
key: keyboard::Key::Character("".into()),
modified_key: keyboard::Key::Character("".into()),
physical_key: keyboard::key::Physical::Unidentified(
keyboard::key::NativeCode::Unidentified,
),
location: keyboard::Location::Standard,
modifiers: keyboard::Modifiers::default(),
text: None,
repeat: false,
}),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
Event::Keyboard(keyboard::Event::KeyPressed {
key: keyboard::Key::Character("s".into()),
modified_key: keyboard::Key::Character("s".into()),
physical_key: keyboard::key::Physical::Unidentified(
keyboard::key::NativeCode::Unidentified,
),
location: keyboard::Location::Standard,
modifiers: keyboard::Modifiers::default(),
text: Some("s".into()),
repeat: false,
}),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
key_press(Named::ArrowUp),
layout,
over,
&viewport,
&mut messages,
);
pump_title(
&mut widget,
&mut tree,
&renderer,
&mut clipboard,
key_press(Named::Enter),
layout,
over,
&viewport,
&mut messages,
);
assert!(messages
.iter()
.any(|s| s == "Open" || s.starts_with("Save")));
messages.clear();
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,
);
must(
messages.iter().all(|m| m == "OPEN" || m == "SHUT"),
format!("only open/close messages, got {messages:?}"),
);
}
#[test]
fn split_more_opens_overlay_and_selects() {
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 = SplitMore::new(
vec![("Save As…".into(), 1u8), ("Export…".into(), 2)],
tok,
false,
30.0,
);
let mut tree = Tree::new(&widget as &dyn Widget<u8, 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::<u8, 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::<u8, Theme, iced_tiny_skia::Renderer>::mouse_interaction(
&widget, &tree, layout, away, &viewport, &renderer,
),
mouse::Interaction::default()
);
assert_eq!(
Widget::<u8, Theme, iced_tiny_skia::Renderer>::mouse_interaction(
&widget, &tree, layout, over, &viewport, &renderer,
),
mouse::Interaction::Pointer
);
let mut messages = Vec::new();
{
let mut shell = Shell::new(&mut messages);
Widget::<u8, Theme, iced_tiny_skia::Renderer>::update(
&mut widget,
&mut tree,
&Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
layout,
away,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
}
assert!(Widget::<u8, Theme, iced_tiny_skia::Renderer>::overlay(
&mut widget,
&mut tree,
layout,
&renderer,
&viewport,
Vector::ZERO,
)
.is_none());
{
let mut shell = Shell::new(&mut messages);
Widget::<u8, Theme, iced_tiny_skia::Renderer>::update(
&mut widget,
&mut tree,
&Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
layout,
over,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
Widget::<u8, Theme, iced_tiny_skia::Renderer>::update(
&mut widget,
&mut tree,
&Event::Window(window::Event::RedrawRequested(std::time::Instant::now())),
layout,
over,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
}
Widget::<u8, Theme, iced_tiny_skia::Renderer>::draw(
&widget,
&tree,
&mut renderer,
&theme,
&style,
layout,
over,
&viewport,
);
assert!(Widget::<u8, Theme, iced_tiny_skia::Renderer>::overlay(
&mut widget,
&mut tree,
layout,
&renderer,
&viewport,
Vector::ZERO,
)
.is_some());
{
let mut ov = Widget::<u8, Theme, iced_tiny_skia::Renderer>::overlay(
&mut widget,
&mut tree,
layout,
&renderer,
&viewport,
Vector::ZERO,
)
.expect("open overflow");
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(&1));
{
let mut shell = Shell::new(&mut messages);
Widget::<u8, Theme, iced_tiny_skia::Renderer>::update(
&mut widget,
&mut tree,
&Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
layout,
over,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
Widget::<u8, Theme, iced_tiny_skia::Renderer>::update(
&mut widget,
&mut tree,
&key_press(Named::Escape),
layout,
over,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
}
assert!(Widget::<u8, Theme, iced_tiny_skia::Renderer>::overlay(
&mut widget,
&mut tree,
layout,
&renderer,
&viewport,
Vector::ZERO,
)
.is_none());
{
let mut shell = Shell::new(&mut messages);
Widget::<u8, Theme, iced_tiny_skia::Renderer>::update(
&mut widget,
&mut tree,
&Event::Touch(touch::Event::FingerPressed {
id: touch::Finger(0),
position: Point::new(bounds.x + 2.0, bounds.y + 2.0),
}),
layout,
over,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
}
let mut dead = SplitMore::new(vec![("X".into(), 9u8)], tok, true, 30.0);
let mut dead_tree = Tree::new(&dead as &dyn Widget<u8, Theme, iced_tiny_skia::Renderer>);
let dead_node = Widget::<u8, Theme, iced_tiny_skia::Renderer>::layout(
&mut dead,
&mut dead_tree,
&renderer,
&limits,
);
let dead_layout = Layout::new(&dead_node);
{
let mut shell = Shell::new(&mut messages);
Widget::<u8, Theme, iced_tiny_skia::Renderer>::update(
&mut dead,
&mut dead_tree,
&Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
dead_layout,
over,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
}
Widget::<u8, Theme, iced_tiny_skia::Renderer>::draw(
&dead,
&dead_tree,
&mut renderer,
&theme,
&style,
dead_layout,
over,
&viewport,
);
assert!(Widget::<u8, Theme, iced_tiny_skia::Renderer>::overlay(
&mut dead,
&mut dead_tree,
dead_layout,
&renderer,
&viewport,
Vector::ZERO,
)
.is_none());
let mut empty = SplitMore::new(Vec::<(String, u8)>::new(), tok, false, 30.0);
let mut empty_tree = Tree::new(&empty as &dyn Widget<u8, Theme, iced_tiny_skia::Renderer>);
let empty_node = Widget::<u8, Theme, iced_tiny_skia::Renderer>::layout(
&mut empty,
&mut empty_tree,
&renderer,
&limits,
);
let empty_layout = Layout::new(&empty_node);
{
let mut shell = Shell::new(&mut messages);
Widget::<u8, Theme, iced_tiny_skia::Renderer>::update(
&mut empty,
&mut empty_tree,
&Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
empty_layout,
over,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
}
assert!(Widget::<u8, Theme, iced_tiny_skia::Renderer>::overlay(
&mut empty,
&mut empty_tree,
empty_layout,
&renderer,
&viewport,
Vector::ZERO,
)
.is_none());
}
}