zed-industries/zed
1
1
Fork 0
mirror of https://github.com/zed-industries/zed.git synced 2024-11-10 14:06:11 +03:00
Code Issues Packages Projects Releases Wiki Activity

Allow you to click on a context menu item

Browse Source
This commit is contained in:
Conrad Irwin 2023-11-17 11:57:51 -07:00
parent 2d1d75f482
commit 9d742b90c3
6 changed files with 139 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
crates/gpui2/src/app/entity_map.rs
View File

@ -71,11 +71,12 @@ impl EntityMap {
#[track_caller] #[track_caller]
pub fn lease<'a, T>(&mut self, model: &'a Model<T>) -> Lease<'a, T> { pub fn lease<'a, T>(&mut self, model: &'a Model<T>) -> Lease<'a, T> {
self.assert_valid_context(model); self.assert_valid_context(model);
let entity = Some( let entity = Some(self.entities.remove(model.entity_id).unwrap_or_else(|| {
self.entities panic!(
.remove(model.entity_id) "Circular entity lease of {}. Is it already being updated?",
.expect("Circular entity lease. Is the entity already being updated?"), std::any::type_name::<T>()
); )
}));
Lease { Lease {
model, model,
entity, entity,

5
crates/gpui2/src/elements/div.rs
View File

@ -1124,9 +1124,14 @@ where
} }
} }
} }
// if self.hover_style.is_some() {
if bounds.contains_point(&mouse_position) { if bounds.contains_point(&mouse_position) {
// eprintln!("div hovered {bounds:?} {mouse_position:?}");
style.refine(&self.hover_style); style.refine(&self.hover_style);
} else {
// eprintln!("div NOT hovered {bounds:?} {mouse_position:?}");
} }
// }
if let Some(drag) = cx.active_drag.take() { if let Some(drag) = cx.active_drag.take() {
for (state_type, group_drag_style) in &self.group_drag_over_styles { for (state_type, group_drag_style) in &self.group_drag_over_styles {

5
crates/gpui2/src/platform/mac/window.rs
View File

@ -1205,10 +1205,7 @@ extern "C" fn handle_view_event(this: &Object, _: Sel, native_event: id) {
InputEvent::MouseMove(_) if !(is_active || lock.kind == WindowKind::PopUp) => return, InputEvent::MouseMove(_) if !(is_active || lock.kind == WindowKind::PopUp) => return,
InputEvent::MouseUp(MouseUpEvent { InputEvent::MouseUp(MouseUpEvent { .. }) => {
button: MouseButton::Left,
..
}) => {
lock.synthetic_drag_counter += 1; lock.synthetic_drag_counter += 1;
} }

103
crates/ui2/src/components/context_menu.rs
View File

@ -6,39 +6,66 @@ use crate::{v_stack, Label, List, ListEntry, ListItem, ListSeparator, ListSubHea
use gpui::{ use gpui::{
overlay, px, Action, AnchorCorner, AnyElement, Bounds, Dismiss, DispatchPhase, Div, overlay, px, Action, AnchorCorner, AnyElement, Bounds, Dismiss, DispatchPhase, Div,
FocusHandle, LayoutId, ManagedView, MouseButton, MouseDownEvent, Pixels, Point, Render, View, FocusHandle, LayoutId, ManagedView, MouseButton, MouseDownEvent, Pixels, Point, Render, View,
VisualContext, WeakView,
}; };
pub struct ContextMenu { pub enum ContextMenuItem<V> {
items: Vec<ListItem>, Separator(ListSeparator),
focus_handle: FocusHandle, Header(ListSubHeader),
Entry(
ListEntry<ContextMenu<V>>,
Rc<dyn Fn(&mut V, &mut ViewContext<V>)>,
),
} }
impl ManagedView for ContextMenu { pub struct ContextMenu<V> {
items: Vec<ContextMenuItem<V>>,
focus_handle: FocusHandle,
handle: WeakView<V>,
}
impl<V: Render> ManagedView for ContextMenu<V> {
fn focus_handle(&self, cx: &gpui::AppContext) -> FocusHandle { fn focus_handle(&self, cx: &gpui::AppContext) -> FocusHandle {
self.focus_handle.clone() self.focus_handle.clone()
} }
} }
impl ContextMenu { impl<V: Render> ContextMenu<V> {
pub fn new(cx: &mut WindowContext) -> Self { pub fn build(
cx: &mut ViewContext<V>,
f: impl FnOnce(Self, &mut ViewContext<Self>) -> Self,
) -> View<Self> {
let handle = cx.view().downgrade();
cx.build_view(|cx| {
f(
Self { Self {
handle,
items: Default::default(), items: Default::default(),
focus_handle: cx.focus_handle(), focus_handle: cx.focus_handle(),
} },
cx,
)
})
} }
pub fn header(mut self, title: impl Into<SharedString>) -> Self { pub fn header(mut self, title: impl Into<SharedString>) -> Self {
self.items.push(ListItem::Header(ListSubHeader::new(title))); self.items
.push(ContextMenuItem::Header(ListSubHeader::new(title)));
self self
} }
pub fn separator(mut self) -> Self { pub fn separator(mut self) -> Self {
self.items.push(ListItem::Separator(ListSeparator)); self.items.push(ContextMenuItem::Separator(ListSeparator));
self self
} }
pub fn entry(mut self, label: Label, action: Box<dyn Action>) -> Self { pub fn entry(
self.items.push(ListEntry::new(label).action(action).into()); mut self,
view: ListEntry<Self>,
on_click: impl Fn(&mut V, &mut ViewContext<V>) + 'static,
) -> Self {
self.items
.push(ContextMenuItem::Entry(view, Rc::new(on_click)));
self self
} }
@ -52,9 +79,9 @@ impl ContextMenu {
} }
} }
impl Render for ContextMenu { impl<V: Render> Render for ContextMenu<V> {
type Element = Div<Self>; type Element = Div<Self>;
// todo!()
fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element { fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
div().elevation_2(cx).flex().flex_row().child( div().elevation_2(cx).flex().flex_row().child(
v_stack() v_stack()
@ -71,7 +98,25 @@ impl Render for ContextMenu {
// .bg(cx.theme().colors().elevated_surface_background) // .bg(cx.theme().colors().elevated_surface_background)
// .border() // .border()
// .border_color(cx.theme().colors().border) // .border_color(cx.theme().colors().border)
.child(List::new(self.items.clone())), .child(List::new(
self.items
.iter()
.map(|item| match item {
ContextMenuItem::Separator(separator) => {
ListItem::Separator(separator.clone())
}
ContextMenuItem::Header(header) => ListItem::Header(header.clone()),
ContextMenuItem::Entry(entry, callback) => {
let callback = callback.clone();
let handle = self.handle.clone();
ListItem::Entry(entry.clone().on_click(move |this, cx| {
handle.update(cx, |view, cx| callback(view, cx)).ok();
cx.emit(Dismiss);
}))
}
})
.collect(),
)),
) )
} }
} }
@ -232,6 +277,7 @@ impl<V: 'static, M: ManagedView> Element<V> for MenuHandle<V, M> {
} }
}) })
.detach(); .detach();
cx.focus_view(&new_menu);
*menu.borrow_mut() = Some(new_menu); *menu.borrow_mut() = Some(new_menu);
*position.borrow_mut() = if attach.is_some() && child_layout_id.is_some() { *position.borrow_mut() = if attach.is_some() && child_layout_id.is_some() {
@ -260,16 +306,25 @@ pub use stories::*;
mod stories { mod stories {
use super::*; use super::*;
use crate::story::Story; use crate::story::Story;
use gpui::{actions, Div, Render, VisualContext}; use gpui::{actions, Div, Render};
actions!(PrintCurrentDate); actions!(PrintCurrentDate, PrintBestFood);
fn build_menu(cx: &mut WindowContext, header: impl Into<SharedString>) -> View<ContextMenu> { fn build_menu<V: Render>(
cx.build_view(|cx| { cx: &mut ViewContext<V>,
ContextMenu::new(cx).header(header).separator().entry( header: impl Into<SharedString>,
Label::new("Print current time"), ) -> View<ContextMenu<V>> {
PrintCurrentDate.boxed_clone(), let handle = cx.view().clone();
) ContextMenu::build(cx, |menu, _| {
menu.header(header)
.separator()
.entry(ListEntry::new(Label::new("Print current time")), |v, cx| {
println!("dispatching PrintCurrentTime action");
cx.dispatch_action(PrintCurrentDate.boxed_clone())
})
.entry(ListEntry::new(Label::new("Print best food")), |v, cx| {
cx.dispatch_action(PrintBestFood.boxed_clone())
})
}) })
} }
@ -281,10 +336,14 @@ mod stories {
fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element { fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
Story::container(cx) Story::container(cx)
.on_action(|_, _: &PrintCurrentDate, _| { .on_action(|_, _: &PrintCurrentDate, _| {
println!("printing unix time!");
if let Ok(unix_time) = std::time::UNIX_EPOCH.elapsed() { if let Ok(unix_time) = std::time::UNIX_EPOCH.elapsed() {
println!("Current Unix time is {:?}", unix_time.as_secs()); println!("Current Unix time is {:?}", unix_time.as_secs());
} }
}) })
.on_action(|_, _: &PrintBestFood, _| {
println!("burrito");
})
.flex() .flex()
.flex_row() .flex_row()
.justify_between() .justify_between()

74
crates/ui2/src/components/list.rs
View File

@ -1,4 +1,6 @@
use gpui::{div, Action}; use std::rc::Rc;
use gpui::{div, Div, Stateful, StatefulInteractiveComponent};
use crate::settings::user_settings; use crate::settings::user_settings;
use crate::{ use crate::{
@ -172,35 +174,35 @@ pub enum ListEntrySize {
Medium, Medium,
} }
#[derive(Component, Clone)] #[derive(Clone)]
pub enum ListItem { pub enum ListItem<V: 'static> {
Entry(ListEntry), Entry(ListEntry<V>),
Separator(ListSeparator), Separator(ListSeparator),
Header(ListSubHeader), Header(ListSubHeader),
} }
impl From<ListEntry> for ListItem { impl<V: 'static> From<ListEntry<V>> for ListItem<V> {
fn from(entry: ListEntry) -> Self { fn from(entry: ListEntry<V>) -> Self {
Self::Entry(entry) Self::Entry(entry)
} }
} }
impl From<ListSeparator> for ListItem { impl<V: 'static> From<ListSeparator> for ListItem<V> {
fn from(entry: ListSeparator) -> Self { fn from(entry: ListSeparator) -> Self {
Self::Separator(entry) Self::Separator(entry)
} }
} }
impl From<ListSubHeader> for ListItem { impl<V: 'static> From<ListSubHeader> for ListItem<V> {
fn from(entry: ListSubHeader) -> Self { fn from(entry: ListSubHeader) -> Self {
Self::Header(entry) Self::Header(entry)
} }
} }
impl ListItem { impl<V: 'static> ListItem<V> {
fn render<V: 'static>(self, view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> { fn render(self, view: &mut V, ix: usize, cx: &mut ViewContext<V>) -> impl Component<V> {
match self { match self {
ListItem::Entry(entry) => div().child(entry.render(view, cx)), ListItem::Entry(entry) => div().child(entry.render(ix, cx)),
ListItem::Separator(separator) => div().child(separator.render(view, cx)), ListItem::Separator(separator) => div().child(separator.render(view, cx)),
ListItem::Header(header) => div().child(header.render(view, cx)), ListItem::Header(header) => div().child(header.render(view, cx)),
} }
@ -210,7 +212,7 @@ impl ListItem {
Self::Entry(ListEntry::new(label)) Self::Entry(ListEntry::new(label))
} }
pub fn as_entry(&mut self) -> Option<&mut ListEntry> { pub fn as_entry(&mut self) -> Option<&mut ListEntry<V>> {
if let Self::Entry(entry) = self { if let Self::Entry(entry) = self {
Some(entry) Some(entry)
} else { } else {
@ -219,8 +221,7 @@ impl ListItem {
} }
} }
#[derive(Component)] pub struct ListEntry<V> {
pub struct ListEntry {
disabled: bool, disabled: bool,
// TODO: Reintroduce this // TODO: Reintroduce this
// disclosure_control_style: DisclosureControlVisibility, // disclosure_control_style: DisclosureControlVisibility,
@ -231,15 +232,13 @@ pub struct ListEntry {
size: ListEntrySize, size: ListEntrySize,
toggle: Toggle, toggle: Toggle,
variant: ListItemVariant, variant: ListItemVariant,
on_click: Option<Box<dyn Action>>, on_click: Option<Rc<dyn Fn(&mut V, &mut ViewContext<V>) + 'static>>,
} }
impl Clone for ListEntry { impl<V> Clone for ListEntry<V> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
disabled: self.disabled, disabled: self.disabled,
// TODO: Reintroduce this
// disclosure_control_style: DisclosureControlVisibility,
indent_level: self.indent_level, indent_level: self.indent_level,
label: self.label.clone(), label: self.label.clone(),
left_slot: self.left_slot.clone(), left_slot: self.left_slot.clone(),
@ -247,12 +246,12 @@ impl Clone for ListEntry {
size: self.size, size: self.size,
toggle: self.toggle, toggle: self.toggle,
variant: self.variant, variant: self.variant,
on_click: self.on_click.as_ref().map(|opt| opt.boxed_clone()), on_click: self.on_click.clone(),
} }
} }
} }
impl ListEntry { impl<V: 'static> ListEntry<V> {
pub fn new(label: Label) -> Self { pub fn new(label: Label) -> Self {
Self { Self {
disabled: false, disabled: false,
@ -267,8 +266,8 @@ impl ListEntry {
} }
} }
pub fn action(mut self, action: impl Into<Box<dyn Action>>) -> Self { pub fn on_click(mut self, handler: impl Fn(&mut V, &mut ViewContext<V>) + 'static) -> Self {
self.on_click = Some(action.into()); self.on_click = Some(Rc::new(handler));
self self
} }
@ -307,7 +306,7 @@ impl ListEntry {
self self
} }
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> { fn render(self, ix: usize, cx: &mut ViewContext<V>) -> Stateful<V, Div<V>> {
let settings = user_settings(cx); let settings = user_settings(cx);
let left_content = match self.left_slot.clone() { let left_content = match self.left_slot.clone() {
@ -328,21 +327,21 @@ impl ListEntry {
ListEntrySize::Medium => div().h_7(), ListEntrySize::Medium => div().h_7(),
}; };
div() div()
.id(ix)
.relative() .relative()
.hover(|mut style| { .hover(|mut style| {
style.background = Some(cx.theme().colors().editor_background.into()); style.background = Some(cx.theme().colors().editor_background.into());
style style
}) })
.on_mouse_down(gpui::MouseButton::Left, { .on_click({
let action = self.on_click.map(|action| action.boxed_clone()); let on_click = self.on_click.clone();
move |entry: &mut V, event, cx| { move |view: &mut V, event, cx| {
if let Some(action) = action.as_ref() { if let Some(on_click) = &on_click {
cx.dispatch_action(action.boxed_clone()); (on_click)(view, cx)
} }
} }
}) })
.group("")
.bg(cx.theme().colors().surface_background) .bg(cx.theme().colors().surface_background)
// TODO: Add focus state // TODO: Add focus state
// .when(self.state == InteractionState::Focused, |this| { // .when(self.state == InteractionState::Focused, |this| {
@ -391,8 +390,8 @@ impl ListSeparator {
} }
#[derive(Component)] #[derive(Component)]
pub struct List { pub struct List<V: 'static> {
items: Vec<ListItem>, items: Vec<ListItem<V>>,
/// Message to display when the list is empty /// Message to display when the list is empty
/// Defaults to "No items" /// Defaults to "No items"
empty_message: SharedString, empty_message: SharedString,
@ -400,8 +399,8 @@ pub struct List {
toggle: Toggle, toggle: Toggle,
} }
impl List { impl<V: 'static> List<V> {
pub fn new(items: Vec<ListItem>) -> Self { pub fn new(items: Vec<ListItem<V>>) -> Self {
Self { Self {
items, items,
empty_message: "No items".into(), empty_message: "No items".into(),
@ -425,9 +424,14 @@ impl List {
self self
} }
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> { fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let list_content = match (self.items.is_empty(), self.toggle) { let list_content = match (self.items.is_empty(), self.toggle) {
(false, _) => div().children(self.items), (false, _) => div().children(
self.items
.into_iter()
.enumerate()
.map(|(ix, item)| item.render(view, ix, cx)),
),
(true, Toggle::Toggled(false)) => div(), (true, Toggle::Toggled(false)) => div(),
(true, _) => { (true, _) => {
div().child(Label::new(self.empty_message.clone()).color(TextColor::Muted)) div().child(Label::new(self.empty_message.clone()).color(TextColor::Muted))

8
crates/ui2/src/static_data.rs
View File

@ -478,7 +478,7 @@ pub fn static_new_notification_items_2<V: 'static>() -> Vec<Notification<V>> {
] ]
} }
pub fn static_project_panel_project_items() -> Vec<ListItem> { pub fn static_project_panel_project_items<V>() -> Vec<ListItem<V>> {
vec![ vec![
ListEntry::new(Label::new("zed")) ListEntry::new(Label::new("zed"))
.left_icon(Icon::FolderOpen.into()) .left_icon(Icon::FolderOpen.into())
@ -605,7 +605,7 @@ pub fn static_project_panel_project_items() -> Vec<ListItem> {
.collect() .collect()
} }
pub fn static_project_panel_single_items() -> Vec<ListItem> { pub fn static_project_panel_single_items<V>() -> Vec<ListItem<V>> {
vec![ vec![
ListEntry::new(Label::new("todo.md")) ListEntry::new(Label::new("todo.md"))
.left_icon(Icon::FileDoc.into()) .left_icon(Icon::FileDoc.into())
@ -622,7 +622,7 @@ pub fn static_project_panel_single_items() -> Vec<ListItem> {
.collect() .collect()
} }
pub fn static_collab_panel_current_call() -> Vec<ListItem> { pub fn static_collab_panel_current_call<V>() -> Vec<ListItem<V>> {
vec![ vec![
ListEntry::new(Label::new("as-cii")).left_avatar("http://github.com/as-cii.png?s=50"), ListEntry::new(Label::new("as-cii")).left_avatar("http://github.com/as-cii.png?s=50"),
ListEntry::new(Label::new("nathansobo")) ListEntry::new(Label::new("nathansobo"))
@ -635,7 +635,7 @@ pub fn static_collab_panel_current_call() -> Vec<ListItem> {
.collect() .collect()
} }
pub fn static_collab_panel_channels() -> Vec<ListItem> { pub fn static_collab_panel_channels<V>() -> Vec<ListItem<V>> {
vec![ vec![
ListEntry::new(Label::new("zed")) ListEntry::new(Label::new("zed"))
.left_icon(Icon::Hash.into()) .left_icon(Icon::Hash.into())