Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Get app menus basically working

Browse source 
- Everything is still disabled when there is no active window.

Co-Authored-By: Marshall <marshall@zed.dev>
This commit is contained in:
Nathan Sobo 2023-12-05 16:37:01 -07:00
parent 79567d1c87
commit 82534b6612
13 changed files with 437 additions and 229 deletions
Download patch file Download diff file Expand all files Collapse all files

8
crates/editor2/src/display_map/block_map.rs
View file

@ -993,7 +993,7 @@ mod tests {
use super::*; use super::*;
use crate::display_map::inlay_map::InlayMap; use crate::display_map::inlay_map::InlayMap;
use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap}; use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap};
use gpui::{div, font, px, Element, Platform as _}; use gpui::{div, font, px, Element};
use multi_buffer::MultiBuffer; use multi_buffer::MultiBuffer;
use rand::prelude::*; use rand::prelude::*;
use settings::SettingsStore; use settings::SettingsStore;
@ -1185,11 +1185,7 @@ mod tests {
fn test_blocks_on_wrapped_lines(cx: &mut gpui::TestAppContext) { fn test_blocks_on_wrapped_lines(cx: &mut gpui::TestAppContext) {
cx.update(|cx| init_test(cx)); cx.update(|cx| init_test(cx));
let font_id = cx let font_id = cx.text_system().font_id(&font("Helvetica")).unwrap();
.test_platform
.text_system()
.font_id(&font("Helvetica"))
.unwrap();
let text = "one two three\nfour five six\nseven eight"; let text = "one two three\nfour five six\nseven eight";

2
crates/editor2/src/display_map/wrap_map.rs
View file

@ -1032,7 +1032,7 @@ mod tests {
display_map::{fold_map::FoldMap, inlay_map::InlayMap, tab_map::TabMap}, display_map::{fold_map::FoldMap, inlay_map::InlayMap, tab_map::TabMap},
MultiBuffer, MultiBuffer,
}; };
use gpui::{font, px, test::observe, Platform}; use gpui::{font, px, test::observe};
use rand::prelude::*; use rand::prelude::*;
use settings::SettingsStore; use settings::SettingsStore;
use smol::stream::StreamExt; use smol::stream::StreamExt;

6
crates/editor2/src/editor_tests.rs
View file

@ -12,7 +12,7 @@ use futures::StreamExt;
use gpui::{ use gpui::{
div, div,
serde_json::{self, json}, serde_json::{self, json},
Div, Flatten, Platform, TestAppContext, VisualTestContext, WindowBounds, WindowOptions, Div, Flatten, TestAppContext, VisualTestContext, WindowBounds, WindowOptions,
}; };
use indoc::indoc; use indoc::indoc;
use language::{ use language::{
@ -3238,9 +3238,7 @@ async fn test_clipboard(cx: &mut gpui::TestAppContext) {
the lazy dog"}); the lazy dog"});
cx.update_editor(|e, cx| e.copy(&Copy, cx)); cx.update_editor(|e, cx| e.copy(&Copy, cx));
assert_eq!( assert_eq!(
cx.test_platform cx.read_from_clipboard().map(|item| item.text().to_owned()),
.read_from_clipboard()
.map(|item| item.text().to_owned()),
Some("fox jumps over\n".to_owned()) Some("fox jumps over\n".to_owned())
); );

21
crates/gpui2/src/app.rs
View file

@ -15,10 +15,10 @@ use smol::future::FutureExt;
pub use test_context::*; pub use test_context::*;
use crate::{ use crate::{
current_platform, image_cache::ImageCache, Action, ActionRegistry, Any, AnyView, current_platform, image_cache::ImageCache, init_app_menus, Action, ActionRegistry, Any,
AnyWindowHandle, AppMetadata, AssetSource, BackgroundExecutor, ClipboardItem, Context, AnyView, AnyWindowHandle, AppMetadata, AssetSource, BackgroundExecutor, ClipboardItem, Context,
DispatchPhase, DisplayId, Entity, EventEmitter, FocusEvent, FocusHandle, FocusId, DispatchPhase, DisplayId, Entity, EventEmitter, FocusEvent, FocusHandle, FocusId,
ForegroundExecutor, KeyBinding, Keymap, LayoutId, PathPromptOptions, Pixels, Platform, ForegroundExecutor, KeyBinding, Keymap, LayoutId, Menu, PathPromptOptions, Pixels, Platform,
PlatformDisplay, Point, Render, SharedString, SubscriberSet, Subscription, SvgRenderer, Task, PlatformDisplay, Point, Render, SharedString, SubscriberSet, Subscription, SvgRenderer, Task,
TextStyle, TextStyleRefinement, TextSystem, View, ViewContext, Window, WindowContext, TextStyle, TextStyleRefinement, TextSystem, View, ViewContext, Window, WindowContext,
WindowHandle, WindowId, WindowHandle, WindowId,
@ -278,6 +278,8 @@ impl AppContext {
}), }),
}); });
init_app_menus(platform.as_ref(), &mut *app.borrow_mut());
platform.on_quit(Box::new({ platform.on_quit(Box::new({
let cx = app.clone(); let cx = app.clone();
move || { move || {
@ -1059,6 +1061,19 @@ impl AppContext {
.contains_key(&action.as_any().type_id()) .contains_key(&action.as_any().type_id())
} }
pub fn set_menus(&mut self, menus: Vec<Menu>) {
if let Some(active_window) = self.active_window() {
active_window
.update(self, |_, cx| {
cx.platform
.set_menus(menus, Some(&cx.window.current_frame.dispatch_tree));
})
.ok();
} else {
self.platform.set_menus(menus, None);
}
}
pub fn dispatch_action(&mut self, action: &dyn Action) { pub fn dispatch_action(&mut self, action: &dyn Action) {
self.propagate_event = true; self.propagate_event = true;

24
crates/gpui2/src/app/test_context.rs
View file

@ -1,9 +1,10 @@
use crate::{ use crate::{
div, Action, AnyView, AnyWindowHandle, AppCell, AppContext, AsyncAppContext, div, Action, AnyView, AnyWindowHandle, AppCell, AppContext, AsyncAppContext,
BackgroundExecutor, Bounds, Context, Div, Entity, EventEmitter, ForegroundExecutor, InputEvent, BackgroundExecutor, Bounds, ClipboardItem, Context, Div, Entity, EventEmitter,
KeyDownEvent, Keystroke, Model, ModelContext, Pixels, PlatformWindow, Point, Render, Result, ForegroundExecutor, InputEvent, KeyDownEvent, Keystroke, Model, ModelContext, Pixels, Platform,
Size, Task, TestDispatcher, TestPlatform, TestWindow, TestWindowHandlers, View, ViewContext, PlatformWindow, Point, Render, Result, Size, Task, TestDispatcher, TestPlatform, TestWindow,
VisualContext, WindowBounds, WindowContext, WindowHandle, WindowOptions, TestWindowHandlers, TextSystem, View, ViewContext, VisualContext, WindowBounds, WindowContext,
WindowHandle, WindowOptions,
}; };
use anyhow::{anyhow, bail}; use anyhow::{anyhow, bail};
use futures::{Stream, StreamExt}; use futures::{Stream, StreamExt};
@ -16,6 +17,7 @@ pub struct TestAppContext {
pub foreground_executor: ForegroundExecutor, pub foreground_executor: ForegroundExecutor,
pub dispatcher: TestDispatcher, pub dispatcher: TestDispatcher,
pub test_platform: Rc<TestPlatform>, pub test_platform: Rc<TestPlatform>,
text_system: Arc<TextSystem>,
} }
impl Context for TestAppContext { impl Context for TestAppContext {
@ -82,6 +84,7 @@ impl TestAppContext {
let platform = TestPlatform::new(background_executor.clone(), foreground_executor.clone()); let platform = TestPlatform::new(background_executor.clone(), foreground_executor.clone());
let asset_source = Arc::new(()); let asset_source = Arc::new(());
let http_client = util::http::FakeHttpClient::with_404_response(); let http_client = util::http::FakeHttpClient::with_404_response();
let text_system = Arc::new(TextSystem::new(platform.text_system()));
Self { Self {
app: AppContext::new(platform.clone(), asset_source, http_client), app: AppContext::new(platform.clone(), asset_source, http_client),
@ -89,6 +92,7 @@ impl TestAppContext {
foreground_executor, foreground_executor,
dispatcher: dispatcher.clone(), dispatcher: dispatcher.clone(),
test_platform: platform, test_platform: platform,
text_system,
} }
} }
@ -155,6 +159,18 @@ impl TestAppContext {
(view, Box::leak(cx)) (view, Box::leak(cx))
} }
pub fn text_system(&self) -> &Arc<TextSystem> {
&self.text_system
}
pub fn write_to_clipboard(&self, item: ClipboardItem) {
self.test_platform.write_to_clipboard(item)
}
pub fn read_from_clipboard(&self) -> Option<ClipboardItem> {
self.test_platform.read_from_clipboard()
}
pub fn simulate_new_path_selection( pub fn simulate_new_path_selection(
&self, &self,
select_path: impl FnOnce(&std::path::Path) -> Option<std::path::PathBuf>, select_path: impl FnOnce(&std::path::Path) -> Option<std::path::PathBuf>,

11
crates/gpui2/src/platform.rs
View file

@ -6,10 +6,10 @@ mod mac;
mod test; mod test;
use crate::{ use crate::{
point, size, Action, AnyWindowHandle, BackgroundExecutor, Bounds, DevicePixels, Font, FontId, point, size, Action, AnyWindowHandle, BackgroundExecutor, Bounds, DevicePixels, DispatchTree,
FontMetrics, FontRun, ForegroundExecutor, GlobalPixels, GlyphId, InputEvent, LineLayout, Font, FontId, FontMetrics, FontRun, ForegroundExecutor, GlobalPixels, GlyphId, InputEvent,
Pixels, Point, RenderGlyphParams, RenderImageParams, RenderSvgParams, Result, Scene, LineLayout, Pixels, Point, RenderGlyphParams, RenderImageParams, RenderSvgParams, Result,
SharedString, Size, TaskLabel, Scene, SharedString, Size, TaskLabel,
}; };
use anyhow::{anyhow, bail}; use anyhow::{anyhow, bail};
use async_task::Runnable; use async_task::Runnable;
@ -46,7 +46,7 @@ pub(crate) fn current_platform() -> Rc<dyn Platform> {
Rc::new(MacPlatform::new()) Rc::new(MacPlatform::new())
} }
pub trait Platform: 'static { pub(crate) trait Platform: 'static {
fn background_executor(&self) -> BackgroundExecutor; fn background_executor(&self) -> BackgroundExecutor;
fn foreground_executor(&self) -> ForegroundExecutor; fn foreground_executor(&self) -> ForegroundExecutor;
fn text_system(&self) -> Arc<dyn PlatformTextSystem>; fn text_system(&self) -> Arc<dyn PlatformTextSystem>;
@ -92,6 +92,7 @@ pub trait Platform: 'static {
fn on_reopen(&self, callback: Box<dyn FnMut()>); fn on_reopen(&self, callback: Box<dyn FnMut()>);
fn on_event(&self, callback: Box<dyn FnMut(InputEvent) -> bool>); fn on_event(&self, callback: Box<dyn FnMut(InputEvent) -> bool>);
fn set_menus(&self, menus: Vec<Menu>, dispatch_tree: Option<&DispatchTree>);
fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>); fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>);
fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>); fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>);
fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>); fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>);

2
crates/gpui2/src/platform/app_menu.rs
View file

@ -52,7 +52,7 @@ pub enum OsAction {
Redo, Redo,
} }
pub(crate) fn init(platform: &dyn Platform, cx: &mut AppContext) { pub(crate) fn init_app_menus(platform: &dyn Platform, cx: &mut AppContext) {
platform.on_will_open_app_menu(Box::new({ platform.on_will_open_app_menu(Box::new({
let cx = cx.to_async(); let cx = cx.to_async();
move || { move || {

321
crates/gpui2/src/platform/mac/platform.rs
View file

@ -1,8 +1,8 @@
use super::BoolExt; use super::{events::key_to_native, BoolExt};
use crate::{ use crate::{
Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId, Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DispatchTree,
ForegroundExecutor, InputEvent, KeystrokeMatcher, MacDispatcher, MacDisplay, MacDisplayLinker, DisplayId, ForegroundExecutor, InputEvent, MacDispatcher, MacDisplay, MacDisplayLinker,
MacTextSystem, MacWindow, MenuItem, PathPromptOptions, Platform, PlatformDisplay, MacTextSystem, MacWindow, Menu, MenuItem, PathPromptOptions, Platform, PlatformDisplay,
PlatformTextSystem, PlatformWindow, Result, SemanticVersion, VideoTimestamp, WindowOptions, PlatformTextSystem, PlatformWindow, Result, SemanticVersion, VideoTimestamp, WindowOptions,
}; };
use anyhow::anyhow; use anyhow::anyhow;
@ -10,10 +10,10 @@ use block::ConcreteBlock;
use cocoa::{ use cocoa::{
appkit::{ appkit::{
NSApplication, NSApplicationActivationPolicy::NSApplicationActivationPolicyRegular, NSApplication, NSApplicationActivationPolicy::NSApplicationActivationPolicyRegular,
NSMenuItem, NSModalResponse, NSOpenPanel, NSPasteboard, NSPasteboardTypeString, NSEventModifierFlags, NSMenu, NSMenuItem, NSModalResponse, NSOpenPanel, NSPasteboard,
NSSavePanel, NSWindow, NSPasteboardTypeString, NSSavePanel, NSWindow,
}, },
base::{id, nil, BOOL, YES}, base::{id, nil, selector, BOOL, YES},
foundation::{ foundation::{
NSArray, NSAutoreleasePool, NSBundle, NSData, NSInteger, NSProcessInfo, NSString, NSArray, NSAutoreleasePool, NSBundle, NSData, NSInteger, NSProcessInfo, NSString,
NSUInteger, NSURL, NSUInteger, NSURL,
@ -201,151 +201,155 @@ impl MacPlatform {
} }
} }
// unsafe fn create_menu_bar( unsafe fn create_menu_bar(
// &self, &self,
// menus: Vec<Menu>, menus: Vec<Menu>,
// delegate: id, delegate: id,
// actions: &mut Vec<Box<dyn Action>>, actions: &mut Vec<Box<dyn Action>>,
// keystroke_matcher: &KeymapMatcher, dispatch_tree: Option<&DispatchTree>,
// ) -> id { ) -> id {
// let application_menu = NSMenu::new(nil).autorelease(); let application_menu = NSMenu::new(nil).autorelease();
// application_menu.setDelegate_(delegate); application_menu.setDelegate_(delegate);
// for menu_config in menus { for menu_config in menus {
// let menu = NSMenu::new(nil).autorelease(); let menu = NSMenu::new(nil).autorelease();
// menu.setTitle_(ns_string(menu_config.name)); menu.setTitle_(ns_string(menu_config.name));
// menu.setDelegate_(delegate); menu.setDelegate_(delegate);
// for item_config in menu_config.items { for item_config in menu_config.items {
// menu.addItem_(self.create_menu_item( menu.addItem_(self.create_menu_item(item_config, delegate, actions, dispatch_tree));
// item_config, }
// delegate,
// actions,
// keystroke_matcher,
// ));
// }
// let menu_item = NSMenuItem::new(nil).autorelease(); let menu_item = NSMenuItem::new(nil).autorelease();
// menu_item.setSubmenu_(menu); menu_item.setSubmenu_(menu);
// application_menu.addItem_(menu_item); application_menu.addItem_(menu_item);
// if menu_config.name == "Window" { if menu_config.name == "Window" {
// let app: id = msg_send![APP_CLASS, sharedApplication]; let app: id = msg_send![APP_CLASS, sharedApplication];
// app.setWindowsMenu_(menu); app.setWindowsMenu_(menu);
// } }
// } }
// application_menu application_menu
// } }
unsafe fn create_menu_item( unsafe fn create_menu_item(
&self, &self,
item: MenuItem, item: MenuItem,
delegate: id, delegate: id,
actions: &mut Vec<Box<dyn Action>>, actions: &mut Vec<Box<dyn Action>>,
keystroke_matcher: &KeystrokeMatcher, dispatch_tree: Option<&DispatchTree>,
) -> id { ) -> id {
todo!() match item {
// match item { MenuItem::Separator => NSMenuItem::separatorItem(nil),
// MenuItem::Separator => NSMenuItem::separatorItem(nil), MenuItem::Action {
// MenuItem::Action { name,
// name, action,
// action, os_action,
// os_action, } => {
// } => { let bindings = dispatch_tree
// // TODO .map(|tree| tree.bindings_for_action(action.as_ref(), &tree.context_stack))
// let keystrokes = keystroke_matcher .unwrap_or_default();
// .bindings_for_action(action.id()) let keystrokes = bindings
// .find(|binding| binding.action().eq(action.as_ref())) .iter()
// .map(|binding| binding.keystrokes()); .find(|binding| binding.action().partial_eq(action.as_ref()))
// let selector = match os_action { .map(|binding| binding.keystrokes());
// Some(crate::OsAction::Cut) => selector("cut:"),
// Some(crate::OsAction::Copy) => selector("copy:"),
// Some(crate::OsAction::Paste) => selector("paste:"),
// Some(crate::OsAction::SelectAll) => selector("selectAll:"),
// Some(crate::OsAction::Undo) => selector("undo:"),
// Some(crate::OsAction::Redo) => selector("redo:"),
// None => selector("handleGPUIMenuItem:"),
// };
// let item; let selector = match os_action {
// if let Some(keystrokes) = keystrokes { Some(crate::OsAction::Cut) => selector("cut:"),
// if keystrokes.len() == 1 { Some(crate::OsAction::Copy) => selector("copy:"),
// let keystroke = &keystrokes[0]; Some(crate::OsAction::Paste) => selector("paste:"),
// let mut mask = NSEventModifierFlags::empty(); Some(crate::OsAction::SelectAll) => selector("selectAll:"),
// for (modifier, flag) in &[ Some(crate::OsAction::Undo) => selector("undo:"),
// (keystroke.cmd, NSEventModifierFlags::NSCommandKeyMask), Some(crate::OsAction::Redo) => selector("redo:"),
// (keystroke.ctrl, NSEventModifierFlags::NSControlKeyMask), None => selector("handleGPUIMenuItem:"),
// (keystroke.alt, NSEventModifierFlags::NSAlternateKeyMask), };
// (keystroke.shift, NSEventModifierFlags::NSShiftKeyMask),
// ] {
// if *modifier {
// mask |= *flag;
// }
// }
// item = NSMenuItem::alloc(nil) let item;
// .initWithTitle_action_keyEquivalent_( if let Some(keystrokes) = keystrokes {
// ns_string(name), if keystrokes.len() == 1 {
// selector, let keystroke = &keystrokes[0];
// ns_string(key_to_native(&keystroke.key).as_ref()), let mut mask = NSEventModifierFlags::empty();
// ) for (modifier, flag) in &[
// .autorelease(); (
// item.setKeyEquivalentModifierMask_(mask); keystroke.modifiers.command,
// } NSEventModifierFlags::NSCommandKeyMask,
// // For multi-keystroke bindings, render the keystroke as part of the title. ),
// else { (
// use std::fmt::Write; keystroke.modifiers.control,
NSEventModifierFlags::NSControlKeyMask,
),
(
keystroke.modifiers.alt,
NSEventModifierFlags::NSAlternateKeyMask,
),
(
keystroke.modifiers.shift,
NSEventModifierFlags::NSShiftKeyMask,
),
] {
if *modifier {
mask |= *flag;
}
}
// let mut name = format!("{name} ["); item = NSMenuItem::alloc(nil)
// for (i, keystroke) in keystrokes.iter().enumerate() { .initWithTitle_action_keyEquivalent_(
// if i > 0 { ns_string(name),
// name.push(' '); selector,
// } ns_string(key_to_native(&keystroke.key).as_ref()),
// write!(&mut name, "{}", keystroke).unwrap(); )
// } .autorelease();
// name.push(']'); item.setKeyEquivalentModifierMask_(mask);
}
// For multi-keystroke bindings, render the keystroke as part of the title.
else {
use std::fmt::Write;
// item = NSMenuItem::alloc(nil) let mut name = format!("{name} [");
// .initWithTitle_action_keyEquivalent_( for (i, keystroke) in keystrokes.iter().enumerate() {
// ns_string(&name), if i > 0 {
// selector, name.push(' ');
// ns_string(""), }
// ) write!(&mut name, "{}", keystroke).unwrap();
// .autorelease(); }
// } name.push(']');
// } else {
// item = NSMenuItem::alloc(nil)
// .initWithTitle_action_keyEquivalent_(
// ns_string(name),
// selector,
// ns_string(""),
// )
// .autorelease();
// }
// let tag = actions.len() as NSInteger; item = NSMenuItem::alloc(nil)
// let _: () = msg_send![item, setTag: tag]; .initWithTitle_action_keyEquivalent_(
// actions.push(action); ns_string(&name),
// item selector,
// } ns_string(""),
// MenuItem::Submenu(Menu { name, items }) => { )
// let item = NSMenuItem::new(nil).autorelease(); .autorelease();
// let submenu = NSMenu::new(nil).autorelease(); }
// submenu.setDelegate_(delegate); } else {
// for item in items { item = NSMenuItem::alloc(nil)
// submenu.addItem_(self.create_menu_item( .initWithTitle_action_keyEquivalent_(
// item, ns_string(name),
// delegate, selector,
// actions, ns_string(""),
// keystroke_matcher, )
// )); .autorelease();
// } }
// item.setSubmenu_(submenu);
// item.setTitle_(ns_string(name)); let tag = actions.len() as NSInteger;
// item let _: () = msg_send![item, setTag: tag];
// } actions.push(action);
// } item
}
MenuItem::Submenu(Menu { name, items }) => {
let item = NSMenuItem::new(nil).autorelease();
let submenu = NSMenu::new(nil).autorelease();
submenu.setDelegate_(delegate);
for item in items {
submenu.addItem_(self.create_menu_item(item, delegate, actions, dispatch_tree));
}
item.setSubmenu_(submenu);
item.setTitle_(ns_string(name));
item
}
}
} }
} }
@ -633,6 +637,18 @@ impl Platform for MacPlatform {
self.0.lock().event = Some(callback); self.0.lock().event = Some(callback);
} }
fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>) {
self.0.lock().menu_command = Some(callback);
}
fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>) {
self.0.lock().will_open_menu = Some(callback);
}
fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>) {
self.0.lock().validate_menu_command = Some(callback);
}
fn os_name(&self) -> &'static str { fn os_name(&self) -> &'static str {
"macOS" "macOS"
} }
@ -675,6 +691,15 @@ impl Platform for MacPlatform {
} }
} }
fn set_menus(&self, menus: Vec<Menu>, dispatch_tree: Option<&DispatchTree>) {
unsafe {
let app: id = msg_send![APP_CLASS, sharedApplication];
let mut state = self.0.lock();
let actions = &mut state.menu_actions;
app.setMainMenu_(self.create_menu_bar(menus, app.delegate(), actions, dispatch_tree));
}
}
fn local_timezone(&self) -> UtcOffset { fn local_timezone(&self) -> UtcOffset {
unsafe { unsafe {
let local_timezone: id = msg_send![class!(NSTimeZone), localTimeZone]; let local_timezone: id = msg_send![class!(NSTimeZone), localTimeZone];
@ -683,32 +708,6 @@ impl Platform for MacPlatform {
} }
} }
fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>) {
self.0.lock().menu_command = Some(callback);
}
fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>) {
self.0.lock().will_open_menu = Some(callback);
}
fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>) {
self.0.lock().validate_menu_command = Some(callback);
}
// fn set_menus(&self, menus: Vec<Menu>, keystroke_matcher: &KeymapMatcher) {
// unsafe {
// let app: id = msg_send![APP_CLASS, sharedApplication];
// let mut state = self.0.lock();
// let actions = &mut state.menu_actions;
// app.setMainMenu_(self.create_menu_bar(
// menus,
// app.delegate(),
// actions,
// keystroke_matcher,
// ));
// }
// }
fn path_for_auxiliary_executable(&self, name: &str) -> Result<PathBuf> { fn path_for_auxiliary_executable(&self, name: &str) -> Result<PathBuf> {
unsafe { unsafe {
let bundle: id = NSBundle::mainBundle(); let bundle: id = NSBundle::mainBundle();

9
crates/gpui2/src/platform/test/platform.rs
View file

@ -1,6 +1,7 @@
use crate::{ use crate::{
AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId, ForegroundExecutor, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DispatchTree, DisplayId,
Platform, PlatformDisplay, PlatformTextSystem, TestDisplay, TestWindow, WindowOptions, ForegroundExecutor, Platform, PlatformDisplay, PlatformTextSystem, TestDisplay, TestWindow,
WindowOptions,
}; };
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Result};
use collections::VecDeque; use collections::VecDeque;
@ -205,6 +206,10 @@ impl Platform for TestPlatform {
unimplemented!() unimplemented!()
} }
fn set_menus(&self, _menus: Vec<crate::Menu>, _dispatch_tree: Option<&DispatchTree>) {
unimplemented!()
}
fn on_app_menu_action(&self, _callback: Box<dyn FnMut(&dyn crate::Action)>) { fn on_app_menu_action(&self, _callback: Box<dyn FnMut(&dyn crate::Action)>) {
unimplemented!() unimplemented!()
} }

36
crates/settings2/src/settings_file.rs
View file

@ -132,39 +132,3 @@ pub fn load_default_keymap(cx: &mut AppContext) {
// KeymapFile::load_asset(asset_path, cx).unwrap(); // KeymapFile::load_asset(asset_path, cx).unwrap();
// } // }
} }
pub fn handle_keymap_file_changes(
mut user_keymap_file_rx: mpsc::UnboundedReceiver<String>,
cx: &mut AppContext,
) {
cx.spawn(move |cx| async move {
// let mut settings_subscription = None;
while let Some(user_keymap_content) = user_keymap_file_rx.next().await {
if let Some(keymap_content) = KeymapFile::parse(&user_keymap_content).log_err() {
cx.update(|cx| reload_keymaps(cx, &keymap_content)).ok();
// todo!()
// let mut old_base_keymap = cx.read(|cx| *settings::get::<BaseKeymap>(cx));
// drop(settings_subscription);
// settings_subscription = Some(cx.update(|cx| {
// cx.observe_global::<SettingsStore, _>(move |cx| {
// let new_base_keymap = *settings::get::<BaseKeymap>(cx);
// if new_base_keymap != old_base_keymap {
// old_base_keymap = new_base_keymap.clone();
// reload_keymaps(cx, &keymap_content);
// }
// })
// }));
}
}
})
.detach();
}
fn reload_keymaps(cx: &mut AppContext, keymap_content: &KeymapFile) {
// todo!()
// cx.clear_bindings();
load_default_keymap(cx);
keymap_content.clone().add_to_cx(cx).log_err();
// cx.set_menus(menus::menus());
}

175
crates/zed2/src/app_menus.rs Normal file
View file

@ -0,0 +1,175 @@
use gpui::{Menu, MenuItem, OsAction};
#[cfg(target_os = "macos")]
pub fn app_menus() -> Vec<Menu<'static>> {
vec![
Menu {
name: "Zed",
items: vec![
MenuItem::action("About Zed…", super::About),
MenuItem::action("Check for Updates", auto_update::Check),
MenuItem::separator(),
MenuItem::submenu(Menu {
name: "Preferences",
items: vec![
MenuItem::action("Open Settings", super::OpenSettings),
MenuItem::action("Open Key Bindings", super::OpenKeymap),
MenuItem::action("Open Default Settings", super::OpenDefaultSettings),
MenuItem::action("Open Default Key Bindings", super::OpenDefaultKeymap),
MenuItem::action("Open Local Settings", super::OpenLocalSettings),
MenuItem::action("Select Theme", theme_selector::Toggle),
],
}),
MenuItem::action("Install CLI", install_cli::Install),
MenuItem::separator(),
MenuItem::action("Hide Zed", super::Hide),
MenuItem::action("Hide Others", super::HideOthers),
MenuItem::action("Show All", super::ShowAll),
MenuItem::action("Quit", super::Quit),
],
},
Menu {
name: "File",
items: vec![
MenuItem::action("New", workspace::NewFile),
MenuItem::action("New Window", workspace::NewWindow),
MenuItem::separator(),
MenuItem::action("Open…", workspace::Open),
// MenuItem::action("Open Recent...", recent_projects::OpenRecent),
MenuItem::separator(),
MenuItem::action("Add Folder to Project…", workspace::AddFolderToProject),
MenuItem::action("Save", workspace::Save { save_intent: None }),
MenuItem::action("Save As…", workspace::SaveAs),
MenuItem::action("Save All", workspace::SaveAll { save_intent: None }),
MenuItem::action(
"Close Editor",
workspace::CloseActiveItem { save_intent: None },
),
MenuItem::action("Close Window", workspace::CloseWindow),
],
},
Menu {
name: "Edit",
items: vec![
MenuItem::os_action("Undo", editor::Undo, OsAction::Undo),
MenuItem::os_action("Redo", editor::Redo, OsAction::Redo),
MenuItem::separator(),
MenuItem::os_action("Cut", editor::Cut, OsAction::Cut),
MenuItem::os_action("Copy", editor::Copy, OsAction::Copy),
MenuItem::os_action("Paste", editor::Paste, OsAction::Paste),
MenuItem::separator(),
MenuItem::action("Find", search::buffer_search::Deploy { focus: true }),
MenuItem::action("Find In Project", workspace::NewSearch),
MenuItem::separator(),
MenuItem::action("Toggle Line Comment", editor::ToggleComments::default()),
MenuItem::action("Emoji & Symbols", editor::ShowCharacterPalette),
],
},
Menu {
name: "Selection",
items: vec![
MenuItem::os_action("Select All", editor::SelectAll, OsAction::SelectAll),
MenuItem::action("Expand Selection", editor::SelectLargerSyntaxNode),
MenuItem::action("Shrink Selection", editor::SelectSmallerSyntaxNode),
MenuItem::separator(),
MenuItem::action("Add Cursor Above", editor::AddSelectionAbove),
MenuItem::action("Add Cursor Below", editor::AddSelectionBelow),
MenuItem::action(
"Select Next Occurrence",
editor::SelectNext {
replace_newest: false,
},
),
MenuItem::separator(),
MenuItem::action("Move Line Up", editor::MoveLineUp),
MenuItem::action("Move Line Down", editor::MoveLineDown),
MenuItem::action("Duplicate Selection", editor::DuplicateLine),
],
},
Menu {
name: "View",
items: vec![
MenuItem::action("Zoom In", super::IncreaseBufferFontSize),
MenuItem::action("Zoom Out", super::DecreaseBufferFontSize),
MenuItem::action("Reset Zoom", super::ResetBufferFontSize),
MenuItem::separator(),
MenuItem::action("Toggle Left Dock", workspace::ToggleLeftDock),
MenuItem::action("Toggle Right Dock", workspace::ToggleRightDock),
MenuItem::action("Toggle Bottom Dock", workspace::ToggleBottomDock),
MenuItem::action("Close All Docks", workspace::CloseAllDocks),
MenuItem::submenu(Menu {
name: "Editor Layout",
items: vec![
MenuItem::action("Split Up", workspace::SplitUp),
MenuItem::action("Split Down", workspace::SplitDown),
MenuItem::action("Split Left", workspace::SplitLeft),
MenuItem::action("Split Right", workspace::SplitRight),
],
}),
MenuItem::separator(),
MenuItem::action("Project Panel", project_panel::ToggleFocus),
MenuItem::action("Command Palette", command_palette::Toggle),
MenuItem::action("Diagnostics", diagnostics::Deploy),
MenuItem::separator(),
],
},
Menu {
name: "Go",
items: vec![
MenuItem::action("Back", workspace::GoBack),
MenuItem::action("Forward", workspace::GoForward),
MenuItem::separator(),
MenuItem::action("Go to File", file_finder::Toggle),
// MenuItem::action("Go to Symbol in Project", project_symbols::Toggle),
MenuItem::action("Go to Symbol in Editor", outline::Toggle),
MenuItem::action("Go to Definition", editor::GoToDefinition),
MenuItem::action("Go to Type Definition", editor::GoToTypeDefinition),
MenuItem::action("Find All References", editor::FindAllReferences),
MenuItem::action("Go to Line/Column", go_to_line::Toggle),
MenuItem::separator(),
MenuItem::action("Next Problem", editor::GoToDiagnostic),
MenuItem::action("Previous Problem", editor::GoToPrevDiagnostic),
],
},
Menu {
name: "Window",
items: vec![
MenuItem::action("Minimize", super::Minimize),
MenuItem::action("Zoom", super::Zoom),
MenuItem::separator(),
],
},
Menu {
name: "Help",
items: vec![
MenuItem::action("Command Palette", command_palette::Toggle),
MenuItem::separator(),
MenuItem::action("View Telemetry", crate::OpenTelemetryLog),
MenuItem::action("View Dependency Licenses", crate::OpenLicenses),
MenuItem::action("Show Welcome", workspace::Welcome),
MenuItem::separator(),
// todo!(): Needs `feedback2` crate.
// MenuItem::action("Give us feedback", feedback::feedback_editor::GiveFeedback),
// MenuItem::action(
// "Copy System Specs Into Clipboard",
// feedback::CopySystemSpecsIntoClipboard,
// ),
// MenuItem::action("File Bug Report", feedback::FileBugReport),
// MenuItem::action("Request Feature", feedback::RequestFeature),
MenuItem::separator(),
MenuItem::action(
"Documentation",
crate::OpenBrowser {
url: "https://zed.dev/docs".into(),
},
),
MenuItem::action(
"Zed Twitter",
crate::OpenBrowser {
url: "https://twitter.com/zeddotdev".into(),
},
),
],
},
]
}

