524 lines
17 KiB
Rust
524 lines
17 KiB
Rust
use std::{cell::RefCell, rc::Rc};
|
|
|
|
use gpui::{
|
|
Context, DefiniteLength, IntoElement, Modifiers, MouseButton, ParentElement as _, Render,
|
|
Styled as _, TestAppContext, VisualTestContext, Window, WindowHandle, div, point, px,
|
|
};
|
|
use gpui_native_core::menu::{Menu, MenuItem};
|
|
use gpui_native_theme::Theme;
|
|
|
|
struct Harness {
|
|
open: bool,
|
|
min_width: Option<DefiniteLength>,
|
|
changes: Rc<RefCell<Vec<bool>>>,
|
|
activated: Rc<RefCell<Vec<&'static str>>>,
|
|
}
|
|
|
|
impl Render for Harness {
|
|
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let changes = self.changes.clone();
|
|
let view = cx.entity();
|
|
let activated = self.activated.clone();
|
|
let mut menu = Menu::new("test-menu")
|
|
.open(self.open)
|
|
.on_change(move |next, _, cx| {
|
|
changes.borrow_mut().push(next);
|
|
view.update(cx, |harness, cx| {
|
|
harness.open = next;
|
|
cx.notify();
|
|
});
|
|
})
|
|
.trigger(|_, _| {
|
|
div()
|
|
.w(px(100.))
|
|
.h(px(32.))
|
|
.bg(gpui::black())
|
|
.into_any_element()
|
|
})
|
|
.items(move |_, _| {
|
|
vec![
|
|
cut_item(activated.clone()),
|
|
MenuItem::separator(),
|
|
copy_item(activated.clone()),
|
|
MenuItem::new("Unavailable").disabled(true).handler({
|
|
let activated = activated.clone();
|
|
move |_, _| record(&activated, "unavailable")
|
|
}),
|
|
delete_item(activated.clone()),
|
|
]
|
|
});
|
|
if let Some(width) = self.min_width {
|
|
menu = menu.min_width(width);
|
|
}
|
|
div().size_full().child(menu)
|
|
}
|
|
}
|
|
|
|
fn cut_item(activated: Rc<RefCell<Vec<&'static str>>>) -> MenuItem {
|
|
MenuItem::new("Cut")
|
|
.shortcut("cmd-x")
|
|
.handler(move |_, _| record(&activated, "cut"))
|
|
}
|
|
|
|
fn copy_item(activated: Rc<RefCell<Vec<&'static str>>>) -> MenuItem {
|
|
MenuItem::new("Copy").handler(move |_, _| record(&activated, "copy"))
|
|
}
|
|
|
|
fn delete_item(activated: Rc<RefCell<Vec<&'static str>>>) -> MenuItem {
|
|
MenuItem::new("Delete")
|
|
.destructive(true)
|
|
.handler(move |_, _| record(&activated, "delete"))
|
|
}
|
|
|
|
fn action_item(
|
|
label: &'static str,
|
|
key: &'static str,
|
|
activated: Rc<RefCell<Vec<&'static str>>>,
|
|
) -> MenuItem {
|
|
MenuItem::new(label).handler(move |_, _| record(&activated, key))
|
|
}
|
|
|
|
fn submenu_item(activated: Rc<RefCell<Vec<&'static str>>>) -> MenuItem {
|
|
MenuItem::new("Export").submenu(vec![
|
|
action_item("PNG", "png", activated.clone()),
|
|
action_item("PDF", "pdf", activated.clone()),
|
|
])
|
|
}
|
|
|
|
/// A menu with an Export row whose flyout holds PNG and PDF actions.
|
|
struct SubmenuHarness {
|
|
open: bool,
|
|
changes: Rc<RefCell<Vec<bool>>>,
|
|
activated: Rc<RefCell<Vec<&'static str>>>,
|
|
}
|
|
|
|
impl Render for SubmenuHarness {
|
|
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let changes = self.changes.clone();
|
|
let view = cx.entity();
|
|
let activated = self.activated.clone();
|
|
div().size_full().child(
|
|
Menu::new("test-submenu")
|
|
.open(self.open)
|
|
.on_change(move |next, _, cx| {
|
|
changes.borrow_mut().push(next);
|
|
view.update(cx, |harness, cx| {
|
|
harness.open = next;
|
|
cx.notify();
|
|
});
|
|
})
|
|
.trigger(|_, _| {
|
|
div()
|
|
.w(px(100.))
|
|
.h(px(32.))
|
|
.bg(gpui::black())
|
|
.into_any_element()
|
|
})
|
|
.items(move |_, _| {
|
|
vec![
|
|
action_item("Cut", "cut", activated.clone()),
|
|
submenu_item(activated.clone()),
|
|
action_item("Delete", "delete", activated.clone()),
|
|
]
|
|
}),
|
|
)
|
|
}
|
|
}
|
|
|
|
fn record(sink: &Rc<RefCell<Vec<&'static str>>>, what: &'static str) {
|
|
sink.borrow_mut().push(what);
|
|
}
|
|
|
|
type Changes = Rc<RefCell<Vec<bool>>>;
|
|
type Activated = Rc<RefCell<Vec<&'static str>>>;
|
|
|
|
fn menu_window(
|
|
open: bool,
|
|
) -> (
|
|
TestAppContext,
|
|
VisualTestContext,
|
|
WindowHandle<Harness>,
|
|
Changes,
|
|
Activated,
|
|
) {
|
|
menu_window_with(open, None)
|
|
}
|
|
|
|
fn menu_window_with(
|
|
open: bool,
|
|
min_width: Option<DefiniteLength>,
|
|
) -> (
|
|
TestAppContext,
|
|
VisualTestContext,
|
|
WindowHandle<Harness>,
|
|
Changes,
|
|
Activated,
|
|
) {
|
|
let mut cx = TestAppContext::single();
|
|
cx.update(Theme::init);
|
|
let changes = Rc::new(RefCell::new(Vec::new()));
|
|
let activated = Rc::new(RefCell::new(Vec::new()));
|
|
let harness_changes = changes.clone();
|
|
let harness_activated = activated.clone();
|
|
let window = cx.add_window(move |_, _| Harness {
|
|
open,
|
|
min_width,
|
|
changes: harness_changes,
|
|
activated: harness_activated,
|
|
});
|
|
let mut visual = VisualTestContext::from_window(window.into(), &cx);
|
|
visual.update(|window, cx| {
|
|
window.draw(cx).clear(cx);
|
|
});
|
|
(cx, visual, window, changes, activated)
|
|
}
|
|
|
|
fn submenu_window(open: bool) -> (TestAppContext, VisualTestContext, Changes, Activated) {
|
|
let mut cx = TestAppContext::single();
|
|
cx.update(Theme::init);
|
|
let changes = Rc::new(RefCell::new(Vec::new()));
|
|
let activated = Rc::new(RefCell::new(Vec::new()));
|
|
let harness_changes = changes.clone();
|
|
let harness_activated = activated.clone();
|
|
let window = cx.add_window(move |_, _| SubmenuHarness {
|
|
open,
|
|
changes: harness_changes,
|
|
activated: harness_activated,
|
|
});
|
|
let mut visual = VisualTestContext::from_window(window.into(), &cx);
|
|
visual.update(|window, cx| {
|
|
window.draw(cx).clear(cx);
|
|
});
|
|
(cx, visual, changes, activated)
|
|
}
|
|
|
|
fn draw(visual: &mut VisualTestContext) {
|
|
visual.update(|window, cx| {
|
|
window.draw(cx).clear(cx);
|
|
});
|
|
}
|
|
|
|
fn click(visual: &mut VisualTestContext, position: gpui::Point<gpui::Pixels>) {
|
|
visual.simulate_mouse_down(position, MouseButton::Left, Modifiers::default());
|
|
visual.simulate_mouse_up(position, MouseButton::Left, Modifiers::default());
|
|
}
|
|
|
|
fn hover(visual: &mut VisualTestContext, position: gpui::Point<gpui::Pixels>) {
|
|
visual.simulate_mouse_move(position, None, Modifiers::default());
|
|
}
|
|
|
|
fn center(bounds: gpui::Bounds<gpui::Pixels>) -> gpui::Point<gpui::Pixels> {
|
|
point(
|
|
bounds.origin.x + bounds.size.width / 2.,
|
|
bounds.origin.y + bounds.size.height / 2.,
|
|
)
|
|
}
|
|
|
|
/// Every action row renders at the platform's stated menu row height,
|
|
/// whatever its content — the metric is the whole row, not a floor under
|
|
/// padding. Item 1 of the harness menu is a separator, so it is skipped.
|
|
#[test]
|
|
fn rows_render_at_the_stated_menu_row_height() {
|
|
let (cx, mut visual, _window, _changes, _activated) = menu_window(true);
|
|
|
|
let stated = cx.update(|cx| Theme::global(cx).sizes.medium.menu_item_height);
|
|
for index in [0, 2, 3, 4] {
|
|
let selector: &'static str = Box::leak(format!("menu-item-{index}").into_boxed_str());
|
|
let row = visual
|
|
.debug_bounds(selector)
|
|
.unwrap_or_else(|| panic!("row {index} should have been laid out"));
|
|
// Painted bounds are snapped to device pixels; allow half a pixel.
|
|
assert!(
|
|
(row.size.height - stated).abs() <= px(0.5),
|
|
"row {index} is {:?} tall, stated menu row height is {stated:?}",
|
|
row.size.height
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn arrow_navigation_skips_separators_and_disabled_items() {
|
|
let (_cx, mut visual, _window, changes, activated) = menu_window(true);
|
|
|
|
// Nothing is highlighted when the menu opens; down arms the first
|
|
// selectable item, the next down crosses the separator to Copy, and
|
|
// enter activates it, closing the menu.
|
|
visual.simulate_keystrokes("down down enter");
|
|
draw(&mut visual);
|
|
assert_eq!(*activated.borrow(), vec!["copy"]);
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
|
|
// Reopen: pointer opens highlight nothing again, and end jumps straight
|
|
// to the last selectable item, over the separator and the disabled row.
|
|
click(&mut visual, point(px(10.), px(16.)));
|
|
draw(&mut visual);
|
|
visual.simulate_keystrokes("end");
|
|
visual.simulate_keystrokes("enter");
|
|
assert_eq!(*activated.borrow(), vec!["copy", "delete"]);
|
|
assert_eq!(*changes.borrow(), vec![false, true, false]);
|
|
}
|
|
|
|
#[test]
|
|
fn enter_without_navigation_activates_nothing() {
|
|
let (_cx, mut visual, _window, changes, activated) = menu_window(true);
|
|
|
|
// A pointer-opened menu arms no row, so enter cannot fire one and the
|
|
// menu stays open.
|
|
visual.simulate_keystrokes("enter");
|
|
draw(&mut visual);
|
|
assert!(activated.borrow().is_empty());
|
|
assert!(changes.borrow().is_empty(), "the menu stays open");
|
|
}
|
|
|
|
#[test]
|
|
fn escape_dismisses_without_activating() {
|
|
let (_cx, mut visual, _window, changes, activated) = menu_window(true);
|
|
|
|
visual.simulate_keystrokes("escape");
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
assert!(activated.borrow().is_empty());
|
|
|
|
// A closed menu is inert.
|
|
draw(&mut visual);
|
|
visual.simulate_keystrokes("escape");
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
}
|
|
|
|
#[test]
|
|
fn clicking_outside_dismisses_and_swallows_the_click() {
|
|
let (_cx, mut visual, _window, changes, activated) = menu_window(true);
|
|
|
|
click(&mut visual, point(px(600.), px(600.)));
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
assert!(activated.borrow().is_empty());
|
|
|
|
draw(&mut visual);
|
|
click(&mut visual, point(px(600.), px(600.)));
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
}
|
|
|
|
#[test]
|
|
fn clicking_an_item_activates_and_closes() {
|
|
let (_cx, mut visual, _window, changes, activated) = menu_window(true);
|
|
|
|
// The first row hangs just below the trigger's panel padding.
|
|
click(&mut visual, point(px(60.), px(50.)));
|
|
assert_eq!(*activated.borrow(), vec!["cut"]);
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
}
|
|
|
|
#[test]
|
|
fn right_arrow_opens_the_submenu_and_enter_within_activates_through() {
|
|
let (_cx, mut visual, changes, activated) = submenu_window(true);
|
|
|
|
// down arms Cut, the next down reaches Export, right opens its flyout
|
|
// with the first row armed.
|
|
visual.simulate_keystrokes("down down right");
|
|
draw(&mut visual);
|
|
assert!(visual.debug_bounds("submenu-item-0").is_some());
|
|
assert!(changes.borrow().is_empty(), "the menu stays open");
|
|
assert!(activated.borrow().is_empty());
|
|
|
|
// Enter inside the flyout fires PNG and closes the whole menu.
|
|
visual.simulate_keystrokes("enter");
|
|
draw(&mut visual);
|
|
assert_eq!(*activated.borrow(), vec!["png"]);
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
assert!(visual.debug_bounds("submenu-item-0").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn enter_on_a_submenu_row_opens_it_and_navigates_within() {
|
|
let (_cx, mut visual, changes, activated) = submenu_window(true);
|
|
|
|
visual.simulate_keystrokes("down down enter");
|
|
draw(&mut visual);
|
|
assert!(visual.debug_bounds("submenu-item-0").is_some());
|
|
assert!(
|
|
changes.borrow().is_empty(),
|
|
"enter opens, it does not close"
|
|
);
|
|
|
|
// The flyout armed PNG; down reaches PDF and enter fires it.
|
|
visual.simulate_keystrokes("down enter");
|
|
draw(&mut visual);
|
|
assert_eq!(*activated.borrow(), vec!["pdf"]);
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
}
|
|
|
|
#[test]
|
|
fn left_closes_the_submenu_and_returns_to_the_menu() {
|
|
let (_cx, mut visual, changes, activated) = submenu_window(true);
|
|
|
|
visual.simulate_keystrokes("down down right");
|
|
draw(&mut visual);
|
|
visual.simulate_keystrokes("left");
|
|
draw(&mut visual);
|
|
assert!(visual.debug_bounds("submenu-item-0").is_none());
|
|
assert!(changes.borrow().is_empty(), "the menu stays open");
|
|
assert!(activated.borrow().is_empty());
|
|
|
|
// Navigation resumes in the parent: down reaches Delete, enter fires it.
|
|
visual.simulate_keystrokes("down enter");
|
|
draw(&mut visual);
|
|
assert_eq!(*activated.borrow(), vec!["delete"]);
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
}
|
|
|
|
#[test]
|
|
fn escape_closes_the_submenu_then_the_menu() {
|
|
let (_cx, mut visual, changes, activated) = submenu_window(true);
|
|
|
|
visual.simulate_keystrokes("down down right");
|
|
draw(&mut visual);
|
|
visual.simulate_keystrokes("escape");
|
|
draw(&mut visual);
|
|
assert!(visual.debug_bounds("submenu-item-0").is_none());
|
|
assert!(
|
|
changes.borrow().is_empty(),
|
|
"the first escape only closes the flyout"
|
|
);
|
|
|
|
visual.simulate_keystrokes("escape");
|
|
draw(&mut visual);
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
assert!(activated.borrow().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn clicking_a_submenu_row_opens_the_flyout_and_a_flyout_action_closes_the_menu() {
|
|
let (_cx, mut visual, changes, activated) = submenu_window(true);
|
|
|
|
let row = visual
|
|
.debug_bounds("menu-item-1")
|
|
.unwrap_or_else(|| panic!("the Export row should have been laid out"));
|
|
click(
|
|
&mut visual,
|
|
point(
|
|
row.origin.x + row.size.width / 2.,
|
|
row.origin.y + row.size.height / 2.,
|
|
),
|
|
);
|
|
draw(&mut visual);
|
|
assert!(visual.debug_bounds("submenu-item-0").is_some());
|
|
assert!(changes.borrow().is_empty());
|
|
|
|
let png = visual
|
|
.debug_bounds("submenu-item-0")
|
|
.unwrap_or_else(|| panic!("the PNG row should have been laid out"));
|
|
click(
|
|
&mut visual,
|
|
point(
|
|
png.origin.x + png.size.width / 2.,
|
|
png.origin.y + png.size.height / 2.,
|
|
),
|
|
);
|
|
draw(&mut visual);
|
|
assert_eq!(*activated.borrow(), vec!["png"]);
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_click_inside_the_flyout_padding_does_not_dismiss_the_menu() {
|
|
let (_cx, mut visual, changes, _activated) = submenu_window(true);
|
|
|
|
let row = visual.debug_bounds("menu-item-1").unwrap();
|
|
click(
|
|
&mut visual,
|
|
point(
|
|
row.origin.x + row.size.width / 2.,
|
|
row.origin.y + row.size.height / 2.,
|
|
),
|
|
);
|
|
draw(&mut visual);
|
|
|
|
// The flyout's own padding belongs to the flyout, not to the dismissal
|
|
// listener of the panel behind it.
|
|
let panel = visual.debug_bounds("submenu-panel").unwrap();
|
|
click(
|
|
&mut visual,
|
|
point(
|
|
panel.origin.x + px(4.),
|
|
panel.size.height + panel.origin.y - px(2.),
|
|
),
|
|
);
|
|
draw(&mut visual);
|
|
assert!(changes.borrow().is_empty(), "the flyout stays open");
|
|
assert!(visual.debug_bounds("submenu-item-0").is_some());
|
|
|
|
// A click outside everything still closes the whole menu.
|
|
click(&mut visual, point(px(600.), px(600.)));
|
|
assert_eq!(*changes.borrow(), vec![false]);
|
|
}
|
|
|
|
#[test]
|
|
fn hovering_a_submenu_row_opens_its_flyout_and_an_action_row_closes_it() {
|
|
let (_cx, mut visual, changes, _activated) = submenu_window(true);
|
|
|
|
let export = visual.debug_bounds("menu-item-1").unwrap();
|
|
hover(&mut visual, center(export));
|
|
draw(&mut visual);
|
|
assert!(
|
|
visual.debug_bounds("submenu-item-0").is_some(),
|
|
"hover opens the flyout"
|
|
);
|
|
assert!(changes.borrow().is_empty(), "the menu stays open");
|
|
|
|
let cut = visual.debug_bounds("menu-item-0").unwrap();
|
|
hover(&mut visual, center(cut));
|
|
draw(&mut visual);
|
|
assert!(
|
|
visual.debug_bounds("submenu-item-0").is_none(),
|
|
"hovering an action row closes the flyout"
|
|
);
|
|
assert!(changes.borrow().is_empty(), "the menu stays open");
|
|
}
|
|
|
|
#[test]
|
|
fn the_flyout_overlaps_the_parent_from_the_rows_right_edge() {
|
|
let (_cx, mut visual, _changes, _activated) = submenu_window(true);
|
|
|
|
let export = visual.debug_bounds("menu-item-1").unwrap();
|
|
hover(&mut visual, center(export));
|
|
draw(&mut visual);
|
|
|
|
let parent = visual.debug_bounds("menu-panel").unwrap();
|
|
let flyout = visual.debug_bounds("submenu-panel").unwrap();
|
|
let parent_right = parent.origin.x + parent.size.width;
|
|
let row_right = export.origin.x + export.size.width;
|
|
// macOS style: the flyout covers the parent's trailing padding, starting
|
|
// at the row's right edge.
|
|
assert!(
|
|
flyout.origin.x < parent_right - px(1.),
|
|
"the flyout starts at {:?}, inside the parent edge at {:?}",
|
|
flyout.origin.x,
|
|
parent_right
|
|
);
|
|
assert!(
|
|
flyout.origin.x >= row_right - px(1.),
|
|
"the flyout starts at {:?}, at or after the row's right edge {:?}",
|
|
flyout.origin.x,
|
|
row_right
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_custom_min_width_overrides_the_default_panel_width() {
|
|
let (_cx, mut visual, _window, _changes, _activated) = menu_window(true);
|
|
let default_width = visual.debug_bounds("menu-panel").unwrap().size.width;
|
|
|
|
let (_cx, mut visual, _window, _changes, _activated) =
|
|
menu_window_with(true, Some(px(320.).into()));
|
|
let width = visual.debug_bounds("menu-panel").unwrap().size.width;
|
|
// Painted bounds are snapped to device pixels; allow half a pixel.
|
|
assert!(
|
|
(width - px(320.)).abs() <= px(0.5),
|
|
"the panel is {width:?} wide, expected the 320px minimum"
|
|
);
|
|
assert!(
|
|
width > default_width,
|
|
"the default panel is {:?} wide and should be narrower",
|
|
default_width
|
|
);
|
|
}
|