Detailed changes
@@ -1989,6 +1989,19 @@ dependencies = [
"theme",
]
+[[package]]
+name = "context_menu2"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "gpui2",
+ "menu2",
+ "settings2",
+ "smallvec",
+ "theme2",
+ "workspace2",
+]
+
[[package]]
name = "convert_case"
version = "0.4.0"
@@ -9181,6 +9194,7 @@ version = "0.1.0"
dependencies = [
"anyhow",
"client2",
+ "context_menu2",
"db2",
"dirs 4.0.0",
"editor2",
@@ -11518,6 +11532,7 @@ dependencies = [
"collab_ui2",
"collections",
"command_palette2",
+ "context_menu2",
"copilot2",
"ctor",
"db2",
@@ -24,6 +24,7 @@ members = [
"crates/command_palette2",
"crates/component_test",
"crates/context_menu",
+ "crates/context_menu2",
"crates/copilot",
"crates/copilot2",
"crates/copilot_button",
@@ -0,0 +1,19 @@
+[package]
+name = "context_menu2"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+path = "src/context_menu.rs"
+doctest = false
+
+[dependencies]
+gpui = { package = "gpui2", path = "../gpui2" }
+menu = { package = "menu2", path = "../menu2" }
+settings = { package = "settings2", path = "../settings2" }
+theme = { package = "theme2", path = "../theme2" }
+workspace = { package = "workspace2", path = "../workspace2" }
+
+anyhow.workspace = true
+smallvec.workspace = true
@@ -0,0 +1,557 @@
+#![allow(unused_variables, unused)]
+//todo!(remove)
+
+use gpui::{
+ div, Action, AnchorCorner, AnyElement, AppContext, BorrowWindow, Div, EntityId, FocusHandle,
+ FocusableView, Pixels, Point, Render, ViewContext,
+};
+use menu::*;
+
+use std::{any::TypeId, borrow::Cow, sync::Arc, time::Duration};
+
+pub fn init(cx: &mut AppContext) {
+ // todo!()
+ // cx.observe_new_views(
+ // |workspace: &mut Workspace, _: &mut ViewContext<Workspace>| {
+ // workspace.register_action(ContextMenu::select_first);
+ // workspace.register_action(ContextMenu::select_last);
+ // workspace.register_action(ContextMenu::select_next);
+ // workspace.register_action(ContextMenu::select_prev);
+ // workspace.register_action(ContextMenu::confirm);
+ // workspace.register_action(ContextMenu::cancel);
+ // },
+ // )
+ // .detach();
+}
+
+pub type StaticItem = Box<dyn Fn(&mut AppContext) -> AnyElement<ContextMenu>>;
+
+type ContextMenuItemBuilder = ();
+// todo!()
+// Box<dyn Fn(&mut MouseState, &theme::ContextMenuItem) -> AnyElement<ContextMenu>>;
+
+pub enum ContextMenuItemLabel {
+ String(Cow<'static, str>),
+ Element(ContextMenuItemBuilder),
+}
+
+impl From<Cow<'static, str>> for ContextMenuItemLabel {
+ fn from(s: Cow<'static, str>) -> Self {
+ Self::String(s)
+ }
+}
+
+impl From<&'static str> for ContextMenuItemLabel {
+ fn from(s: &'static str) -> Self {
+ Self::String(s.into())
+ }
+}
+
+impl From<String> for ContextMenuItemLabel {
+ fn from(s: String) -> Self {
+ Self::String(s.into())
+ }
+}
+
+// todo!()
+// impl<T> From<T> for ContextMenuItemLabel
+// where
+// T: 'static + Fn(&mut MouseState, &theme::ContextMenuItem) -> AnyElement<ContextMenu>,
+// {
+// fn from(f: T) -> Self {
+// Self::Element(Box::new(f))
+// }
+// }
+
+pub enum ContextMenuItemAction {
+ Action(Box<dyn Action>),
+ Handler(Arc<dyn Fn(&mut ViewContext<ContextMenu>)>),
+}
+
+impl Clone for ContextMenuItemAction {
+ fn clone(&self) -> Self {
+ match self {
+ Self::Action(action) => Self::Action(action.boxed_clone()),
+ Self::Handler(handler) => Self::Handler(handler.clone()),
+ }
+ }
+}
+
+pub enum ContextMenuItem {
+ Item {
+ label: ContextMenuItemLabel,
+ action: ContextMenuItemAction,
+ },
+ Static(StaticItem),
+ Separator,
+}
+
+impl ContextMenuItem {
+ pub fn action(label: impl Into<ContextMenuItemLabel>, action: impl 'static + Action) -> Self {
+ Self::Item {
+ label: label.into(),
+ action: ContextMenuItemAction::Action(Box::new(action)),
+ }
+ }
+
+ pub fn handler(
+ label: impl Into<ContextMenuItemLabel>,
+ handler: impl 'static + Fn(&mut ViewContext<ContextMenu>),
+ ) -> Self {
+ Self::Item {
+ label: label.into(),
+ action: ContextMenuItemAction::Handler(Arc::new(handler)),
+ }
+ }
+
+ pub fn separator() -> Self {
+ Self::Separator
+ }
+
+ fn is_action(&self) -> bool {
+ matches!(self, Self::Item { .. })
+ }
+
+ fn action_id(&self) -> Option<TypeId> {
+ match self {
+ ContextMenuItem::Item { action, .. } => match action {
+ ContextMenuItemAction::Action(action) => Some(action.type_id()),
+ ContextMenuItemAction::Handler(_) => None,
+ },
+ ContextMenuItem::Static(..) | ContextMenuItem::Separator => None,
+ }
+ }
+}
+
+pub struct ContextMenu {
+ show_count: usize,
+ anchor_position: Point<Pixels>,
+ anchor_corner: AnchorCorner,
+ // todo!()
+ // position_mode: OverlayPositionMode,
+ items: Vec<ContextMenuItem>,
+ selected_index: Option<usize>,
+ visible: bool,
+ delay_cancel: bool,
+ previously_focused_view_handle: Option<FocusHandle>,
+ parent_view_id: EntityId,
+ focus_handle: FocusHandle,
+ // todo!()
+ // _actions_observation: Subscription,
+}
+
+impl FocusableView for ContextMenu {
+ fn focus_handle(&self, _: &AppContext) -> FocusHandle {
+ self.focus_handle.clone()
+ }
+}
+
+// todo!()
+// fn ui_name() -> &'static str {
+// "ContextMenu"
+// }
+//
+// fn update_keymap_context(&self, keymap: &mut KeymapContext, _: &AppContext) {
+// Self::reset_to_default_keymap_context(keymap);
+// keymap.add_identifier("menu");
+// }
+//
+// fn focus_out(&mut self, _: AnyView, cx: &mut ViewContext<Self>) {
+// self.reset(cx);
+// }
+
+impl Render for ContextMenu {
+ type Element = Div<Self>;
+
+ fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
+ if !self.visible {
+ return div();
+ }
+
+ // todo!()
+ // // Render the menu once at minimum width.
+ // let mut collapsed_menu = self.render_menu_for_measurement(cx);
+ // let expanded_menu = self
+ // .render_menu(cx)
+ // .dynamically(move |constraint, view, cx| {
+ // SizeConstraint::strict_along(
+ // Axis::Horizontal,
+ // collapsed_menu.layout(constraint, view, cx).0.x(),
+ // )
+ // });
+
+ // Overlay::new(expanded_menu)
+ // .with_hoverable(true)
+ // .with_fit_mode(OverlayFitMode::SnapToWindow)
+ // .with_anchor_position(self.anchor_position)
+ // .with_anchor_corner(self.anchor_corner)
+ // .with_position_mode(self.position_mode)
+ // .into_any()
+ div()
+ }
+}
+
+impl ContextMenu {
+ pub fn new(parent_view_id: EntityId, cx: &mut ViewContext<Self>) -> Self {
+ Self {
+ show_count: 0,
+ delay_cancel: false,
+ anchor_position: Default::default(),
+ anchor_corner: AnchorCorner::TopLeft,
+ // todo!()
+ // position_mode: OverlayPositionMode::Window,
+ items: Default::default(),
+ selected_index: Default::default(),
+ visible: Default::default(),
+ previously_focused_view_handle: None,
+ parent_view_id,
+ // todo!()
+ // _actions_observation: cx.observe_actions(Self::action_dispatched),
+ focus_handle: cx.focus_handle(),
+ }
+ }
+
+ pub fn visible(&self) -> bool {
+ self.visible
+ }
+
+ fn action_dispatched(&mut self, action_id: TypeId, cx: &mut ViewContext<Self>) {
+ if let Some(ix) = self
+ .items
+ .iter()
+ .position(|item| item.action_id() == Some(action_id))
+ {
+ self.selected_index = Some(ix);
+ cx.notify();
+ cx.spawn(|this, mut cx| async move {
+ cx.background_executor()
+ .timer(Duration::from_millis(50))
+ .await;
+ this.update(&mut cx, |this, cx| this.cancel(&Default::default(), cx))?;
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
+ }
+ }
+
+ fn confirm(&mut self, _: &Confirm, cx: &mut ViewContext<Self>) {
+ if let Some(ix) = self.selected_index {
+ if let Some(ContextMenuItem::Item { action, .. }) = self.items.get(ix) {
+ match action {
+ ContextMenuItemAction::Action(action) => {
+ let window = cx.window();
+ let view_id = self.parent_view_id;
+ let action = action.boxed_clone();
+ // todo!()
+ // cx.app_context()
+ // .spawn(|mut cx| async move {
+ // window
+ // .dispatch_action(view_id, action.as_ref(), &mut cx)
+ // .ok_or_else(|| anyhow!("window was closed"))
+ // })
+ // .detach_and_log_err(cx);
+ }
+ ContextMenuItemAction::Handler(handler) => handler(cx),
+ }
+ self.reset(cx);
+ }
+ }
+ }
+
+ pub fn delay_cancel(&mut self) {
+ self.delay_cancel = true;
+ }
+
+ fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
+ if !self.delay_cancel {
+ self.reset(cx);
+ let show_count = self.show_count;
+ cx.defer(move |this, cx| {
+ if this.focus_handle.is_focused(cx) && this.show_count == show_count {
+ if let Some(previously_focused_view_handle) =
+ this.previously_focused_view_handle.take()
+ {
+ previously_focused_view_handle.focus(cx);
+ }
+ }
+ });
+ } else {
+ self.delay_cancel = false;
+ }
+ }
+
+ fn reset(&mut self, cx: &mut ViewContext<Self>) {
+ self.items.clear();
+ self.visible = false;
+ self.selected_index.take();
+ cx.notify();
+ }
+
+ fn select_first(&mut self, _: &SelectFirst, cx: &mut ViewContext<Self>) {
+ self.selected_index = self.items.iter().position(|item| item.is_action());
+ cx.notify();
+ }
+
+ fn select_last(&mut self, _: &SelectLast, cx: &mut ViewContext<Self>) {
+ for (ix, item) in self.items.iter().enumerate().rev() {
+ if item.is_action() {
+ self.selected_index = Some(ix);
+ cx.notify();
+ break;
+ }
+ }
+ }
+
+ fn select_next(&mut self, _: &SelectNext, cx: &mut ViewContext<Self>) {
+ if let Some(ix) = self.selected_index {
+ for (ix, item) in self.items.iter().enumerate().skip(ix + 1) {
+ if item.is_action() {
+ self.selected_index = Some(ix);
+ cx.notify();
+ break;
+ }
+ }
+ } else {
+ self.select_first(&Default::default(), cx);
+ }
+ }
+
+ fn select_prev(&mut self, _: &SelectPrev, cx: &mut ViewContext<Self>) {
+ if let Some(ix) = self.selected_index {
+ for (ix, item) in self.items.iter().enumerate().take(ix).rev() {
+ if item.is_action() {
+ self.selected_index = Some(ix);
+ cx.notify();
+ break;
+ }
+ }
+ } else {
+ self.select_last(&Default::default(), cx);
+ }
+ }
+
+ pub fn toggle(
+ &mut self,
+ anchor_position: Point<Pixels>,
+ anchor_corner: AnchorCorner,
+ items: Vec<ContextMenuItem>,
+ cx: &mut ViewContext<Self>,
+ ) {
+ if self.visible() {
+ self.cancel(&Cancel, cx);
+ } else {
+ let mut items = items.into_iter().peekable();
+ if items.peek().is_some() {
+ self.items = items.collect();
+ self.anchor_position = anchor_position;
+ self.anchor_corner = anchor_corner;
+ self.visible = true;
+ self.show_count += 1;
+ if !self.focus_handle.is_focused(cx) {
+ self.previously_focused_view_handle = cx.focused();
+ }
+ cx.focus_self();
+ } else {
+ self.visible = false;
+ }
+ }
+ cx.notify();
+ }
+
+ pub fn show(
+ &mut self,
+ anchor_position: Point<Pixels>,
+ anchor_corner: AnchorCorner,
+ items: Vec<ContextMenuItem>,
+ cx: &mut ViewContext<Self>,
+ ) {
+ let mut items = items.into_iter().peekable();
+ if items.peek().is_some() {
+ self.items = items.collect();
+ self.anchor_position = anchor_position;
+ self.anchor_corner = anchor_corner;
+ self.visible = true;
+ self.show_count += 1;
+ if !self.focus_handle.is_focused(cx) {
+ self.previously_focused_view_handle = cx.focused();
+ }
+ cx.focus_self();
+ } else {
+ self.visible = false;
+ }
+ cx.notify();
+ }
+
+ // todo!()
+ // pub fn set_position_mode(&mut self, mode: OverlayPositionMode) {
+ // self.position_mode = mode;
+ // }
+
+ fn render_menu_for_measurement(&self, cx: &mut ViewContext<Self>) -> Div<ContextMenu> {
+ // let style = theme::current(cx).context_menu.clone();
+ // Flex::row()
+ // .with_child(
+ // Flex::column().with_children(self.items.iter().enumerate().map(|(ix, item)| {
+ // match item {
+ // ContextMenuItem::Item { label, .. } => {
+ // let style = style.item.in_state(self.selected_index == Some(ix));
+ // let style = style.style_for(&mut Default::default());
+
+ // match label {
+ // ContextMenuItemLabel::String(label) => {
+ // Label::new(label.to_string(), style.label.clone())
+ // .contained()
+ // .with_style(style.container)
+ // .into_any()
+ // }
+ // ContextMenuItemLabel::Element(element) => {
+ // element(&mut Default::default(), style)
+ // }
+ // }
+ // }
+
+ // ContextMenuItem::Static(f) => f(cx),
+
+ // ContextMenuItem::Separator => Empty::new()
+ // .collapsed()
+ // .contained()
+ // .with_style(style.separator)
+ // .constrained()
+ // .with_height(1.)
+ // .into_any(),
+ // }
+ // })),
+ // )
+ // .with_child(
+ // Flex::column()
+ // .with_children(self.items.iter().enumerate().map(|(ix, item)| {
+ // match item {
+ // ContextMenuItem::Item { action, .. } => {
+ // let style = style.item.in_state(self.selected_index == Some(ix));
+ // let style = style.style_for(&mut Default::default());
+
+ // match action {
+ // ContextMenuItemAction::Action(action) => KeystrokeLabel::new(
+ // self.parent_view_id,
+ // action.boxed_clone(),
+ // style.keystroke.container,
+ // style.keystroke.text.clone(),
+ // )
+ // .into_any(),
+ // ContextMenuItemAction::Handler(_) => Empty::new().into_any(),
+ // }
+ // }
+
+ // ContextMenuItem::Static(_) => Empty::new().into_any(),
+
+ // ContextMenuItem::Separator => Empty::new()
+ // .collapsed()
+ // .constrained()
+ // .with_height(1.)
+ // .contained()
+ // .with_style(style.separator)
+ // .into_any(),
+ // }
+ // }))
+ // .contained()
+ // .with_margin_left(style.keystroke_margin),
+ // )
+ // .contained()
+ // .with_style(style.container)
+ todo!()
+ }
+
+ fn render_menu(&self, cx: &mut ViewContext<Self>) -> Div<ContextMenu> {
+ enum Menu {}
+ enum MenuItem {}
+
+ // let style = theme::current(cx).context_menu.clone();
+
+ // MouseEventHandler::new::<Menu, _>(0, cx, |_, cx| {
+ // Flex::column()
+ // .with_children(self.items.iter().enumerate().map(|(ix, item)| {
+ // match item {
+ // ContextMenuItem::Item { label, action } => {
+ // let action = action.clone();
+ // let view_id = self.parent_view_id;
+ // MouseEventHandler::new::<MenuItem, _>(ix, cx, |state, _| {
+ // let style = style.item.in_state(self.selected_index == Some(ix));
+ // let style = style.style_for(state);
+ // let keystroke = match &action {
+ // ContextMenuItemAction::Action(action) => Some(
+ // KeystrokeLabel::new(
+ // view_id,
+ // action.boxed_clone(),
+ // style.keystroke.container,
+ // style.keystroke.text.clone(),
+ // )
+ // .flex_float(),
+ // ),
+ // ContextMenuItemAction::Handler(_) => None,
+ // };
+
+ // Flex::row()
+ // .with_child(match label {
+ // ContextMenuItemLabel::String(label) => {
+ // Label::new(label.clone(), style.label.clone())
+ // .contained()
+ // .into_any()
+ // }
+ // ContextMenuItemLabel::Element(element) => {
+ // element(state, style)
+ // }
+ // })
+ // .with_children(keystroke)
+ // .contained()
+ // .with_style(style.container)
+ // })
+ // .with_cursor_style(CursorStyle::PointingHand)
+ // .on_up(MouseButton::Left, |_, _, _| {}) // Capture these events
+ // .on_down(MouseButton::Left, |_, _, _| {}) // Capture these events
+ // .on_click(MouseButton::Left, move |_, menu, cx| {
+ // menu.cancel(&Default::default(), cx);
+ // let window = cx.window();
+ // match &action {
+ // ContextMenuItemAction::Action(action) => {
+ // let action = action.boxed_clone();
+ // cx.app_context()
+ // .spawn(|mut cx| async move {
+ // window
+ // .dispatch_action(
+ // view_id,
+ // action.as_ref(),
+ // &mut cx,
+ // )
+ // .ok_or_else(|| anyhow!("window was closed"))
+ // })
+ // .detach_and_log_err(cx);
+ // }
+ // ContextMenuItemAction::Handler(handler) => handler(cx),
+ // }
+ // })
+ // .on_drag(MouseButton::Left, |_, _, _| {})
+ // .into_any()
+ // }
+
+ // ContextMenuItem::Static(f) => f(cx),
+
+ // ContextMenuItem::Separator => Empty::new()
+ // .constrained()
+ // .with_height(1.)
+ // .contained()
+ // .with_style(style.separator)
+ // .into_any(),
+ // }
+ // }))
+ // .contained()
+ // .with_style(style.container)
+ // })
+ // .on_down_out(MouseButton::Left, |_, this, cx| {
+ // this.cancel(&Default::default(), cx);
+ // })
+ // .on_down_out(MouseButton::Right, |_, this, cx| {
+ // this.cancel(&Default::default(), cx);
+ // })
+ todo!()
+ }
+}
@@ -9,7 +9,7 @@ path = "src/terminal_view.rs"
doctest = false
[dependencies]
-# context_menu = { package = "context_menu2", path = "../context_menu2" }
+context_menu = { package = "context_menu2", path = "../context_menu2" }
editor = { package = "editor2", path = "../editor2" }
language = { package = "language2", path = "../language2" }
gpui = { package = "gpui2", path = "../gpui2" }
@@ -23,6 +23,7 @@
// TerminalSize,
// };
// use theme::ThemeSettings;
+// use workspace::ElementId;
// use std::mem;
// use std::{fmt::Debug, ops::RangeInclusive};
@@ -809,7 +810,7 @@
// });
// }
-// fn element_id(&self) -> Option<workspace::ui::prelude::ElementId> {
+// fn element_id(&self) -> Option<ElementId> {
// todo!()
// }
@@ -7,27 +7,18 @@ pub mod terminal_panel;
// todo!()
// use crate::terminal_element::TerminalElement;
-use anyhow::Context;
-use dirs::home_dir;
+use context_menu::{ContextMenu, ContextMenuItem};
use editor::{scroll::autoscroll::Autoscroll, Editor};
use gpui::{
- actions, div, img, red, register_action, AnyElement, AppContext, Component, DispatchPhase, Div,
- EventEmitter, FocusEvent, FocusHandle, Focusable, FocusableComponent, FocusableView,
- InputHandler, InteractiveComponent, KeyDownEvent, Keystroke, Model, ParentComponent, Pixels,
- Render, SharedString, Styled, Task, View, ViewContext, VisualContext, WeakView,
+ actions, div, img, red, register_action, AnchorCorner, AnyElement, AppContext, Component,
+ DispatchPhase, Div, EventEmitter, FocusEvent, FocusHandle, Focusable, FocusableComponent,
+ FocusableView, InputHandler, InteractiveComponent, KeyDownEvent, Keystroke, Model,
+ ParentComponent, Pixels, Render, SharedString, Styled, Task, View, ViewContext, VisualContext,
+ WeakView,
};
use language::Bias;
use persistence::TERMINAL_DB;
use project::{search::SearchQuery, LocalWorktree, Project};
-use serde::Deserialize;
-use settings::Settings;
-use smol::Timer;
-use std::{
- ops::RangeInclusive,
- path::{Path, PathBuf},
- sync::Arc,
- time::Duration,
-};
use terminal::{
alacritty_terminal::{
index::Point,
@@ -42,7 +33,20 @@ use workspace::{
notifications::NotifyResultExt,
register_deserializable_item,
searchable::{SearchEvent, SearchOptions, SearchableItem},
- NewCenterTerminal, Pane, ToolbarItemLocation, Workspace, WorkspaceId,
+ CloseActiveItem, NewCenterTerminal, Pane, ToolbarItemLocation, Workspace, WorkspaceId,
+};
+
+use anyhow::Context;
+use dirs::home_dir;
+use serde::Deserialize;
+use settings::Settings;
+use smol::Timer;
+
+use std::{
+ ops::RangeInclusive,
+ path::{Path, PathBuf},
+ sync::Arc,
+ time::Duration,
};
const CURSOR_BLINK_INTERVAL: Duration = Duration::from_millis(500);
@@ -82,7 +86,7 @@ pub struct TerminalView {
has_new_content: bool,
//Currently using iTerm bell, show bell emoji in tab until input is received
has_bell: bool,
- // context_menu: View<ContextMenu>,
+ context_menu: View<ContextMenu>,
blink_state: bool,
blinking_on: bool,
blinking_paused: bool,
@@ -265,8 +269,7 @@ impl TerminalView {
has_new_content: true,
has_bell: false,
focus_handle: cx.focus_handle(),
- // todo!()
- // context_menu: cx.build_view(|cx| ContextMenu::new(view_id, cx)),
+ context_menu: cx.build_view(|cx| ContextMenu::new(view_id, cx)),
blink_state: true,
blinking_on: false,
blinking_paused: false,
@@ -293,18 +296,21 @@ impl TerminalView {
cx.emit(Event::Wakeup);
}
- pub fn deploy_context_menu(&mut self, _position: Point<Pixels>, _cx: &mut ViewContext<Self>) {
- //todo!(context_menu)
- // let menu_entries = vec![
- // ContextMenuItem::action("Clear", Clear),
- // ContextMenuItem::action("Close", pane::CloseActiveItem { save_intent: None }),
- // ];
+ pub fn deploy_context_menu(
+ &mut self,
+ position: gpui::Point<Pixels>,
+ cx: &mut ViewContext<Self>,
+ ) {
+ let menu_entries = vec![
+ ContextMenuItem::action("Clear", Clear),
+ ContextMenuItem::action("Close", CloseActiveItem { save_intent: None }),
+ ];
- // self.context_menu.update(cx, |menu, cx| {
- // menu.show(position, AnchorCorner::TopLeft, menu_entries, cx)
- // });
+ self.context_menu.update(cx, |menu, cx| {
+ menu.show(position, AnchorCorner::TopLeft, menu_entries, cx)
+ });
- // cx.notify();
+ cx.notify();
}
fn show_character_palette(&mut self, _: &ShowCharacterPalette, cx: &mut ViewContext<Self>) {
@@ -561,8 +567,7 @@ impl Render for TerminalView {
// self.can_navigate_to_selected_word,
// )
)
- // todo!()
- // .child(ChildView::new(&self.context_menu, cx))
+ .child(self.context_menu.clone())
}
}
@@ -27,7 +27,7 @@ collab_ui = { package = "collab_ui2", path = "../collab_ui2" }
collections = { path = "../collections" }
command_palette = { package="command_palette2", path = "../command_palette2" }
# component_test = { path = "../component_test" }
-# context_menu = { path = "../context_menu" }
+context_menu = { package = "context_menu2", path = "../context_menu2" }
client = { package = "client2", path = "../client2" }
# clock = { path = "../clock" }
copilot = { package = "copilot2", path = "../copilot2" }
@@ -141,7 +141,7 @@ fn main() {
cx.set_global(client.clone());
theme::init(cx);
- // context_menu::init(cx);
+ context_menu::init(cx);
project::Project::init(&client, cx);
client::init(&client, cx);
command_palette::init(cx);