Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

ui: Support persistent submenu refresh (#66336)

Danilo Lealb61f33f8b6bf
diff --git a/crates/ui/src/components/context_menu.rs b/crates/ui/src/components/context_menu.rs
index 1216c5190ee..3ff74bfc6c6 100644
--- a/crates/ui/src/components/context_menu.rs
+++ b/crates/ui/src/components/context_menu.rs
@@ -19,6 +19,8 @@ use std::{
use theme::BufferLineHeight;
use web_time::Instant;
+mod preview;
+
const CONTEXT_MENU_MIN_WIDTH: Pixels = px(200.);
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -60,12 +62,7 @@ pub enum ContextMenuItem {
documentation_aside: Option<DocumentationAside>,
},
EmbeddedView(AnyView),
- Submenu {
- label: SharedString,
- icon: Option<IconName>,
- icon_color: Option<Color>,
- builder: Rc<dyn Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu>,
- },
+ Submenu(ContextMenuSubmenu),
}
impl ContextMenuItem {
@@ -212,6 +209,61 @@ impl From<ContextMenuEntry> for ContextMenuItem {
}
}
+pub struct ContextMenuSubmenu {
+ id: Option<ElementId>,
+ label: SharedString,
+ icon: Option<IconName>,
+ icon_color: Option<Color>,
+ disabled: bool,
+ builder: Rc<dyn Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu>,
+}
+
+impl ContextMenuSubmenu {
+ pub fn new(
+ label: impl Into<SharedString>,
+ builder: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu + 'static,
+ ) -> Self {
+ Self {
+ id: None,
+ label: label.into(),
+ icon: None,
+ icon_color: None,
+ disabled: false,
+ builder: Rc::new(builder),
+ }
+ }
+
+ /// Preserves the submenu across parent rebuilds; must be unique within the parent.
+ pub fn id(mut self, id: impl Into<ElementId>) -> Self {
+ self.id = Some(id.into());
+ self
+ }
+
+ pub fn disabled(mut self, disabled: bool) -> Self {
+ self.disabled = disabled;
+ self
+ }
+
+ pub fn icon(mut self, icon: IconName) -> Self {
+ self.icon = Some(icon);
+ self
+ }
+
+ pub fn icon_color(mut self, color: Color) -> Self {
+ self.icon_color = Some(color);
+ self
+ }
+}
+
+impl FluentBuilder for ContextMenuSubmenu {}
+
+impl From<ContextMenuSubmenu> for ContextMenuItem {
+ fn from(submenu: ContextMenuSubmenu) -> Self {
+ Self::Submenu(submenu)
+ }
+}
+
+#[derive(RegisterComponent)]
pub struct ContextMenu {
builder: Option<Rc<dyn Fn(Self, &mut Window, &mut Context<Self>) -> Self>>,
items: Vec<ContextMenuItem>,
@@ -222,8 +274,9 @@ pub struct ContextMenu {
clicked: bool,
end_slot_action: Option<Box<dyn Action>>,
key_context: SharedString,
- _on_blur_subscription: Subscription,
+ _on_blur_subscription: Option<Subscription>,
keep_open_on_confirm: bool,
+ rebuild_parent_on_confirm: bool,
fixed_width: Option<DefiniteLength>,
spacing: ListItemSpacing,
main_menu: Option<Entity<ContextMenu>>,
@@ -357,8 +410,9 @@ impl ContextMenu {
clicked: false,
end_slot_action: None,
key_context: "menu".into(),
- _on_blur_subscription,
+ _on_blur_subscription: Some(_on_blur_subscription),
keep_open_on_confirm: true,
+ rebuild_parent_on_confirm: false,
fixed_width: None,
spacing: ListItemSpacing::default(),
main_menu: None,
@@ -381,60 +435,30 @@ impl ContextMenu {
})
}
- /// Rebuilds the menu.
- ///
- /// This is used to refresh the menu entries when entries are toggled when the menu is configured with
- /// `keep_open_on_confirm = true`.
- ///
- /// This only works if the [`ContextMenu`] was constructed using [`ContextMenu::build_persistent`]. Otherwise it is
- /// a no-op.
+ /// Rebuilds persistent menus and submenus, preserving open submenus by ID.
+ /// No-op without a retained builder.
pub fn rebuild(&mut self, window: &mut Window, cx: &mut Context<Self>) {
let Some(builder) = self.builder.clone() else {
return;
};
- // The way we rebuild the menu is a bit of a hack.
- let focus_handle = cx.retained_focus_handle();
let new_menu = (builder.clone())(
Self {
builder: Some(builder),
items: Default::default(),
- focus_handle: focus_handle.clone(),
+ focus_handle: self.focus_handle.clone(),
action_context: None,
selected_index: None,
delayed: false,
clicked: false,
end_slot_action: None,
key_context: "menu".into(),
- _on_blur_subscription: cx.on_blur(
- &focus_handle,
- window,
- |this: &mut ContextMenu, window, cx| {
- if let Some(ignore_until) = this.ignore_blur_until {
- if Instant::now() < ignore_until {
- return;
- } else {
- this.ignore_blur_until = None;
- }
- }
-
- if this.main_menu.is_none() {
- if let SubmenuState::Open(open_submenu) = &this.submenu_state {
- let submenu_focus =
- open_submenu.entity.read(cx).focus_handle.clone();
- if submenu_focus.contains_focused(window, cx) {
- return;
- }
- }
- }
-
- this.cancel(&menu::Cancel, window, cx)
- },
- ),
- keep_open_on_confirm: false,
+ _on_blur_subscription: None,
+ keep_open_on_confirm: self.keep_open_on_confirm,
+ rebuild_parent_on_confirm: self.rebuild_parent_on_confirm,
fixed_width: None,
spacing: self.spacing,
- main_menu: None,
+ main_menu: self.main_menu.clone(),
main_menu_observed_bounds: Rc::new(Cell::new(None)),
documentation_aside: None,
aside_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
@@ -442,7 +466,7 @@ impl ContextMenu {
hover_target: HoverTarget::MainMenu,
submenu_trigger_bounds: Rc::new(RefCell::new(HashMap::default())),
submenu_bounds: Rc::new(Cell::new(None)),
- submenu_depth: 0,
+ submenu_depth: self.submenu_depth,
submenu_trigger_mouse_down: false,
content_focus_handle: None,
ignore_blur_until: None,
@@ -452,10 +476,88 @@ impl ContextMenu {
cx,
);
+ let open_submenu = match &self.submenu_state {
+ SubmenuState::Open(open) => {
+ let id = match self.items.get(open.item_index) {
+ Some(ContextMenuItem::Submenu(submenu)) => submenu.id.as_ref(),
+ _ => None,
+ };
+ let replacement = id.and_then(|id| {
+ new_menu
+ .items
+ .iter()
+ .enumerate()
+ .find_map(|(index, item)| match item {
+ ContextMenuItem::Submenu(submenu)
+ if submenu.id.as_ref() == Some(id) =>
+ {
+ Some((index, submenu.disabled, submenu.builder.clone()))
+ }
+ _ => None,
+ })
+ });
+ Some((open.item_index, open.entity.clone(), replacement))
+ }
+ SubmenuState::Closed => None,
+ };
+
self.items = new_menu.items;
+ self.action_context = new_menu.action_context;
+ self.end_slot_action = new_menu.end_slot_action;
+ self.key_context = new_menu.key_context;
+ self.keep_open_on_confirm = new_menu.keep_open_on_confirm;
+ self.rebuild_parent_on_confirm = new_menu.rebuild_parent_on_confirm;
+ self.fixed_width = new_menu.fixed_width;
self.spacing = new_menu.spacing;
+ self.documentation_aside = None;
+ self.aside_trigger_bounds.borrow_mut().clear();
self.content_focus_handle = new_menu.content_focus_handle;
- self.submenu_trigger_bounds.borrow_mut().clear();
+
+ let selected_index = self.selected_index.take();
+ if let Some(index) = selected_index {
+ self.select_nearest(index, window, cx);
+ }
+
+ if let Some((old_index, submenu, replacement)) = open_submenu {
+ let trigger_index = replacement
+ .as_ref()
+ .map_or(old_index, |(index, _, _)| *index);
+ if let Some((index, false, builder)) = replacement {
+ if let SubmenuState::Open(open) = &mut self.submenu_state {
+ open.item_index = index;
+ }
+ if selected_index == Some(old_index) {
+ self.select_index(index, window, cx);
+ }
+ let bounds = self.submenu_trigger_bounds.borrow_mut().remove(&old_index);
+ self.submenu_trigger_bounds.borrow_mut().clear();
+ if let Some(bounds) = bounds {
+ self.submenu_trigger_bounds
+ .borrow_mut()
+ .insert(index, bounds);
+ }
+ submenu.update(cx, |submenu, cx| {
+ submenu.builder = Some(builder);
+ submenu.rebuild(window, cx);
+ });
+ } else {
+ self.close_submenu(false, cx);
+ self.select_nearest(trigger_index, window, cx);
+ window.focus(&self.focus_handle, cx);
+ self.submenu_trigger_bounds.borrow_mut().clear();
+ }
+ } else {
+ self.submenu_trigger_bounds.borrow_mut().clear();
+ }
+
+ if self.main_menu.is_some() && !self.items.iter().any(ContextMenuItem::is_selectable) {
+ // The parent may still be inside rebuild.
+ cx.defer_in(window, |this, window, cx| {
+ if !this.items.iter().any(ContextMenuItem::is_selectable) {
+ this.select_submenu_parent(&SelectParent, window, cx);
+ }
+ });
+ }
cx.notify();
}
@@ -815,55 +917,48 @@ impl ContextMenu {
}
pub fn submenu(
- mut self,
+ self,
label: impl Into<SharedString>,
builder: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu + 'static,
) -> Self {
- self.items.push(ContextMenuItem::Submenu {
- label: label.into(),
- icon: None,
- icon_color: None,
- builder: Rc::new(builder),
- });
- self
+ self.item(ContextMenuSubmenu::new(label, builder))
}
pub fn submenu_with_icon(
- mut self,
+ self,
label: impl Into<SharedString>,
icon: IconName,
builder: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu + 'static,
) -> Self {
- self.items.push(ContextMenuItem::Submenu {
- label: label.into(),
- icon: Some(icon),
- icon_color: None,
- builder: Rc::new(builder),
- });
- self
+ self.item(ContextMenuSubmenu::new(label, builder).icon(icon))
}
pub fn submenu_with_colored_icon(
- mut self,
+ self,
label: impl Into<SharedString>,
icon: IconName,
icon_color: Color,
builder: impl Fn(ContextMenu, &mut Window, &mut Context<ContextMenu>) -> ContextMenu + 'static,
) -> Self {
- self.items.push(ContextMenuItem::Submenu {
- label: label.into(),
- icon: Some(icon),
- icon_color: Some(icon_color),
- builder: Rc::new(builder),
- });
- self
+ self.item(
+ ContextMenuSubmenu::new(label, builder)
+ .icon(icon)
+ .icon_color(icon_color),
+ )
}
+ /// Submenus must opt in separately.
pub fn keep_open_on_confirm(mut self, keep_open: bool) -> Self {
self.keep_open_on_confirm = keep_open;
self
}
+ /// Requires keep-open confirmation, a rebuildable parent, and a [`ContextMenuSubmenu::id`].
+ pub fn rebuild_parent_on_confirm(mut self, rebuild: bool) -> Self {
+ self.rebuild_parent_on_confirm = rebuild;
+ self
+ }
+
pub fn trigger_end_slot_handler(&mut self, window: &mut Window, cx: &mut Context<Self>) {
let Some(entry) = self.selected_index.and_then(|ix| self.items.get(ix)) else {
return;
@@ -924,10 +1019,13 @@ impl ContextMenu {
return cx.emit(DismissEvent);
};
- if let Some(ContextMenuItem::Submenu { builder, .. }) = self.items.get(ix) {
+ if let Some(ContextMenuItem::Submenu(submenu)) = self.items.get(ix) {
+ if submenu.disabled {
+ return;
+ }
self.open_submenu(
ix,
- builder.clone(),
+ submenu.builder.clone(),
SubmenuOpenTrigger::Keyboard,
window,
cx,
@@ -959,15 +1057,7 @@ impl ContextMenu {
(handler)(context, window, cx)
}
- if self.main_menu.is_some() && !self.keep_open_on_confirm {
- self.clicked = true;
- }
-
- if self.keep_open_on_confirm {
- self.rebuild(window, cx);
- } else {
- cx.emit(DismissEvent);
- }
+ self.finish_confirm(window, cx);
}
pub fn secondary_confirm(
@@ -980,10 +1070,13 @@ impl ContextMenu {
return;
};
- if let Some(ContextMenuItem::Submenu { builder, .. }) = self.items.get(ix) {
+ if let Some(ContextMenuItem::Submenu(submenu)) = self.items.get(ix) {
+ if submenu.disabled {
+ return;
+ }
self.open_submenu(
ix,
- builder.clone(),
+ submenu.builder.clone(),
SubmenuOpenTrigger::Keyboard,
window,
cx,
@@ -1019,15 +1112,39 @@ impl ContextMenu {
(handler)(context, window, cx)
}
- if self.main_menu.is_some() && !self.keep_open_on_confirm {
- self.clicked = true;
- }
+ self.finish_confirm(window, cx);
+ }
- if self.keep_open_on_confirm {
- self.rebuild(window, cx);
- } else {
+ fn finish_confirm(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+ self.clicked = !self.keep_open_on_confirm;
+ if !self.keep_open_on_confirm {
cx.emit(DismissEvent);
+ return;
+ }
+
+ if self.rebuild_parent_on_confirm {
+ if let Some(parent) = self
+ .main_menu
+ .as_ref()
+ .filter(|parent| parent.read(cx).builder.is_some())
+ {
+ let parent = parent.downgrade();
+ let entity_id = cx.entity_id();
+ // Avoid re-entering this submenu through the parent's rebuild.
+ window.defer(cx, move |window, cx| {
+ if let Some(parent) = parent.upgrade() {
+ parent.update(cx, |parent, cx| {
+ if matches!(&parent.submenu_state, SubmenuState::Open(open) if open.entity.entity_id() == entity_id) {
+ parent.rebuild(window, cx);
+ }
+ });
+ }
+ });
+ return;
+ }
}
+
+ self.rebuild(window, cx);
}
pub fn cancel(&mut self, _: &menu::Cancel, window: &mut Window, cx: &mut Context<Self>) {
@@ -1165,13 +1282,16 @@ impl ContextMenu {
return;
};
- let Some(ContextMenuItem::Submenu { builder, .. }) = self.items.get(ix) else {
+ let Some(ContextMenuItem::Submenu(submenu)) = self.items.get(ix) else {
return;
};
+ if submenu.disabled {
+ return;
+ }
self.open_submenu(
ix,
- builder.clone(),
+ submenu.builder.clone(),
SubmenuOpenTrigger::Keyboard,
window,
cx,
@@ -1194,31 +1314,37 @@ impl ContextMenu {
window: &mut Window,
cx: &mut Context<Self>,
) {
- if self.main_menu.is_none() {
- return;
- }
-
if let Some(parent) = &self.main_menu {
- let parent_clone = parent.clone();
-
- let parent_focus = parent.read(cx).focus_handle.clone();
- window.focus(&parent_focus, cx);
-
- cx.emit(DismissEvent);
-
- parent_clone.update(cx, |parent, cx| {
- if let SubmenuState::Open(open_submenu) = &parent.submenu_state {
- let trigger_index = open_submenu.item_index;
- parent.close_submenu(false, cx);
- let _ = parent.select_index(trigger_index, window, cx);
- cx.notify();
+ let entity_id = cx.entity_id();
+ parent.update(cx, |parent, cx| {
+ let SubmenuState::Open(open) = &parent.submenu_state else {
+ return;
+ };
+ if open.entity.entity_id() != entity_id {
+ return;
}
+ let trigger_index = open.item_index;
+ parent.close_submenu(false, cx);
+ parent.select_nearest(trigger_index, window, cx);
+ window.focus(&parent.focus_handle, cx);
});
-
- return;
+ cx.emit(DismissEvent);
}
+ }
- cx.emit(DismissEvent);
+ fn select_nearest(&mut self, index: usize, window: &mut Window, cx: &mut Context<Self>) {
+ self.selected_index = None;
+ self.documentation_aside = None;
+ if let Some(index) = self
+ .items
+ .iter()
+ .enumerate()
+ .filter(|(_, item)| item.is_selectable())
+ .min_by_key(|(candidate, _)| candidate.abs_diff(index))
+ .map(|(index, _)| index)
+ {
+ self.select_index(index, window, cx);
+ }
}
fn select_index(
@@ -1243,7 +1369,7 @@ impl ContextMenu {
} => {
self.documentation_aside = Some((ix, callback.clone()));
}
- ContextMenuItem::Submenu { .. } => {}
+ ContextMenuItem::Submenu(_) => {}
_ => (),
}
}
@@ -1289,7 +1415,7 @@ impl ContextMenu {
);
let mut menu = ContextMenu {
- builder: None,
+ builder: Some(builder.clone()),
items: Default::default(),
focus_handle,
action_context: None,
@@ -1298,8 +1424,9 @@ impl ContextMenu {
clicked: false,
end_slot_action: None,
key_context: "menu".into(),
- _on_blur_subscription,
+ _on_blur_subscription: Some(_on_blur_subscription),
keep_open_on_confirm: false,
+ rebuild_parent_on_confirm: false,
fixed_width: None,
spacing: ListItemSpacing::default(),
documentation_aside: None,
@@ -1416,7 +1543,7 @@ impl ContextMenu {
}
pub fn on_blur_subscription(mut self, new_subscription: Subscription) -> Self {
- self._on_blur_subscription = new_subscription;
+ self._on_blur_subscription = Some(new_subscription);
self
}
@@ -1522,17 +1649,10 @@ impl ContextMenu {
.when(selectable, |item| {
item.on_click({
let context = self.action_context.clone();
- let keep_open_on_confirm = self.keep_open_on_confirm;
move |_, window, cx| {
handler(context.as_ref(), window, cx);
menu.update(cx, |menu, cx| {
- menu.clicked = true;
-
- if keep_open_on_confirm {
- menu.rebuild(window, cx);
- } else {
- cx.emit(DismissEvent);
- }
+ menu.finish_confirm(window, cx);
})
.ok();
}
@@ -1542,18 +1662,11 @@ impl ContextMenu {
)
.into_any_element()
}
- ContextMenuItem::Submenu {
- label,
- icon,
- icon_color,
- ..
- } => self
+ ContextMenuItem::Submenu(submenu) => self
.render_submenu_item_trigger(
ix,
- label.clone(),
- *icon,
- *icon_color,
- is_active_descendant(true),
+ submenu,
+ is_active_descendant(!submenu.disabled),
window,
cx,
)
@@ -1564,13 +1677,19 @@ impl ContextMenu {
fn render_submenu_item_trigger(
&self,
ix: usize,
- label: SharedString,
- icon: Option<IconName>,
- icon_color: Option<Color>,
+ submenu: &ContextMenuSubmenu,
is_active_descendant: bool,
window: &Window,
cx: &mut Context<Self>,
) -> impl IntoElement {
+ let ContextMenuSubmenu {
+ label,
+ icon,
+ icon_color,
+ disabled,
+ ..
+ } = submenu;
+ let disabled = *disabled;
let toggle_state = Some(ix) == self.selected_index
|| matches!(
&self.submenu_state,
@@ -1619,26 +1738,30 @@ impl ContextMenu {
ListItem::new(ix)
.inset(true)
.spacing(self.spacing)
+ .disabled(disabled)
.aria_role(Role::MenuItem)
.when(is_active_descendant, |item| item.aria_active_descendant())
.aria_label(label.clone())
.toggle_state(toggle_state)
.on_hover(cx.listener(move |this, hovered, window, cx| {
+ if disabled {
+ return;
+ }
if *hovered {
this.clear_selected();
this.suppress_focus_selection = true;
window.focus(&this.focus_handle.clone(), cx);
this.hover_target = HoverTarget::MainMenu;
- if let Some(ContextMenuItem::Submenu { builder, .. }) =
- this.items.get(ix)
- {
- this.open_submenu(
- ix,
- builder.clone(),
- SubmenuOpenTrigger::Pointer,
- window,
- cx,
- );
+ if let Some(ContextMenuItem::Submenu(submenu)) = this.items.get(ix) {
+ if !submenu.disabled {
+ this.open_submenu(
+ ix,
+ submenu.builder.clone(),
+ SubmenuOpenTrigger::Pointer,
+ window,
+ cx,
+ );
+ }
}
cx.notify();
@@ -1676,14 +1799,16 @@ impl ContextMenu {
return;
}
- if let Some(ContextMenuItem::Submenu { builder, .. }) = this.items.get(ix) {
- this.open_submenu(
- ix,
- builder.clone(),
- SubmenuOpenTrigger::Pointer,
- window,
- cx,
- );
+ if let Some(ContextMenuItem::Submenu(submenu)) = this.items.get(ix) {
+ if !submenu.disabled {
+ this.open_submenu(
+ ix,
+ submenu.builder.clone(),
+ SubmenuOpenTrigger::Pointer,
+ window,
+ cx,
+ );
+ }
}
}))
.child(
@@ -1694,19 +1819,31 @@ impl ContextMenu {
.child(
h_flex()
.gap_1p5()
- .when_some(icon, |this, icon_name| {
+ .when_some(*icon, |this, icon_name| {
this.child(
- Icon::new(icon_name)
- .size(IconSize::Small)
- .color(icon_color.unwrap_or(Color::Muted)),
+ Icon::new(icon_name).size(IconSize::Small).color(
+ if disabled {
+ Color::Disabled
+ } else {
+ icon_color.unwrap_or(Color::Muted)
+ },
+ ),
)
})
- .child(Label::new(label).color(Color::Default)),
+ .child(Label::new(label.clone()).color(if disabled {
+ Color::Disabled
+ } else {
+ Color::Default
+ })),
)
.child(
Icon::new(IconName::ChevronRight)
.size(IconSize::Small)
- .color(Color::Muted),
+ .color(if disabled {
+ Color::Disabled
+ } else {
+ Color::Muted
+ }),
),
),
)
@@ -1987,12 +2124,10 @@ impl ContextMenu {
return;
}
- if let Some(ContextMenuItem::Submenu { builder, .. }) =
- this.items.get(ix)
- {
+ if let Some(ContextMenuItem::Submenu(submenu)) = this.items.get(ix) {
this.open_submenu(
ix,
- builder.clone(),
+ submenu.builder.clone(),
SubmenuOpenTrigger::Pointer,
window,
cx,
@@ -2132,16 +2267,10 @@ impl ContextMenu {
)
.on_click({
let context = self.action_context.clone();
- let keep_open_on_confirm = self.keep_open_on_confirm;
move |_, window, cx| {
handler(context.as_ref(), window, cx);
menu.update(cx, |menu, cx| {
- menu.clicked = true;
- if keep_open_on_confirm {
- menu.rebuild(window, cx);
- } else {
- cx.emit(DismissEvent);
- }
+ menu.finish_confirm(window, cx);
})
.ok();
}
@@ -2205,8 +2334,9 @@ impl ContextMenu {
clicked: false,
end_slot_action: None,
key_context: SharedString::from("menu"),
- _on_blur_subscription,
+ _on_blur_subscription: Some(_on_blur_subscription),
keep_open_on_confirm: false,
+ rebuild_parent_on_confirm: false,
fixed_width: None,
spacing: ListItemSpacing::default(),
main_menu: None,
@@ -2236,7 +2366,7 @@ impl ContextMenuItem {
| ContextMenuItem::EmbeddedView(_) => false,
ContextMenuItem::Entry(ContextMenuEntry { disabled, .. }) => !disabled,
ContextMenuItem::CustomEntry { selectable, .. } => *selectable,
- ContextMenuItem::Submenu { .. } => true,
+ ContextMenuItem::Submenu(submenu) => !submenu.disabled,
}
}
}
@@ -2485,6 +2615,366 @@ mod tests {
}
}
+ fn submenu_test_window(
+ cx: &mut TestAppContext,
+ build: impl FnOnce(&mut Window, &mut App) -> Entity<ContextMenu>,
+ ) -> (Entity<ContextMenu>, VisualTestContext) {
+ cx.update(|cx| {
+ let settings_store = settings::SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ theme_settings::init(theme::LoadThemes::JustBase, cx);
+ });
+ let window = cx.open_window(size(px(700.), px(400.)), |window, cx| SubmenuTestView {
+ menu: build(window, cx),
+ left: px(40.),
+ });
+ let menu = window
+ .update(cx, |view, _, _| view.menu.clone())
+ .expect("menu");
+ let mut visual = VisualTestContext::from_window(window.into(), cx);
+ visual.update(|window, cx| window.draw(cx).clear(cx));
+ (menu, visual)
+ }
+
+ fn open_selected_submenu(
+ menu: &Entity<ContextMenu>,
+ cx: &mut VisualTestContext,
+ ) -> Entity<ContextMenu> {
+ menu.update_in(cx, |menu, window, cx| {
+ menu.select_submenu_child(&SelectChild, window, cx);
+ });
+ cx.update(|window, cx| window.draw(cx).clear(cx));
+ menu.read_with(cx, |menu, _| match &menu.submenu_state {
+ SubmenuState::Open(open) => open.entity.clone(),
+ SubmenuState::Closed => panic!("submenu should be open"),
+ })
+ }
+
+ #[gpui::test]
+ fn persistent_submenu_refreshes_for_mouse_and_keyboard(cx: &mut TestAppContext) {
+ let changes = Rc::new(Cell::new(0));
+ let builds = Rc::new(Cell::new(0));
+ let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
+ ContextMenu::build(window, cx, {
+ let changes = changes.clone();
+ let builds = builds.clone();
+ move |menu, _, _| {
+ menu.submenu("Filters", move |menu, _, _| {
+ builds.set(builds.get() + 1);
+ let count = changes.get();
+ menu.keep_open_on_confirm(true)
+ .header(format!("Changes: {count}"))
+ .item(
+ ContextMenuEntry::new("Toggle")
+ .toggleable(IconPosition::End, count % 2 != 0)
+ .handler({
+ let changes = changes.clone();
+ move |_, _| changes.set(changes.get() + 1)
+ }),
+ )
+ .custom_entry(
+ |_, _| {
+ div()
+ .debug_selector(|| "custom-toggle".into())
+ .child("Custom")
+ .into_any_element()
+ },
+ {
+ let changes = changes.clone();
+ move |_, _| changes.set(changes.get() + 1)
+ },
+ )
+ })
+ }
+ })
+ });
+ let dismissals = Rc::new(Cell::new(0));
+ let _subscription = visual.update(|_, cx| {
+ let dismissals = dismissals.clone();
+ cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
+ dismissals.set(dismissals.get() + 1);
+ })
+ });
+ menu.update_in(&mut visual, |menu, window, cx| {
+ menu.select_first(&SelectFirst, window, cx)
+ });
+ let submenu = open_selected_submenu(&menu, &mut visual);
+ let focus = visual.update(|_, cx| submenu.focus_handle(cx));
+
+ for count in 1..=4 {
+ match count {
+ 1 | 2 => {
+ let selector = if count == 1 {
+ "MENU_ITEM-Toggle"
+ } else {
+ "custom-toggle"
+ };
+ let bounds = visual.debug_bounds(selector).expect("entry bounds");
+ visual.simulate_click(bounds.center(), Modifiers::default());
+ }
+ _ => {
+ submenu.update_in(&mut visual, |menu, window, cx| {
+ menu.select_first(&SelectFirst, window, cx);
+ });
+ if count == 3 {
+ visual.dispatch_action(menu::Confirm);
+ } else {
+ visual.dispatch_action(menu::SecondaryConfirm);
+ }
+ }
+ }
+ visual.run_until_parked();
+ visual.update(|window, cx| {
+ window.draw(cx).clear(cx);
+ assert!(focus.is_focused(window));
+ });
+ assert_eq!(changes.get(), count);
+ assert_eq!(
+ builds.get(),
+ count + 1,
+ "rebuild once per confirmation, not per frame"
+ );
+ submenu.read_with(&visual, |submenu, _| {
+ assert!(matches!(submenu.items.first(), Some(ContextMenuItem::Header(label)) if label.as_ref() == format!("Changes: {count}")));
+ assert!(matches!(submenu.items.get(1), Some(ContextMenuItem::Entry(entry)) if entry.toggle == Some((IconPosition::End, count % 2 != 0))));
+ assert!(!submenu.clicked);
+ });
+ menu.read_with(&visual, |menu, _| {
+ assert!(matches!(&menu.submenu_state, SubmenuState::Open(open) if open.entity == submenu));
+ });
+ assert_eq!(dismissals.get(), 0);
+ }
+
+ visual.dispatch_action(menu::Cancel);
+ visual.run_until_parked();
+ assert_eq!(
+ dismissals.get(),
+ 0,
+ "Escape after a keep-open click must not dismiss the parent"
+ );
+ menu.read_with(&visual, |menu, _| {
+ assert!(matches!(menu.submenu_state, SubmenuState::Closed))
+ });
+ visual.update(|window, cx| assert!(menu.focus_handle(cx).is_focused(window)));
+ }
+
+ #[gpui::test]
+ fn persistent_submenu_removal_repairs_selection_and_returns_focus(cx: &mut TestAppContext) {
+ let remaining = Rc::new(Cell::new(2));
+ let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
+ ContextMenu::build(window, cx, {
+ let remaining = remaining.clone();
+ move |menu, _, _| {
+ menu.submenu("Filters", move |menu, _, _| {
+ let mut menu = menu.keep_open_on_confirm(true).header("Available filters");
+ for index in 0..remaining.get() {
+ let remaining = remaining.clone();
+ menu = menu.entry(format!("Filter {index}"), None, move |_, _| {
+ remaining.set(remaining.get() - 1);
+ });
+ }
+ menu.item(ContextMenuEntry::new("Unavailable").disabled(true))
+ })
+ }
+ })
+ });
+ menu.update_in(&mut visual, |menu, window, cx| {
+ menu.select_first(&SelectFirst, window, cx)
+ });
+ let submenu = open_selected_submenu(&menu, &mut visual);
+ submenu.update_in(&mut visual, |submenu, window, cx| {
+ submenu.select_last(window, cx);
+ submenu.confirm(&menu::Confirm, window, cx);
+ assert_eq!(submenu.selected_index(), Some(1));
+ });
+ visual.run_until_parked();
+ submenu.update_in(&mut visual, |submenu, window, cx| {
+ submenu.confirm(&menu::Confirm, window, cx);
+ });
+ visual.run_until_parked();
+ menu.read_with(&visual, |menu, _| {
+ assert!(matches!(menu.submenu_state, SubmenuState::Closed));
+ assert_eq!(menu.selected_index(), Some(0));
+ });
+ visual.update(|window, cx| assert!(menu.focus_handle(cx).is_focused(window)));
+ assert_eq!(remaining.get(), 0);
+ }
+
+ #[gpui::test]
+ fn persistent_submenu_can_refresh_and_disable_its_parent_trigger(cx: &mut TestAppContext) {
+ let remaining = Rc::new(Cell::new(2));
+ let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
+ ContextMenu::build_persistent(window, cx, {
+ let remaining = remaining.clone();
+ move |menu, _, _| {
+ let count = remaining.get();
+ menu.entry("Before", None, |_, _| {})
+ .when(count < 2, |menu| menu.header("Updated"))
+ .when(count == 0, |menu| menu.header("No filters"))
+ .item(
+ ContextMenuSubmenu::new(format!("Filters ({count})"), {
+ let remaining = remaining.clone();
+ move |menu, _, _| {
+ let mut menu = menu
+ .keep_open_on_confirm(true)
+ .rebuild_parent_on_confirm(true);
+ for index in 0..count {
+ let remaining = remaining.clone();
+ menu = menu.entry(
+ format!("Filter {index}"),
+ None,
+ move |_, _| {
+ remaining.set(remaining.get() - 1);
+ },
+ );
+ }
+ menu
+ }
+ })
+ .id("filters")
+ .disabled(count == 0),
+ )
+ .entry("After", None, |_, _| {})
+ }
+ })
+ });
+ let dismissals = Rc::new(Cell::new(0));
+ let _subscription = visual.update(|_, cx| {
+ let dismissals = dismissals.clone();
+ cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
+ dismissals.set(dismissals.get() + 1)
+ })
+ });
+ menu.update_in(&mut visual, |menu, window, cx| {
+ menu.select_first(&SelectFirst, window, cx);
+ menu.select_next(&SelectNext, window, cx);
+ });
+ let submenu = open_selected_submenu(&menu, &mut visual);
+ let focus = visual.update(|_, cx| submenu.focus_handle(cx));
+ let bounds = visual
+ .debug_bounds("MENU_ITEM-Filter 0")
+ .expect("filter bounds");
+ visual.simulate_click(bounds.center(), Modifiers::default());
+ visual.run_until_parked();
+ visual.update(|window, cx| window.draw(cx).clear(cx));
+ menu.read_with(&visual, |menu, _| {
+ assert!(matches!(&menu.submenu_state, SubmenuState::Open(open) if open.item_index == 2 && open.entity == submenu));
+ assert!(matches!(menu.items.get(2), Some(ContextMenuItem::Submenu(trigger)) if trigger.label.as_ref() == "Filters (1)"));
+ });
+ submenu.read_with(&visual, |submenu, _| assert_eq!(submenu.items.len(), 1));
+ visual.update(|window, _| assert!(focus.is_focused(window)));
+
+ submenu.update_in(&mut visual, |submenu, window, cx| {
+ submenu.select_first(&SelectFirst, window, cx)
+ });
+ visual.dispatch_action(menu::Confirm);
+ visual.run_until_parked();
+ menu.read_with(&visual, |menu, _| {
+ assert!(matches!(menu.submenu_state, SubmenuState::Closed));
+ assert!(matches!(menu.items.get(3), Some(ContextMenuItem::Submenu(trigger)) if trigger.disabled && trigger.label.as_ref() == "Filters (0)"));
+ assert_eq!(menu.selected_index(), Some(4), "skip disabled triggers and headers");
+ });
+ visual.update(|window, cx| assert!(menu.focus_handle(cx).is_focused(window)));
+ assert_eq!(dismissals.get(), 0);
+ visual.update(|window, cx| window.draw(cx).clear(cx));
+ let trigger_bounds = menu.read_with(&visual, |menu, _| {
+ menu.submenu_trigger_bounds
+ .borrow()
+ .get(&3)
+ .copied()
+ .expect("disabled trigger bounds")
+ });
+ visual.simulate_mouse_move(trigger_bounds.center(), None, Modifiers::default());
+ visual.simulate_click(trigger_bounds.center(), Modifiers::default());
+ menu.read_with(&visual, |menu, _| {
+ assert!(matches!(menu.submenu_state, SubmenuState::Closed));
+ assert_eq!(menu.selected_index(), Some(4));
+ });
+ assert_eq!(dismissals.get(), 0);
+ }
+
+ #[gpui::test]
+ fn nested_submenu_refresh_preserves_ancestors_and_focus(cx: &mut TestAppContext) {
+ let count = Rc::new(Cell::new(0));
+ let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
+ ContextMenu::build(window, cx, {
+ let count = count.clone();
+ move |menu, _, _| {
+ menu.submenu("Options", move |menu, _, _| {
+ menu.item(
+ ContextMenuSubmenu::new(format!("Filters ({})", count.get()), {
+ let count = count.clone();
+ move |menu, _, _| {
+ menu.keep_open_on_confirm(true)
+ .rebuild_parent_on_confirm(true)
+ .entry(format!("Count: {}", count.get()), None, {
+ let count = count.clone();
+ move |_, _| count.set(count.get() + 1)
+ })
+ }
+ })
+ .id("filters"),
+ )
+ })
+ }
+ })
+ });
+ let dismissals = Rc::new(Cell::new(0));
+ let _subscription = visual.update(|_, cx| {
+ let dismissals = dismissals.clone();
+ cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
+ dismissals.set(dismissals.get() + 1)
+ })
+ });
+ menu.update_in(&mut visual, |menu, window, cx| {
+ menu.select_first(&SelectFirst, window, cx)
+ });
+ let parent = open_selected_submenu(&menu, &mut visual);
+ let submenu = open_selected_submenu(&parent, &mut visual);
+ visual.dispatch_action(menu::Confirm);
+ visual.run_until_parked();
+ visual.update(|window, cx| {
+ window.draw(cx).clear(cx);
+ assert!(submenu.focus_handle(cx).is_focused(window));
+ });
+ menu.read_with(&visual, |menu, _| {
+ assert!(
+ matches!(&menu.submenu_state, SubmenuState::Open(open) if open.entity == parent)
+ );
+ });
+ parent.read_with(&visual, |parent, _| {
+ assert!(matches!(&parent.submenu_state, SubmenuState::Open(open) if open.entity == submenu));
+ assert!(matches!(parent.items.first(), Some(ContextMenuItem::Submenu(trigger)) if trigger.label.as_ref() == "Filters (1)"));
+ });
+ visual.dispatch_action(SelectParent);
+ visual.run_until_parked();
+ visual.update(|window, cx| assert!(parent.focus_handle(cx).is_focused(window)));
+ assert_eq!(dismissals.get(), 0);
+ }
+
+ #[gpui::test]
+ fn ordinary_submenu_confirmation_still_dismisses_parent(cx: &mut TestAppContext) {
+ let (menu, mut visual) = submenu_test_window(cx, |window, cx| {
+ ContextMenu::build_persistent(window, cx, |menu, _, _| {
+ menu.submenu("Commands", |menu, _, _| menu.entry("Run", None, |_, _| {}))
+ })
+ });
+ let dismissals = Rc::new(Cell::new(0));
+ let _subscription = visual.update(|_, cx| {
+ let dismissals = dismissals.clone();
+ cx.subscribe(&menu, move |_, _: &DismissEvent, _| {
+ dismissals.set(dismissals.get() + 1)
+ })
+ });
+ menu.update_in(&mut visual, |menu, window, cx| {
+ menu.select_first(&SelectFirst, window, cx)
+ });
+ open_selected_submenu(&menu, &mut visual);
+ visual.dispatch_action(menu::Confirm);
+ visual.run_until_parked();
+ assert_eq!(dismissals.get(), 1);
+ }
+
struct EmbeddedTestView {
focus_handle: FocusHandle,
bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
diff --git a/crates/ui/src/components/context_menu/preview.rs b/crates/ui/src/components/context_menu/preview.rs
new file mode 100644
index 00000000000..120834245d0
--- /dev/null
+++ b/crates/ui/src/components/context_menu/preview.rs
@@ -0,0 +1,600 @@
+use gpui::{Anchor, Entity, FocusHandle};
+
+use crate::{ListItemSpacing, PopoverMenu, prelude::*, right_click_menu};
+
+use super::{ContextMenu, ContextMenuEntry, ContextMenuSubmenu, DocumentationSide};
+
+#[derive(Clone, PartialEq, gpui::Action)]
+#[action(namespace = context_menu_preview, no_json, no_register)]
+struct PreviewAction;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Example {
+ Standard,
+ Persistent,
+ Submenu,
+ Removal,
+ ParentRefresh,
+ Nested,
+ Content,
+ Placement,
+}
+
+impl Example {
+ const ALL: [Self; 8] = [
+ Self::Standard,
+ Self::Persistent,
+ Self::Submenu,
+ Self::Removal,
+ Self::ParentRefresh,
+ Self::Nested,
+ Self::Content,
+ Self::Placement,
+ ];
+
+ fn title(self) -> &'static str {
+ match self {
+ Self::Standard => "Standard menus",
+ Self::Persistent => "Persistent menus",
+ Self::Submenu => "Persistent submenus",
+ Self::Removal => "Removing submenu entries",
+ Self::ParentRefresh => "Refreshing the parent",
+ Self::Nested => "Nested menus",
+ Self::Content => "Content, width, and spacing",
+ Self::Placement => "Placement and right-click menus",
+ }
+ }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Default)]
+enum TriggerState {
+ #[default]
+ Enabled,
+ Disabled,
+ Removed,
+}
+
+struct ExampleValues {
+ archived: bool,
+ confirmations: usize,
+ filters: Vec<&'static str>,
+ trigger_moved: bool,
+ trigger_state: TriggerState,
+}
+
+impl Default for ExampleValues {
+ fn default() -> Self {
+ Self {
+ archived: false,
+ confirmations: 0,
+ filters: vec!["Assigned to me", "In progress", "Updated today"],
+ trigger_moved: false,
+ trigger_state: TriggerState::Enabled,
+ }
+ }
+}
+
+struct MenuPreview {
+ example: Example,
+ values: ExampleValues,
+ focus_handle: FocusHandle,
+}
+
+impl MenuPreview {
+ fn new(example: Example, cx: &mut Context<Self>) -> Self {
+ Self {
+ example,
+ values: ExampleValues::default(),
+ focus_handle: cx.focus_handle(),
+ }
+ }
+
+ fn handler(
+ preview: &Entity<Self>,
+ update: impl Fn(&mut ExampleValues) + 'static,
+ ) -> impl Fn(&mut Window, &mut App) + 'static {
+ let preview = preview.clone();
+ move |_, cx| {
+ preview.update(cx, |this, cx| {
+ update(&mut this.values);
+ this.values.confirmations += 1;
+ cx.notify();
+ });
+ }
+ }
+
+ fn open_menu(
+ preview: &Entity<Self>,
+ spacing: ListItemSpacing,
+ width: Option<Pixels>,
+ window: &mut Window,
+ cx: &mut App,
+ ) -> Entity<ContextMenu> {
+ let example = preview.read(cx).example;
+ let builder = {
+ let preview = preview.clone();
+ move |menu: ContextMenu, _: &mut Window, cx: &mut Context<ContextMenu>| {
+ Self::build_menu(menu, &preview, cx)
+ .spacing(spacing)
+ .when_some(width, |menu, width| menu.fixed_width(width.into()))
+ }
+ };
+ if matches!(example, Example::Persistent | Example::ParentRefresh) {
+ ContextMenu::build_persistent(window, cx, builder)
+ } else {
+ ContextMenu::build(window, cx, builder)
+ }
+ }
+
+ fn filter_entries(menu: ContextMenu, preview: &Entity<Self>, cx: &App) -> ContextMenu {
+ let values = &preview.read(cx).values;
+ let confirmations = values.confirmations;
+ menu.keep_open_on_confirm(true)
+ .header(format!("Confirmed {confirmations} times"))
+ .item(
+ ContextMenuEntry::new("Include archived")
+ .toggleable(IconPosition::Start, values.archived)
+ .handler(Self::handler(preview, |values| {
+ values.archived = !values.archived;
+ })),
+ )
+ .item(
+ ContextMenuEntry::new("Archived-only option")
+ .disabled(!values.archived)
+ .handler(Self::handler(preview, |_| {})),
+ )
+ .separator()
+ .custom_entry(
+ move |_, _| {
+ h_flex()
+ .w_full()
+ .gap_3()
+ .justify_between()
+ .child(Label::new("Custom counter row"))
+ .child(Label::new(confirmations.to_string()).color(Color::Muted))
+ .into_any_element()
+ },
+ Self::handler(preview, |_| {}),
+ )
+ }
+
+ fn build_menu(menu: ContextMenu, preview: &Entity<Self>, cx: &App) -> ContextMenu {
+ let this = preview.read(cx);
+ match this.example {
+ Example::Standard => menu
+ .context(this.focus_handle.clone())
+ .header("Commands")
+ .action("Dispatch preview action", Box::new(PreviewAction))
+ .item(
+ ContextMenuEntry::new("Disabled command")
+ .disabled(true)
+ .handler(Self::handler(preview, |_| {})),
+ )
+ .label("This label is not selectable")
+ .separator()
+ .submenu("Ordinary submenu", {
+ let preview = preview.clone();
+ move |menu, _, _| {
+ menu.entry("Run child command", None, Self::handler(&preview, |_| {}))
+ }
+ })
+ .item(
+ ContextMenuSubmenu::new("Disabled submenu", |menu, _, _| {
+ menu.label("This submenu should not open")
+ })
+ .disabled(true),
+ )
+ .entry("Last command", None, Self::handler(preview, |_| {})),
+ Example::Persistent => Self::filter_entries(menu, preview, cx),
+ Example::Submenu => menu
+ .submenu_with_icon("Filters", IconName::Filter, {
+ let preview = preview.clone();
+ move |menu, _, cx| Self::filter_entries(menu, &preview, cx)
+ })
+ .entry("Parent command", None, Self::handler(preview, |_| {})),
+ Example::Removal => menu
+ .submenu("Active filters", {
+ let preview = preview.clone();
+ move |menu, _, cx| {
+ let values = &preview.read(cx).values;
+ menu.keep_open_on_confirm(true)
+ .header(format!("{} remaining", values.filters.len()))
+ .label("Select a filter to remove it")
+ .extend(values.filters.iter().map(|&filter| {
+ ContextMenuEntry::new(filter)
+ .toggleable(IconPosition::End, true)
+ .handler(Self::handler(&preview, move |values| {
+ values.filters.retain(|value| *value != filter)
+ }))
+ }))
+ }
+ })
+ .entry("Parent command", None, Self::handler(preview, |_| {})),
+ Example::ParentRefresh => {
+ let values = &this.values;
+ menu.keep_open_on_confirm(false)
+ .entry("Before filters", None, Self::handler(preview, |_| {}))
+ .when(values.trigger_moved, |menu| {
+ menu.entry("Inserted neighbor", None, Self::handler(preview, |_| {}))
+ })
+ .when(values.trigger_state != TriggerState::Removed, |menu| {
+ menu.item(
+ ContextMenuSubmenu::new(
+ format!("Filters ({} changes)", values.confirmations),
+ {
+ let preview = preview.clone();
+ move |menu, _, cx| {
+ Self::filter_entries(menu, &preview, cx)
+ .rebuild_parent_on_confirm(true)
+ .separator()
+ .entry(
+ "Move trigger",
+ None,
+ Self::handler(&preview, |values| {
+ values.trigger_moved = !values.trigger_moved;
+ }),
+ )
+ .entry(
+ "Disable trigger",
+ None,
+ Self::handler(&preview, |values| {
+ values.trigger_state = TriggerState::Disabled;
+ }),
+ )
+ .entry(
+ "Remove trigger",
+ None,
+ Self::handler(&preview, |values| {
+ values.trigger_state = TriggerState::Removed;
+ }),
+ )
+ }
+ },
+ )
+ .id("filters")
+ .icon(IconName::Filter)
+ .disabled(values.trigger_state == TriggerState::Disabled),
+ )
+ })
+ .entry("After filters", None, Self::handler(preview, |_| {}))
+ }
+ Example::Nested => menu.submenu("Filters", {
+ let preview = preview.clone();
+ move |menu, _, _| {
+ menu.submenu("Status", {
+ let preview = preview.clone();
+ move |menu, _, cx| Self::filter_entries(menu, &preview, cx)
+ })
+ .entry(
+ "Intermediate command",
+ None,
+ Self::handler(&preview, |_| {}),
+ )
+ }
+ }),
+ Example::Content => menu
+ .header("Content variants")
+ .item(
+ ContextMenuEntry::new("Leading colored icon")
+ .icon(IconName::Filter)
+ .icon_color(Color::Accent)
+ .handler(Self::handler(preview, |_| {})),
+ )
+ .item(
+ ContextMenuEntry::new("Trailing icon")
+ .icon(IconName::ArrowUpRight)
+ .icon_position(IconPosition::End)
+ .handler(Self::handler(preview, |_| {})),
+ )
+ .toggleable_entry(
+ "Checked option",
+ true,
+ IconPosition::End,
+ None,
+ Self::handler(preview, |_| {}),
+ )
+ .separator()
+ .item(
+ ContextMenuEntry::new("Documentation on the right")
+ .documentation_aside(DocumentationSide::Right, |_| {
+ v_flex()
+ .p_3()
+ .gap_1()
+ .child(Label::new("Documentation aside"))
+ .child(
+ Label::new("Shown on hover or keyboard selection.")
+ .size(LabelSize::Small),
+ )
+ .into_any_element()
+ })
+ .handler(Self::handler(preview, |_| {})),
+ )
+ .item(
+ ContextMenuEntry::new("Disabled with documentation")
+ .disabled(true)
+ .documentation_aside(DocumentationSide::Left, |_| {
+ div()
+ .p_3()
+ .child(Label::new("Unavailable, but still explains why."))
+ .into_any_element()
+ }),
+ )
+ .custom_row(|_, _| {
+ Label::new("Non-selectable custom row")
+ .color(Color::Muted)
+ .size(LabelSize::Small)
+ .into_any_element()
+ })
+ .custom_entry(
+ |_, _| {
+ h_flex()
+ .gap_2()
+ .child(Icon::new(IconName::Check).color(Color::Success))
+ .child(Label::new("Selectable custom row"))
+ .into_any_element()
+ },
+ Self::handler(preview, |_| {}),
+ )
+ .separator()
+ .end_slot_action(Box::new(PreviewAction))
+ .entry_with_end_slot(
+ "Always-visible end slot",
+ None,
+ Self::handler(preview, |_| {}),
+ IconName::Settings,
+ "Secondary action".into(),
+ Self::handler(preview, |_| {}),
+ )
+ .entry_with_end_slot_on_hover(
+ "Hover-only end slot",
+ None,
+ Self::handler(preview, |_| {}),
+ IconName::Settings,
+ "Secondary action".into(),
+ Self::handler(preview, |_| {}),
+ ),
+ Example::Placement => menu
+ .header("Window edges")
+ .entry("First command", None, Self::handler(preview, |_| {}))
+ .submenu("Open toward available space", {
+ let preview = preview.clone();
+ move |menu, _, _| {
+ menu.entry("Submenu command", None, Self::handler(&preview, |_| {}))
+ .entry(
+ "Another submenu command",
+ None,
+ Self::handler(&preview, |_| {}),
+ )
+ }
+ })
+ .entry("Last command", None, Self::handler(preview, |_| {})),
+ }
+ }
+
+ fn trigger(
+ label: &'static str,
+ spacing: ListItemSpacing,
+ width: Option<Pixels>,
+ anchor: Anchor,
+ cx: &Context<Self>,
+ ) -> Div {
+ let preview = cx.entity();
+ div()
+ .flex()
+ .self_start()
+ .debug_selector(move || label.to_string())
+ .child(
+ PopoverMenu::new(label)
+ .trigger(Button::new(label, label).style(ButtonStyle::Outlined))
+ .anchor(anchor)
+ .attach(match anchor {
+ Anchor::TopRight => Anchor::BottomRight,
+ _ => Anchor::BottomLeft,
+ })
+ .menu(move |window, cx| {
+ Some(Self::open_menu(&preview, spacing, width, window, cx))
+ }),
+ )
+ }
+}
+
+impl Render for MenuPreview {
+ fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+ let controls = match self.example {
+ Example::Content => h_flex()
+ .flex_wrap()
+ .gap_2()
+ .child(Self::trigger(
+ "Extra dense · 240px",
+ ListItemSpacing::ExtraDense,
+ Some(px(240.)),
+ Anchor::TopLeft,
+ cx,
+ ))
+ .child(Self::trigger(
+ "Dense · automatic width",
+ ListItemSpacing::Dense,
+ None,
+ Anchor::TopLeft,
+ cx,
+ ))
+ .child(Self::trigger(
+ "Sparse · 360px",
+ ListItemSpacing::Sparse,
+ Some(px(360.)),
+ Anchor::TopLeft,
+ cx,
+ ))
+ .into_any_element(),
+ Example::Placement => {
+ let preview = cx.entity();
+ v_flex()
+ .w_full()
+ .gap_3()
+ .child(
+ h_flex()
+ .justify_between()
+ .child(Self::trigger(
+ "Left edge",
+ ListItemSpacing::Dense,
+ None,
+ Anchor::TopLeft,
+ cx,
+ ))
+ .child(Self::trigger(
+ "Right edge",
+ ListItemSpacing::Dense,
+ None,
+ Anchor::TopRight,
+ cx,
+ )),
+ )
+ .child(
+ right_click_menu("placement-surface")
+ .trigger(|_, _, cx| {
+ v_flex()
+ .w_full()
+ .h(px(160.))
+ .items_center()
+ .justify_center()
+ .border_1()
+ .border_color(cx.theme().colors().border)
+ .rounded_md()
+ .child(Label::new("Right-click menu").color(Color::Muted))
+ })
+ .menu(move |window, cx| {
+ Self::open_menu(&preview, ListItemSpacing::Dense, None, window, cx)
+ }),
+ )
+ .into_any_element()
+ }
+ _ => Self::trigger(
+ "Open menu",
+ ListItemSpacing::Dense,
+ None,
+ Anchor::TopLeft,
+ cx,
+ )
+ .into_any_element(),
+ };
+
+ v_flex()
+ .id("context-menu-example")
+ .track_focus(&self.focus_handle)
+ .on_action(cx.listener(|this, _: &PreviewAction, _, cx| {
+ this.values.confirmations += 1;
+ cx.notify();
+ }))
+ .w_full()
+ .child(controls)
+ }
+}
+
+impl Component for ContextMenu {
+ fn scope() -> ComponentScope {
+ ComponentScope::Input
+ }
+
+ fn description() -> &'static str {
+ ""
+ }
+
+ fn preview(window: &mut Window, cx: &mut App) -> AnyElement {
+ example_group(
+ Example::ALL
+ .into_iter()
+ .map(|example| {
+ let preview = window.use_keyed_state(
+ (
+ ElementId::Name("context-menu-preview".into()),
+ example.title(),
+ ),
+ cx,
+ |_, cx| MenuPreview::new(example, cx),
+ );
+ single_example(example.title(), preview.into_any_element())
+ })
+ .collect(),
+ )
+ .into_any_element()
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use gpui::{Modifiers, TestAppContext, VisualTestContext, size};
+
+ use super::*;
+
+ #[gpui::test]
+ fn examples_open_record_actions_and_retain_values(cx: &mut TestAppContext) {
+ cx.update(|cx| {
+ let settings_store = settings::SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ theme_settings::init(theme::LoadThemes::JustBase, cx);
+ });
+
+ for example in Example::ALL {
+ let window = cx.open_window(size(px(900.), px(700.)), |_, cx| {
+ MenuPreview::new(example, cx)
+ });
+ let preview = window.root(cx).expect("preview");
+ let mut visual = VisualTestContext::from_window(window.into(), cx);
+ let focus_handle = visual.update(|window, cx| {
+ let focus_handle = preview.read(cx).focus_handle.clone();
+ window.focus(&focus_handle, cx);
+ window.draw(cx).clear(cx);
+ focus_handle
+ });
+ let trigger = match example {
+ Example::Content => "Dense · automatic width",
+ Example::Placement => "Left edge",
+ _ => "Open menu",
+ };
+
+ for open_count in 1..=2 {
+ let bounds = visual.debug_bounds(trigger).expect("menu trigger");
+ visual.simulate_click(bounds.center(), Modifiers::default());
+ visual.run_until_parked();
+ for _ in 0..2 {
+ visual.update(|window, cx| {
+ window.simulate_next_frame(cx);
+ window.draw(cx).clear(cx);
+ });
+ }
+ visual.update(|window, _| {
+ assert!(!focus_handle.is_focused(window), "{}", example.title());
+ });
+
+ if matches!(example, Example::Standard | Example::Persistent) {
+ visual.dispatch_action(menu::SelectFirst);
+ visual.dispatch_action(menu::Confirm);
+ visual.run_until_parked();
+ preview.read_with(&visual, |preview, _| {
+ assert_eq!(
+ preview.values.confirmations,
+ open_count,
+ "{}",
+ example.title()
+ );
+ if example == Example::Persistent {
+ assert_eq!(preview.values.archived, open_count % 2 != 0);
+ }
+ });
+ if example == Example::Persistent {
+ visual.update(|window, _| assert!(!focus_handle.is_focused(window)));
+ }
+ }
+
+ if example != Example::Standard {
+ visual.dispatch_action(menu::Cancel);
+ }
+ visual.run_until_parked();
+ visual.update(|window, cx| window.draw(cx).clear(cx));
+ visual.update(|window, _| {
+ assert!(focus_handle.is_focused(window), "{}", example.title());
+ });
+ }
+ }
+ }
+}