10
crates/zed2/src/main.rs
View file

@ -22,8 +22,7 @@ use node_runtime::RealNodeRuntime;
use parking_lot::Mutex; use parking_lot::Mutex;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use settings::{ use settings::{
default_settings, handle_keymap_file_changes, handle_settings_file_changes, watch_config_file, default_settings, handle_settings_file_changes, watch_config_file, Settings, SettingsStore,
Settings, SettingsStore,
}; };
use simplelog::ConfigBuilder; use simplelog::ConfigBuilder;
use smol::process::Command; use smol::process::Command;
@ -51,8 +50,9 @@ use uuid::Uuid;
use welcome::{show_welcome_experience, FIRST_OPEN}; use welcome::{show_welcome_experience, FIRST_OPEN};
use workspace::{AppState, WorkspaceStore}; use workspace::{AppState, WorkspaceStore};
use zed2::{ use zed2::{
build_window_options, ensure_only_instance, handle_cli_connection, initialize_workspace, app_menus, build_window_options, ensure_only_instance, handle_cli_connection,
languages, Assets, IsOnlyInstance, OpenListener, OpenRequest, handle_keymap_file_changes, initialize_workspace, languages, Assets, IsOnlyInstance,
OpenListener, OpenRequest,
}; };
mod open_listener; mod open_listener;
@ -224,7 +224,7 @@ fn main() {
// feedback::init(cx); // feedback::init(cx);
welcome::init(cx); welcome::init(cx);
// cx.set_menus(menus::menus()); cx.set_menus(app_menus());
initialize_workspace(app_state.clone(), cx); initialize_workspace(app_state.clone(), cx);
if stdout_is_a_pty() { if stdout_is_a_pty() {

41
crates/zed2/src/zed2.rs
View file

@ -1,11 +1,13 @@
#![allow(unused_variables, unused_mut)] #![allow(unused_variables, unused_mut)]
//todo!() //todo!()
mod app_menus;
mod assets; mod assets;
pub mod languages; pub mod languages;
mod only_instance; mod only_instance;
mod open_listener; mod open_listener;
pub use app_menus::*;
pub use assets::*; pub use assets::*;
use breadcrumbs::Breadcrumbs; use breadcrumbs::Breadcrumbs;
use collections::VecDeque; use collections::VecDeque;
@ -18,8 +20,9 @@ pub use only_instance::*;
pub use open_listener::*; pub use open_listener::*;
use anyhow::{anyhow, Context as _}; use anyhow::{anyhow, Context as _};
use futures::{channel::mpsc, StreamExt};
use project_panel::ProjectPanel; use project_panel::ProjectPanel;
use settings::{initial_local_settings_content, Settings}; use settings::{initial_local_settings_content, load_default_keymap, KeymapFile, Settings};
use std::{borrow::Cow, ops::Deref, sync::Arc}; use std::{borrow::Cow, ops::Deref, sync::Arc};
use terminal_view::terminal_panel::TerminalPanel; use terminal_view::terminal_panel::TerminalPanel;
use util::{ use util::{
@ -561,6 +564,42 @@ fn open_log_file(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
.detach(); .detach();
} }
pub fn handle_keymap_file_changes(
mut user_keymap_file_rx: mpsc::UnboundedReceiver<String>,
cx: &mut AppContext,
) {
cx.spawn(move |cx| async move {
// let mut settings_subscription = None;
while let Some(user_keymap_content) = user_keymap_file_rx.next().await {
if let Some(keymap_content) = KeymapFile::parse(&user_keymap_content).log_err() {
cx.update(|cx| reload_keymaps(cx, &keymap_content)).ok();
// todo!()
// let mut old_base_keymap = cx.read(|cx| *settings::get::<BaseKeymap>(cx));
// drop(settings_subscription);
// settings_subscription = Some(cx.update(|cx| {
// cx.observe_global::<SettingsStore, _>(move |cx| {
// let new_base_keymap = *settings::get::<BaseKeymap>(cx);
// if new_base_keymap != old_base_keymap {
// old_base_keymap = new_base_keymap.clone();
// reload_keymaps(cx, &keymap_content);
// }
// })
// }));
}
}
})
.detach();
}
fn reload_keymaps(cx: &mut AppContext, keymap_content: &KeymapFile) {
// todo!()
// cx.clear_bindings();
load_default_keymap(cx);
keymap_content.clone().add_to_cx(cx).log_err();
cx.set_menus(app_menus());
}
fn open_local_settings_file( fn open_local_settings_file(
workspace: &mut Workspace, workspace: &mut Workspace,
_: &OpenLocalSettings, _: &OpenLocalSettings,