diff --git a/crates/gpui/src/elements/anchored.rs b/crates/gpui/src/elements/anchored.rs index 9fd564516d4..12f3f086c14 100644 --- a/crates/gpui/src/elements/anchored.rs +++ b/crates/gpui/src/elements/anchored.rs @@ -1,3 +1,5 @@ +use std::cmp::Ordering; + use smallvec::SmallVec; use crate::{ @@ -17,11 +19,21 @@ pub struct Anchored { children: SmallVec<[AnyElement; 2]>, anchor: Anchor, fit_mode: AnchoredFitMode, - anchor_position: Option>, + placement: Placement, position_mode: AnchoredPositionMode, offset: Option>, } +#[derive(Clone, Copy)] +enum Placement { + InPlace, + At(Point), + Attached { + target: Bounds, + corner: Anchor, + }, +} + /// anchored gives you an element that will avoid overflowing the window bounds. /// Its children should have no margin to avoid measurement issues. pub fn anchored() -> Anchored { @@ -29,7 +41,7 @@ pub fn anchored() -> Anchored { children: SmallVec::new(), anchor: Anchor::TopLeft, fit_mode: AnchoredFitMode::SwitchAnchor, - anchor_position: None, + placement: Placement::InPlace, position_mode: AnchoredPositionMode::Window, offset: None, } @@ -45,7 +57,20 @@ impl Anchored { /// Sets the position in window coordinates /// (otherwise the location the anchored element is rendered is used) pub fn position(mut self, anchor: Point) -> Self { - self.anchor_position = Some(anchor); + self.placement = Placement::At(anchor); + self + } + + /// Places the element next to `target`, with the element's [`Anchored::anchor`] corner + /// on `corner` of `target`. For example, a submenu puts its top-left corner on its row's + /// top-right corner. Use this instead of [`Anchored::position`]. + /// + /// If the element doesn't fit in the window, it moves to the other side of `target`, as + /// long as that side fits better. A submenu moves from the right of its row to the left, + /// and a dropdown moves from below its button to above. The offset flips with it. + /// [`AnchoredFitMode::SwitchAnchor`] has no effect here. + pub fn attach(mut self, target: Bounds, corner: Anchor) -> Self { + self.placement = Placement::Attached { target, corner }; self } @@ -57,8 +82,9 @@ impl Anchored { } /// Sets the position mode for this anchored element. Local will have this - /// interpret its [`Anchored::position`] as relative to the parent element. - /// While Window will have it interpret the position as relative to the window. + /// interpret its [`Anchored::position`] or [`Anchored::attach`] target as + /// relative to the parent element. While Window will have it interpret the + /// position as relative to the window. pub fn position_mode(mut self, mode: AnchoredPositionMode) -> Self { self.position_mode = mode; self @@ -139,8 +165,13 @@ impl Element for Anchored { .reduce(|acc, bounds| acc.union(&bounds)) .unwrap(); + let anchor_position = match self.placement { + Placement::InPlace => None, + Placement::At(position) => Some(position), + Placement::Attached { target, corner } => Some(target.corner(corner)), + }; let (origin, mut desired) = self.position_mode.get_position_and_bounds( - self.anchor_position, + anchor_position, self.anchor, children_bounds.size, bounds, @@ -152,7 +183,53 @@ impl Element for Anchored { size: window.viewport_size(), }; - if self.fit_mode == AnchoredFitMode::SwitchAnchor { + if let Placement::Attached { target, mut corner } = self.placement { + // Compare against the window edges, not the snap margin, so an element that + // already fits doesn't move. The client inset doesn't count as room either, + // since on Linux it's the window's transparent shadow. + let visible = limits.inset(window.client_inset.unwrap_or(px(0.))); + let overflow_along = |bounds: Bounds, axis: Axis| match axis { + Axis::Horizontal => { + (visible.left() - bounds.left()).max(px(0.)) + + (bounds.right() - visible.right()).max(px(0.)) + } + Axis::Vertical => { + (visible.top() - bounds.top()).max(px(0.)) + + (bounds.bottom() - visible.bottom()).max(px(0.)) + } + }; + let mut anchor = self.anchor; + let mut offset = self.offset.unwrap_or_default(); + for axis in [Axis::Horizontal, Axis::Vertical] { + let corner_side = side_along(corner, axis); + let is_outside_target = corner_side != Ordering::Equal + && side_along(anchor, axis) == corner_side.reverse(); + let overflow = overflow_along(desired, axis); + if !is_outside_target || overflow == px(0.) { + continue; + } + + let flipped_corner = corner.other_side_along(axis); + let flipped_anchor = anchor.other_side_along(axis); + let flipped_offset = match axis { + Axis::Horizontal => point(-offset.x, offset.y), + Axis::Vertical => point(offset.x, -offset.y), + }; + let (_, flipped) = self.position_mode.get_position_and_bounds( + Some(target.corner(flipped_corner)), + flipped_anchor, + children_bounds.size, + bounds, + Some(flipped_offset), + ); + if overflow_along(flipped, axis) < overflow { + corner = flipped_corner; + anchor = flipped_anchor; + offset = flipped_offset; + desired = flipped; + } + } + } else if self.fit_mode == AnchoredFitMode::SwitchAnchor { let mut anchor = self.anchor; if desired.left() < limits.left() || desired.right() > limits.right() { @@ -238,6 +315,23 @@ impl IntoElement for Anchored { } } +/// Which side of a box `anchor` is on along `axis`. `Less` is left or top, `Equal` is the +/// center, and `Greater` is right or bottom. +fn side_along(anchor: Anchor, axis: Axis) -> Ordering { + match axis { + Axis::Horizontal => match anchor { + Anchor::TopLeft | Anchor::BottomLeft | Anchor::LeftCenter => Ordering::Less, + Anchor::TopCenter | Anchor::BottomCenter => Ordering::Equal, + Anchor::TopRight | Anchor::BottomRight | Anchor::RightCenter => Ordering::Greater, + }, + Axis::Vertical => match anchor { + Anchor::TopLeft | Anchor::TopRight | Anchor::TopCenter => Ordering::Less, + Anchor::LeftCenter | Anchor::RightCenter => Ordering::Equal, + Anchor::BottomLeft | Anchor::BottomRight | Anchor::BottomCenter => Ordering::Greater, + }, + } +} + /// Which algorithm to use when fitting the anchored element to be inside the window. #[derive(Copy, Clone, PartialEq)] pub enum AnchoredFitMode { @@ -291,8 +385,8 @@ impl AnchoredPositionMode { #[cfg(test)] mod tests { use crate::{ - Context, Pixels, PlatformInput, Point, TestAppContext, Window, deferred, div, point, - prelude::*, px, size, + Anchor, Bounds, Context, Pixels, PlatformInput, Point, TestAppContext, Window, deferred, + div, point, prelude::*, px, size, }; struct AnchoredTestView { @@ -395,4 +489,91 @@ mod tests { assert_eq!(menu_bounds.origin, point(px(100.), px(300.))); assert_eq!(menu_bounds.size, size(px(200.), px(300.))); } + + struct AttachedTestView { + target: Bounds, + corner: Anchor, + anchor: Anchor, + } + + impl Render for AttachedTestView { + fn render(&mut self, _window: &mut Window, _cx: &mut Context) -> impl IntoElement { + div().size_full().child( + deferred( + super::anchored() + .attach(self.target, self.corner) + .anchor(self.anchor) + .offset(point(px(-2.), px(4.))) + .snap_to_window_with_margin(px(8.)) + .child( + div() + .debug_selector(|| "MENU".into()) + .w(px(200.)) + .h(px(300.)), + ), + ) + .with_priority(1), + ) + } + } + + #[gpui::test] + fn test_anchored_attach_moves_to_the_side_with_room(cx: &mut TestAppContext) { + let trigger = |x: f32, y: f32| Bounds::new(point(px(x), px(y)), size(px(100.), px(20.))); + // A submenu sits to the right of its trigger, with their top edges lined up. + let submenu = (Anchor::TopRight, Anchor::TopLeft); + // A dropdown sits below its button, with their left edges lined up. + let dropdown = (Anchor::BottomLeft, Anchor::TopLeft); + for (target, (corner, anchor), expected_origin) in [ + (trigger(100., 100.), submenu, point(px(198.), px(104.))), + (trigger(550., 100.), submenu, point(px(352.), px(104.))), + (trigger(100., 400.), dropdown, point(px(98.), px(96.))), + // Ends 4px from the window edge. That's inside the snap margin but still fits, + // so it stays. + (trigger(498., 100.), submenu, point(px(596.), px(104.))), + // Doesn't fit on either side. The left sticks out less, so it goes left and + // slides back into the window. + ( + Bounds::new(point(px(180.), px(100.)), size(px(500.), px(20.))), + submenu, + point(px(8.), px(104.)), + ), + // Doesn't fit on either side, but the right sticks out less, so it stays right + // and slides back into the window. + ( + Bounds::new(point(px(50.), px(100.)), size(px(650.), px(20.))), + submenu, + point(px(592.), px(104.)), + ), + // A dropdown that runs off the right edge slides left. It never moves beside its + // button. + (trigger(700., 100.), dropdown, point(px(592.), px(124.))), + // Centered under its button, so it can move above it but never sideways. + ( + trigger(100., 400.), + (Anchor::BottomCenter, Anchor::TopCenter), + point(px(48.), px(96.)), + ), + ] { + let window = cx.open_window(size(px(800.), px(600.)), |_, _| AttachedTestView { + target, + corner, + anchor, + }); + + cx.run_until_parked(); + + let menu_bounds = window + .update(cx, |_, window, _| { + window.rendered_frame.debug_bounds.get("MENU").copied() + }) + .unwrap() + .expect("MENU debug bounds not found"); + + assert_eq!( + menu_bounds.origin, expected_origin, + "target: {target:?}, corner: {corner:?}, anchor: {anchor:?}" + ); + } + } } diff --git a/crates/settings_ui/src/components/dropdown.rs b/crates/settings_ui/src/components/dropdown.rs index 04ab548f352..337e75eea33 100644 --- a/crates/settings_ui/src/components/dropdown.rs +++ b/crates/settings_ui/src/components/dropdown.rs @@ -132,6 +132,7 @@ impl RenderOnce for EnumVariantDropdown { .when_some(self.tab_index, |elem, tab_index| elem.tab_index(tab_index)) .trigger_size(ButtonSize::Medium) .style(DropdownStyle::Outlined) + .attach(gpui::Anchor::BottomRight) .offset(gpui::Point { x: px(0.0), y: px(2.0), diff --git a/crates/settings_ui/src/pages/edit_prediction_provider_setup.rs b/crates/settings_ui/src/pages/edit_prediction_provider_setup.rs index 5cc77153301..66096f03eed 100644 --- a/crates/settings_ui/src/pages/edit_prediction_provider_setup.rs +++ b/crates/settings_ui/src/pages/edit_prediction_provider_setup.rs @@ -177,7 +177,8 @@ fn render_provider_dropdown(window: &mut Window, cx: &mut App) -> AnyElement { .child( DropdownMenu::new("provider-dropdown", current_provider_name, menu) .tab_index(0) - .style(DropdownStyle::Outlined), + .style(DropdownStyle::Outlined) + .attach(gpui::Anchor::BottomRight), ), ) .into_any_element() diff --git a/crates/ui/src/components/context_menu.rs b/crates/ui/src/components/context_menu.rs index 3ff74bfc6c6..078f6612ee9 100644 --- a/crates/ui/src/components/context_menu.rs +++ b/crates/ui/src/components/context_menu.rs @@ -1667,7 +1667,6 @@ impl ContextMenu { ix, submenu, is_active_descendant(!submenu.disabled), - window, cx, ) .into_any_element(), @@ -1679,7 +1678,6 @@ impl ContextMenu { ix: usize, submenu: &ContextMenuSubmenu, is_active_descendant: bool, - window: &Window, cx: &mut Context, ) -> impl IntoElement { let ContextMenuSubmenu { @@ -1848,7 +1846,7 @@ impl ContextMenu { ), ) .when_some(submenu, |this, (submenu, trigger_bounds)| { - this.child(self.render_submenu_container(ix, submenu, trigger_bounds, window, cx)) + this.child(self.render_submenu_container(ix, submenu, trigger_bounds.size, cx)) }) } @@ -1870,21 +1868,9 @@ impl ContextMenu { &self, ix: usize, submenu: Entity, - trigger_bounds: Bounds, - window: &Window, + trigger_size: Size, cx: &mut Context, ) -> impl IntoElement { - let space_on_right = window.viewport_size().width - trigger_bounds.right(); - let space_on_left = trigger_bounds.left(); - let flip_left = space_on_right < CONTEXT_MENU_MIN_WIDTH && space_on_left > space_on_right; - let anchor_position = point( - if flip_left { - px(2.) - } else { - trigger_bounds.size.width - px(2.) - }, - px(0.), - ); let bounds_cell = self.submenu_bounds.clone(); let canvas = canvas( { @@ -1904,13 +1890,13 @@ impl ContextMenu { div().absolute().top_0().left_0().w(px(0.)).h(px(0.)).child( deferred( anchored() - .position(anchor_position) .position_mode(AnchoredPositionMode::Local) - .anchor(if flip_left { - Anchor::TopRight - } else { - Anchor::TopLeft - }) + .attach( + Bounds::new(Point::default(), trigger_size), + Anchor::TopRight, + ) + .anchor(Anchor::TopLeft) + .offset(point(px(-2.), px(0.))) .snap_to_window_with_margin(px(8.0)) .child( div() @@ -3102,6 +3088,60 @@ mod tests { } } + #[gpui::test] + fn wide_submenu_opens_on_the_side_it_fits(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); + }); + + let window = cx.open_window(size(px(900.), px(400.)), |window, cx| { + let menu = ContextMenu::build(window, cx, |menu, _, _| { + menu.submenu("Wide", |menu, _, _| { + menu.custom_row(|_, _| div().w(px(320.)).child("wide").into_any_element()) + }) + }); + SubmenuTestView { + menu, + left: px(400.), + } + }); + cx.run_until_parked(); + let menu = window + .update(cx, |view, _, _| view.menu.clone()) + .expect("submenu window"); + let mut visual = VisualTestContext::from_window(window.into(), cx); + draw_frames(&mut visual); + + menu.update_in(&mut visual, |menu, window, cx| { + menu.select_first(&SelectFirst, window, cx); + menu.select_submenu_child(&SelectChild, window, cx); + }); + draw_frames(&mut visual); + + menu.read_with(&visual, |menu, _| { + let trigger = menu + .submenu_trigger_bounds + .borrow() + .get(&0) + .copied() + .expect("trigger bounds"); + let submenu = menu.submenu_bounds.get().expect("submenu bounds"); + let space_on_right = px(900.) - trigger.right(); + assert!( + space_on_right > CONTEXT_MENU_MIN_WIDTH && space_on_right < submenu.size.width, + "trigger: {trigger:?}, submenu: {submenu:?}" + ); + assert_eq!( + submenu.right(), + trigger.left() + px(2.), + "trigger: {trigger:?}, submenu: {submenu:?}" + ); + assert_eq!(submenu.top(), trigger.top()); + }); + } + #[gpui::test] fn submenu_content_keeps_focus(cx: &mut TestAppContext) { let content_focus = cx.update(|cx| cx.focus_handle()); diff --git a/crates/ui/src/components/dropdown_menu.rs b/crates/ui/src/components/dropdown_menu.rs index 8991f992967..777a76da2d7 100644 --- a/crates/ui/src/components/dropdown_menu.rs +++ b/crates/ui/src/components/dropdown_menu.rs @@ -1,4 +1,4 @@ -use gpui::{Anchor, AnyView, Entity, Pixels, Point, Role}; +use gpui::{Anchor, AnyView, Axis, Entity, Pixels, Point, Role}; use crate::{ButtonLike, ContextMenu, PopoverMenu, prelude::*}; @@ -125,7 +125,10 @@ impl DropdownMenu { self } - /// Defines which corner of the handle to attach the menu's anchor to. + /// Defines which corner of the trigger the menu lines up with. The default, + /// [`Anchor::BottomLeft`], opens the menu below the trigger with their left edges lined + /// up. Use [`Anchor::BottomRight`] to line up the right edges instead, for a trigger at + /// the right end of a row. pub fn attach(mut self, attach: Anchor) -> Self { self.attach = Some(attach); self @@ -304,11 +307,10 @@ impl RenderOnce for DropdownMenu { _ => popover, }; + let attach = self.attach.unwrap_or(Anchor::BottomLeft); popover - .attach(match self.attach { - Some(attach) => attach, - None => Anchor::BottomRight, - }) + .attach(attach) + .anchor(attach.other_side_along(Axis::Vertical)) .when_some(self.offset, |this, offset| this.offset(offset)) } } @@ -417,3 +419,99 @@ impl Component for DropdownMenu { .into_any_element() } } + +#[cfg(test)] +mod tests { + use gpui::{Bounds, TestAppContext, VisualTestContext, size}; + + use super::*; + + struct DropdownTestView { + handle: PopoverMenuHandle, + menu: Entity, + attach: Option, + at_right_edge: bool, + } + + impl Render for DropdownTestView { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + let trigger = div() + .absolute() + .top(px(40.)) + .map(|this| { + if self.at_right_edge { + this.right(px(40.)) + } else { + this.left(px(40.)) + } + }) + .debug_selector(|| "TRIGGER".into()) + .child( + DropdownMenu::new("dropdown", "Pick", self.menu.clone()) + .handle(self.handle.clone()) + .when_some(self.attach, |this, attach| this.attach(attach)), + ); + div().size_full().child(trigger) + } + } + + fn open_dropdown( + attach: Option, + at_right_edge: bool, + cx: &mut TestAppContext, + ) -> (Bounds, Bounds) { + cx.update(|cx| { + let settings_store = settings::SettingsStore::test(cx); + cx.set_global(settings_store); + theme_settings::init(theme::LoadThemes::JustBase, cx); + }); + let handle = PopoverMenuHandle::default(); + let window = cx.open_window(size(px(800.), px(600.)), |window, cx| { + let menu = ContextMenu::build(window, cx, |menu, _, _| { + menu.custom_row(|_, _| { + div() + .debug_selector(|| "MENU_ROW".into()) + .w(px(300.)) + .h(px(20.)) + .into_any_element() + }) + }); + DropdownTestView { + handle: handle.clone(), + menu, + attach, + at_right_edge, + } + }); + cx.run_until_parked(); + let mut cx = VisualTestContext::from_window(window.into(), cx); + cx.update(|window, cx| window.draw(cx).clear(cx)); + cx.update(|window, cx| handle.show(window, cx)); + for _ in 0..3 { + cx.update(|window, cx| window.draw(cx).clear(cx)); + } + let trigger = cx.debug_bounds("TRIGGER").expect("trigger bounds"); + let menu_row = cx.debug_bounds("MENU_ROW").expect("menu row bounds"); + (trigger, menu_row) + } + + #[gpui::test] + fn dropdown_lines_up_with_its_attached_edge(cx: &mut TestAppContext) { + for (attach, at_right_edge) in [(None, false), (Some(Anchor::BottomRight), true)] { + let (trigger, menu_row) = open_dropdown(attach, at_right_edge, cx); + let (menu_edge, trigger_edge) = if at_right_edge { + (menu_row.right(), trigger.right()) + } else { + (menu_row.left(), trigger.left()) + }; + assert!( + menu_row.top() >= trigger.bottom(), + "attach: {attach:?}, trigger: {trigger:?}, menu row: {menu_row:?}" + ); + assert!( + (menu_edge - trigger_edge).abs() < px(12.), + "attach: {attach:?}, trigger: {trigger:?}, menu row: {menu_row:?}" + ); + } + } +} diff --git a/crates/ui/src/components/popover_menu.rs b/crates/ui/src/components/popover_menu.rs index 06e206f3006..44a381ccd11 100644 --- a/crates/ui/src/components/popover_menu.rs +++ b/crates/ui/src/components/popover_menu.rs @@ -224,7 +224,8 @@ impl PopoverMenu { self } - /// Defines which corner of the handle to attach the menu's anchor to. + /// Defines which corner of the handle to attach the menu's anchor to. If the menu doesn't + /// fit on that side of the handle, it opens on the other side. pub fn attach(mut self, attach: Anchor) -> Self { self.attach = Some(attach); self @@ -373,14 +374,17 @@ impl Element for PopoverMenu { let menu_element = element_state.menu.borrow_mut().as_mut().map(|menu| { let offset = self.resolved_offset(window); - let mut anchored = anchored() + let anchored = anchored() .snap_to_window_with_margin(px(8.)) - .anchor(self.anchor) - .offset(offset); - if let Some(child_bounds) = element_state.child_bounds { - anchored = - anchored.position(child_bounds.corner(self.resolved_attach()) + offset); - } + .anchor(self.anchor); + let anchored = match element_state.child_bounds { + // The offset is doubled on purpose. This used to add it twice, and + // callers picked their offsets with that in mind. + Some(child_bounds) => anchored + .attach(child_bounds, self.resolved_attach()) + .offset(offset + offset), + None => anchored.offset(offset), + }; let mut element = deferred(anchored.child(div().occlude().child(menu.clone()))) .with_priority(1) .into_any(); @@ -506,3 +510,97 @@ impl IntoElement for PopoverMenu { self } } + +#[cfg(test)] +mod tests { + use gpui::{EventEmitter, FocusHandle, Focusable, TestAppContext, VisualTestContext}; + + use super::*; + use crate::Button; + + struct TestMenu { + focus_handle: FocusHandle, + } + + impl EventEmitter for TestMenu {} + + impl Focusable for TestMenu { + fn focus_handle(&self, _: &App) -> FocusHandle { + self.focus_handle.clone() + } + } + + impl Render for TestMenu { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + div() + .track_focus(&self.focus_handle) + .debug_selector(|| "MENU".into()) + .w(px(200.)) + .h(px(100.)) + } + } + + struct PopoverTestView { + handle: PopoverMenuHandle, + top: Pixels, + } + + impl Render for PopoverTestView { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + div().size_full().child( + div() + .absolute() + .left(px(100.)) + .top(self.top) + .debug_selector(|| "TRIGGER".into()) + .child( + PopoverMenu::new("popover") + .trigger(Button::new("trigger", "Open")) + .menu(|_, cx| { + Some(cx.new(|cx| TestMenu { + focus_handle: cx.focus_handle(), + })) + }) + .with_handle(self.handle.clone()), + ), + ) + } + } + + #[gpui::test] + fn popover_opens_below_its_trigger_or_above_when_it_does_not_fit(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 (top, opens_above) in [(px(40.), false), (px(560.), true)] { + let handle = PopoverMenuHandle::default(); + let window = cx.open_window(size(px(800.), px(600.)), |_, _| PopoverTestView { + handle: handle.clone(), + top, + }); + cx.run_until_parked(); + let mut cx = VisualTestContext::from_window(window.into(), cx); + cx.update(|window, cx| window.draw(cx).clear(cx)); + cx.update(|window, cx| handle.show(window, cx)); + for _ in 0..3 { + cx.update(|window, cx| window.draw(cx).clear(cx)); + } + + let trigger = cx.debug_bounds("TRIGGER").expect("trigger bounds"); + let menu = cx.debug_bounds("MENU").expect("menu bounds"); + let offset = cx.update(|window, _| rems_from_px(5_f32) * window.rem_size()); + let top = if opens_above { + trigger.top() - menu.size.height + } else { + trigger.bottom() + }; + assert_eq!( + menu.origin, + point(trigger.left() - offset - offset, top), + "trigger: {trigger:?}, menu: {menu:?}" + ); + } + } +}