Mikayla Maki created
Add back cmd-q, cmd-n, etc.
TODO:
- [x] Fix quit checking workspace windows
- [ ] ~~See if GPUI2 has a DebugElements analog~~
Release Notes:
- N/ACargo.lock | 3
crates/Cargo.toml | 38 -
crates/gpui/src/app.rs | 4
crates/gpui2/src/app.rs | 12
crates/gpui2/src/window.rs | 14
crates/install_cli2/Cargo.toml | 1
crates/install_cli2/src/install_cli2.rs | 5
crates/workspace2/src/workspace2.rs | 101 ++--
crates/zed2/Cargo.toml | 2
crates/zed2/src/main.rs | 15
crates/zed2/src/open_listener.rs | 4
crates/zed2/src/zed2.rs | 534 ++++++++++++++++++++++++++
crates/zed_actions2/src/lib.rs | 34 -
13 files changed, 636 insertions(+), 131 deletions(-)
@@ -4198,6 +4198,7 @@ dependencies = [
"anyhow",
"gpui2",
"log",
+ "serde",
"smol",
"util",
]
@@ -11432,7 +11433,7 @@ dependencies = [
"ignore",
"image",
"indexmap 1.9.3",
- "install_cli",
+ "install_cli2",
"isahc",
"journal2",
"language2",
@@ -1,38 +0,0 @@
-[package]
-name = "ai"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/ai.rs"
-doctest = false
-
-[features]
-test-support = []
-
-[dependencies]
-gpui = { path = "../gpui" }
-util = { path = "../util" }
-language = { path = "../language" }
-async-trait.workspace = true
-anyhow.workspace = true
-futures.workspace = true
-lazy_static.workspace = true
-ordered-float.workspace = true
-parking_lot.workspace = true
-isahc.workspace = true
-regex.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-postage.workspace = true
-rand.workspace = true
-log.workspace = true
-parse_duration = "2.1.1"
-tiktoken-rs.workspace = true
-matrixmultiply = "0.3.7"
-rusqlite = { version = "0.29.0", features = ["blob", "array", "modern_sqlite"] }
-bincode = "1.3.3"
-
-[dev-dependencies]
-gpui = { path = "../gpui", features = ["test-support"] }
@@ -2112,6 +2112,10 @@ impl AppContext {
AsyncAppContext(self.weak_self.as_ref().unwrap().upgrade().unwrap())
}
+ pub fn open_url(&self, url: &str) {
+ self.platform.open_url(url)
+ }
+
pub fn write_to_clipboard(&self, item: ClipboardItem) {
self.platform.write_to_clipboard(item);
}
@@ -431,6 +431,18 @@ impl AppContext {
self.platform.activate(ignoring_other_apps);
}
+ pub fn hide(&self) {
+ self.platform.hide();
+ }
+
+ pub fn hide_other_apps(&self) {
+ self.platform.hide_other_apps();
+ }
+
+ pub fn unhide_other_apps(&self) {
+ self.platform.unhide_other_apps();
+ }
+
/// Returns the list of currently active displays.
pub fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {
self.platform.displays()
@@ -1365,6 +1365,14 @@ impl<'a> WindowContext<'a> {
self.window.platform_window.activate();
}
+ pub fn minimize_window(&self) {
+ self.window.platform_window.minimize();
+ }
+
+ pub fn toggle_full_screen(&self) {
+ self.window.platform_window.toggle_full_screen();
+ }
+
pub fn prompt(
&self,
level: PromptLevel,
@@ -2360,6 +2368,12 @@ impl<V: 'static + Render> WindowHandle<V> {
{
cx.read_window(self, |root_view, _cx| root_view.clone())
}
+
+ pub fn is_active(&self, cx: &WindowContext) -> Option<bool> {
+ cx.windows
+ .get(self.id)
+ .and_then(|window| window.as_ref().map(|window| window.active))
+ }
}
impl<V> Copy for WindowHandle<V> {}
@@ -14,5 +14,6 @@ test-support = []
smol.workspace = true
anyhow.workspace = true
log.workspace = true
+serde.workspace = true
gpui = { package = "gpui2", path = "../gpui2" }
util = { path = "../util" }
@@ -1,10 +1,9 @@
use anyhow::{anyhow, Result};
-use gpui::AsyncAppContext;
+use gpui::{actions, AsyncAppContext};
use std::path::Path;
use util::ResultExt;
-// todo!()
-// actions!(cli, [Install]);
+actions!(Install);
pub async fn install_cli(cx: &AsyncAppContext) -> Result<()> {
let cli_path = cx.update(|cx| cx.path_for_auxiliary_executable("cli"))??;
@@ -45,7 +45,7 @@ use gpui::{
};
use item::{FollowableItem, FollowableItemHandle, Item, ItemHandle, ItemSettings, ProjectItem};
use itertools::Itertools;
-use language2::LanguageRegistry;
+use language2::{LanguageRegistry, Rope};
use lazy_static::lazy_static;
pub use modal_layer::*;
use node_runtime::NodeRuntime;
@@ -72,7 +72,7 @@ pub use toolbar::{ToolbarItemLocation, ToolbarItemView};
use ui::{h_stack, Button, ButtonVariant, Label, LabelColor};
use util::ResultExt;
use uuid::Uuid;
-use workspace_settings::{AutosaveSetting, WorkspaceSettings};
+pub use workspace_settings::{AutosaveSetting, WorkspaceSettings};
lazy_static! {
static ref ZED_WINDOW_SIZE: Option<Size<GlobalPixels>> = env::var("ZED_WINDOW_SIZE")
@@ -1052,29 +1052,29 @@ impl Workspace {
// self.titlebar_item.clone()
// }
- // /// Call the given callback with a workspace whose project is local.
- // ///
- // /// If the given workspace has a local project, then it will be passed
- // /// to the callback. Otherwise, a new empty window will be created.
- // pub fn with_local_workspace<T, F>(
- // &mut self,
- // cx: &mut ViewContext<Self>,
- // callback: F,
- // ) -> Task<Result<T>>
- // where
- // T: 'static,
- // F: 'static + FnOnce(&mut Workspace, &mut ViewContext<Workspace>) -> T,
- // {
- // if self.project.read(cx).is_local() {
- // Task::Ready(Some(Ok(callback(self, cx))))
- // } else {
- // let task = Self::new_local(Vec::new(), self.app_state.clone(), None, cx);
- // cx.spawn(|_vh, mut cx| async move {
- // let (workspace, _) = task.await;
- // workspace.update(&mut cx, callback)
- // })
- // }
- // }
+ /// Call the given callback with a workspace whose project is local.
+ ///
+ /// If the given workspace has a local project, then it will be passed
+ /// to the callback. Otherwise, a new empty window will be created.
+ pub fn with_local_workspace<T, F>(
+ &mut self,
+ cx: &mut ViewContext<Self>,
+ callback: F,
+ ) -> Task<Result<T>>
+ where
+ T: 'static,
+ F: 'static + FnOnce(&mut Workspace, &mut ViewContext<Workspace>) -> T,
+ {
+ if self.project.read(cx).is_local() {
+ Task::Ready(Some(Ok(callback(self, cx))))
+ } else {
+ let task = Self::new_local(Vec::new(), self.app_state.clone(), None, cx);
+ cx.spawn(|_vh, mut cx| async move {
+ let (workspace, _) = task.await?;
+ workspace.update(&mut cx, callback)
+ })
+ }
+ }
pub fn worktrees<'a>(&self, cx: &'a AppContext) -> impl 'a + Iterator<Item = Model<Worktree>> {
self.project.read(cx).worktrees()
@@ -3435,13 +3435,14 @@ impl Workspace {
pub fn register_action<A: Action>(
&mut self,
callback: impl Fn(&mut Self, &A, &mut ViewContext<Self>) + 'static,
- ) {
+ ) -> &mut Self {
let callback = Arc::new(callback);
self.workspace_actions.push(Box::new(move |div| {
let callback = callback.clone();
div.on_action(move |workspace, event, cx| (callback.clone())(workspace, event, cx))
}));
+ self
}
fn add_workspace_actions_listeners(
@@ -4383,32 +4384,32 @@ pub fn open_new(
})
}
-// pub fn create_and_open_local_file(
-// path: &'static Path,
-// cx: &mut ViewContext<Workspace>,
-// default_content: impl 'static + Send + FnOnce() -> Rope,
-// ) -> Task<Result<Box<dyn ItemHandle>>> {
-// cx.spawn(|workspace, mut cx| async move {
-// let fs = workspace.read_with(&cx, |workspace, _| workspace.app_state().fs.clone())?;
-// if !fs.is_file(path).await {
-// fs.create_file(path, Default::default()).await?;
-// fs.save(path, &default_content(), Default::default())
-// .await?;
-// }
+pub fn create_and_open_local_file(
+ path: &'static Path,
+ cx: &mut ViewContext<Workspace>,
+ default_content: impl 'static + Send + FnOnce() -> Rope,
+) -> Task<Result<Box<dyn ItemHandle>>> {
+ cx.spawn(|workspace, mut cx| async move {
+ let fs = workspace.update(&mut cx, |workspace, _| workspace.app_state().fs.clone())?;
+ if !fs.is_file(path).await {
+ fs.create_file(path, Default::default()).await?;
+ fs.save(path, &default_content(), Default::default())
+ .await?;
+ }
-// let mut items = workspace
-// .update(&mut cx, |workspace, cx| {
-// workspace.with_local_workspace(cx, |workspace, cx| {
-// workspace.open_paths(vec![path.to_path_buf()], false, cx)
-// })
-// })?
-// .await?
-// .await;
+ let mut items = workspace
+ .update(&mut cx, |workspace, cx| {
+ workspace.with_local_workspace(cx, |workspace, cx| {
+ workspace.open_paths(vec![path.to_path_buf()], false, cx)
+ })
+ })?
+ .await?
+ .await;
-// let item = items.pop().flatten();
-// item.ok_or_else(|| anyhow!("path {path:?} is not a file"))?
-// })
-// }
+ let item = items.pop().flatten();
+ item.ok_or_else(|| anyhow!("path {path:?} is not a file"))?
+ })
+}
// pub fn join_remote_project(
// project_id: u64,
@@ -43,7 +43,7 @@ fsevent = { path = "../fsevent" }
fuzzy = { path = "../fuzzy" }
go_to_line = { package = "go_to_line2", path = "../go_to_line2" }
gpui = { package = "gpui2", path = "../gpui2" }
-install_cli = { path = "../install_cli" }
+install_cli = { package = "install_cli2", path = "../install_cli2" }
journal = { package = "journal2", path = "../journal2" }
language = { package = "language2", path = "../language2" }
# language_selector = { path = "../language_selector" }
@@ -50,14 +50,16 @@ use util::{
use uuid::Uuid;
use workspace::{AppState, WorkspaceStore};
use zed2::{
- build_window_options, ensure_only_instance, handle_cli_connection, initialize_workspace,
- languages, Assets, IsOnlyInstance, OpenListener, OpenRequest,
+ build_window_options, ensure_only_instance, handle_cli_connection, init_zed_actions,
+ initialize_workspace, languages, Assets, IsOnlyInstance, OpenListener, OpenRequest,
};
mod open_listener;
fn main() {
menu::init();
+ zed_actions::init();
+
let http = http::client();
init_paths();
init_logger();
@@ -96,7 +98,7 @@ fn main() {
let (listener, mut open_rx) = OpenListener::new();
let listener = Arc::new(listener);
let open_listener = listener.clone();
- app.on_open_urls(move |urls, _| open_listener.open_urls(urls));
+ app.on_open_urls(move |urls, _| open_listener.open_urls(&urls));
app.on_reopen(move |_cx| {
// todo!("workspace")
// if cx.has_global::<Weak<AppState>>() {
@@ -111,6 +113,8 @@ fn main() {
app.run(move |cx| {
cx.set_global(*RELEASE_CHANNEL);
+ cx.set_global(listener.clone());
+
load_embedded_fonts(cx);
let mut store = SettingsStore::default();
@@ -209,12 +213,13 @@ fn main() {
// zed::init(&app_state, cx);
// cx.set_menus(menus::menus());
+ init_zed_actions(app_state.clone(), cx);
if stdout_is_a_pty() {
cx.activate(true);
let urls = collect_url_args();
if !urls.is_empty() {
- listener.open_urls(urls)
+ listener.open_urls(&urls)
}
} else {
upload_previous_panics(http.clone(), cx);
@@ -224,7 +229,7 @@ fn main() {
if std::env::var(FORCE_CLI_MODE_ENV_VAR_NAME).ok().is_some()
&& !listener.triggered.load(Ordering::Acquire)
{
- listener.open_urls(collect_url_args())
+ listener.open_urls(&collect_url_args())
}
}
@@ -54,7 +54,7 @@ impl OpenListener {
)
}
- pub fn open_urls(&self, urls: Vec<String>) {
+ pub fn open_urls(&self, urls: &[String]) {
self.triggered.store(true, Ordering::Release);
let request = if let Some(server_name) =
urls.first().and_then(|url| url.strip_prefix("zed-cli://"))
@@ -101,7 +101,7 @@ impl OpenListener {
None
}
- fn handle_file_urls(&self, urls: Vec<String>) -> Option<OpenRequest> {
+ fn handle_file_urls(&self, urls: &[String]) -> Option<OpenRequest> {
let paths: Vec<_> = urls
.iter()
.flat_map(|url| url.strip_prefix("file://"))
@@ -1,5 +1,5 @@
-#![allow(unused_variables, dead_code, unused_mut)]
-// todo!() this is to make transition easier.
+#![allow(unused_variables, unused_mut)]
+//todo!()
mod assets;
pub mod languages;
@@ -7,18 +7,56 @@ mod only_instance;
mod open_listener;
pub use assets::*;
+use collections::VecDeque;
+use editor::{Editor, MultiBuffer};
use gpui::{
- point, px, AppContext, AsyncWindowContext, Task, TitlebarOptions, WeakView, WindowBounds,
- WindowKind, WindowOptions,
+ actions, point, px, AppContext, AsyncWindowContext, Context, PromptLevel, Task,
+ TitlebarOptions, ViewContext, VisualContext, WeakView, WindowBounds, WindowKind, WindowOptions,
};
pub use only_instance::*;
pub use open_listener::*;
-use anyhow::Result;
+use anyhow::{anyhow, Context as _, Result};
use project_panel::ProjectPanel;
-use std::sync::Arc;
+use settings::{initial_local_settings_content, Settings};
+use std::{borrow::Cow, ops::Deref, sync::Arc};
+use util::{
+ asset_str,
+ channel::ReleaseChannel,
+ paths::{self, LOCAL_SETTINGS_RELATIVE_PATH},
+ ResultExt,
+};
use uuid::Uuid;
-use workspace::{dock::PanelHandle as _, AppState, Workspace};
+use workspace::{
+ create_and_open_local_file, dock::PanelHandle,
+ notifications::simple_message_notification::MessageNotification, open_new, AppState, NewFile,
+ NewWindow, Workspace, WorkspaceSettings,
+};
+use zed_actions::{OpenBrowser, OpenZedURL};
+
+actions!(
+ About,
+ DebugElements,
+ DecreaseBufferFontSize,
+ Hide,
+ HideOthers,
+ IncreaseBufferFontSize,
+ Minimize,
+ OpenDefaultKeymap,
+ OpenDefaultSettings,
+ OpenKeymap,
+ OpenLicenses,
+ OpenLocalSettings,
+ OpenLog,
+ OpenSettings,
+ OpenTelemetryLog,
+ Quit,
+ ResetBufferFontSize,
+ ResetDatabase,
+ ShowAll,
+ ToggleFullScreen,
+ Zoom,
+);
pub fn build_window_options(
bounds: Option<WindowBounds>,
@@ -48,6 +86,211 @@ pub fn build_window_options(
}
}
+pub fn init_zed_actions(app_state: Arc<AppState>, cx: &mut AppContext) {
+ cx.observe_new_views(move |workspace: &mut Workspace, _cx| {
+ workspace
+ .register_action(about)
+ .register_action(|_, _: &Hide, cx| {
+ cx.hide();
+ })
+ .register_action(|_, _: &HideOthers, cx| {
+ cx.hide_other_apps();
+ })
+ .register_action(|_, _: &ShowAll, cx| {
+ cx.unhide_other_apps();
+ })
+ .register_action(|_, _: &Minimize, cx| {
+ cx.minimize_window();
+ })
+ .register_action(|_, _: &Zoom, cx| {
+ cx.zoom_window();
+ })
+ .register_action(|_, _: &ToggleFullScreen, cx| {
+ cx.toggle_full_screen();
+ })
+ .register_action(quit)
+ .register_action(|_, action: &OpenZedURL, cx| {
+ cx.global::<Arc<OpenListener>>()
+ .open_urls(&[action.url.clone()])
+ })
+ .register_action(|_, action: &OpenBrowser, cx| cx.open_url(&action.url))
+ //todo!(buffer font size)
+ // cx.add_global_action(move |_: &IncreaseBufferFontSize, cx| {
+ // theme::adjust_font_size(cx, |size| *size += 1.0)
+ // });
+ // cx.add_global_action(move |_: &DecreaseBufferFontSize, cx| {
+ // theme::adjust_font_size(cx, |size| *size -= 1.0)
+ // });
+ // cx.add_global_action(move |_: &ResetBufferFontSize, cx| theme::reset_font_size(cx));
+ .register_action(|_, _: &install_cli::Install, cx| {
+ cx.spawn(|_, cx| async move {
+ install_cli::install_cli(cx.deref())
+ .await
+ .context("error creating CLI symlink")
+ })
+ .detach_and_log_err(cx);
+ })
+ .register_action(|workspace, _: &OpenLog, cx| {
+ open_log_file(workspace, cx);
+ })
+ .register_action(|workspace, _: &OpenLicenses, cx| {
+ open_bundled_file(
+ workspace,
+ asset_str::<Assets>("licenses.md"),
+ "Open Source License Attribution",
+ "Markdown",
+ cx,
+ );
+ })
+ .register_action(
+ move |workspace: &mut Workspace,
+ _: &OpenTelemetryLog,
+ cx: &mut ViewContext<Workspace>| {
+ open_telemetry_log_file(workspace, cx);
+ },
+ )
+ .register_action(
+ move |_: &mut Workspace, _: &OpenKeymap, cx: &mut ViewContext<Workspace>| {
+ create_and_open_local_file(&paths::KEYMAP, cx, Default::default)
+ .detach_and_log_err(cx);
+ },
+ )
+ .register_action(
+ move |_: &mut Workspace, _: &OpenSettings, cx: &mut ViewContext<Workspace>| {
+ create_and_open_local_file(&paths::SETTINGS, cx, || {
+ settings::initial_user_settings_content().as_ref().into()
+ })
+ .detach_and_log_err(cx);
+ },
+ )
+ .register_action(open_local_settings_file)
+ .register_action(
+ move |workspace: &mut Workspace,
+ _: &OpenDefaultKeymap,
+ cx: &mut ViewContext<Workspace>| {
+ open_bundled_file(
+ workspace,
+ settings::default_keymap(),
+ "Default Key Bindings",
+ "JSON",
+ cx,
+ );
+ },
+ )
+ .register_action(
+ move |workspace: &mut Workspace,
+ _: &OpenDefaultSettings,
+ cx: &mut ViewContext<Workspace>| {
+ open_bundled_file(
+ workspace,
+ settings::default_settings(),
+ "Default Settings",
+ "JSON",
+ cx,
+ );
+ },
+ )
+ //todo!()
+ // cx.add_action({
+ // move |workspace: &mut Workspace, _: &DebugElements, cx: &mut ViewContext<Workspace>| {
+ // let app_state = workspace.app_state().clone();
+ // let markdown = app_state.languages.language_for_name("JSON");
+ // let window = cx.window();
+ // cx.spawn(|workspace, mut cx| async move {
+ // let markdown = markdown.await.log_err();
+ // let content = to_string_pretty(&window.debug_elements(&cx).ok_or_else(|| {
+ // anyhow!("could not debug elements for window {}", window.id())
+ // })?)
+ // .unwrap();
+ // workspace
+ // .update(&mut cx, |workspace, cx| {
+ // workspace.with_local_workspace(cx, move |workspace, cx| {
+ // let project = workspace.project().clone();
+ // let buffer = project
+ // .update(cx, |project, cx| {
+ // project.create_buffer(&content, markdown, cx)
+ // })
+ // .expect("creating buffers on a local workspace always succeeds");
+ // let buffer = cx.add_model(|cx| {
+ // MultiBuffer::singleton(buffer, cx)
+ // .with_title("Debug Elements".into())
+ // });
+ // workspace.add_item(
+ // Box::new(cx.add_view(|cx| {
+ // Editor::for_multibuffer(buffer, Some(project.clone()), cx)
+ // })),
+ // cx,
+ // );
+ // })
+ // })?
+ // .await
+ // })
+ // .detach_and_log_err(cx);
+ // }
+ // });
+ // .register_action(
+ // |workspace: &mut Workspace,
+ // _: &project_panel::ToggleFocus,
+ // cx: &mut ViewContext<Workspace>| {
+ // workspace.toggle_panel_focus::<ProjectPanel>(cx);
+ // },
+ // );
+ // cx.add_action(
+ // |workspace: &mut Workspace,
+ // _: &collab_ui::collab_panel::ToggleFocus,
+ // cx: &mut ViewContext<Workspace>| {
+ // workspace.toggle_panel_focus::<collab_ui::collab_panel::CollabPanel>(cx);
+ // },
+ // );
+ // cx.add_action(
+ // |workspace: &mut Workspace,
+ // _: &collab_ui::chat_panel::ToggleFocus,
+ // cx: &mut ViewContext<Workspace>| {
+ // workspace.toggle_panel_focus::<collab_ui::chat_panel::ChatPanel>(cx);
+ // },
+ // );
+ // cx.add_action(
+ // |workspace: &mut Workspace,
+ // _: &collab_ui::notification_panel::ToggleFocus,
+ // cx: &mut ViewContext<Workspace>| {
+ // workspace.toggle_panel_focus::<collab_ui::notification_panel::NotificationPanel>(cx);
+ // },
+ // );
+ // cx.add_action(
+ // |workspace: &mut Workspace,
+ // _: &terminal_panel::ToggleFocus,
+ // cx: &mut ViewContext<Workspace>| {
+ // workspace.toggle_panel_focus::<TerminalPanel>(cx);
+ // },
+ // );
+ .register_action({
+ let app_state = Arc::downgrade(&app_state);
+ move |_, _: &NewWindow, cx| {
+ if let Some(app_state) = app_state.upgrade() {
+ open_new(&app_state, cx, |workspace, cx| {
+ Editor::new_file(workspace, &Default::default(), cx)
+ })
+ .detach();
+ }
+ }
+ })
+ .register_action({
+ let app_state = Arc::downgrade(&app_state);
+ move |_, _: &NewFile, cx| {
+ if let Some(app_state) = app_state.upgrade() {
+ open_new(&app_state, cx, |workspace, cx| {
+ Editor::new_file(workspace, &Default::default(), cx)
+ })
+ .detach();
+ }
+ }
+ });
+ //todo!()
+ // load_default_keymap(cx);
+ })
+ .detach();
+}
+
pub fn initialize_workspace(
workspace_handle: WeakView<Workspace>,
was_deserialized: bool,
@@ -195,3 +438,280 @@ pub fn initialize_workspace(
Ok(())
})
}
+
+fn about(_: &mut Workspace, _: &About, cx: &mut gpui::ViewContext<Workspace>) {
+ let app_name = cx.global::<ReleaseChannel>().display_name();
+ let version = env!("CARGO_PKG_VERSION");
+ let prompt = cx.prompt(PromptLevel::Info, &format!("{app_name} {version}"), &["OK"]);
+ cx.foreground_executor()
+ .spawn(async {
+ prompt.await.ok();
+ })
+ .detach();
+}
+
+fn quit(_: &mut Workspace, _: &Quit, cx: &mut gpui::ViewContext<Workspace>) {
+ let should_confirm = WorkspaceSettings::get_global(cx).confirm_quit;
+ cx.spawn(|_, mut cx| async move {
+ let mut workspace_windows = cx.update(|_, cx| {
+ cx.windows()
+ .into_iter()
+ .filter_map(|window| window.downcast::<Workspace>())
+ .collect::<Vec<_>>()
+ })?;
+
+ // If multiple windows have unsaved changes, and need a save prompt,
+ // prompt in the active window before switching to a different window.
+ cx.update(|_, cx| {
+ workspace_windows.sort_by_key(|window| window.is_active(&cx) == Some(false));
+ })
+ .log_err();
+
+ if let (true, Some(window)) = (should_confirm, workspace_windows.first().copied()) {
+ let answer = cx
+ .update(|_, cx| {
+ cx.prompt(
+ PromptLevel::Info,
+ "Are you sure you want to quit?",
+ &["Quit", "Cancel"],
+ )
+ })
+ .log_err();
+
+ if let Some(mut answer) = answer {
+ let answer = answer.await.ok();
+ if answer != Some(0) {
+ return Ok(());
+ }
+ }
+ }
+
+ // If the user cancels any save prompt, then keep the app open.
+ for window in workspace_windows {
+ if let Some(should_close) = window
+ .update(&mut cx, |workspace, cx| {
+ workspace.prepare_to_close(true, cx)
+ })
+ .log_err()
+ {
+ if !should_close.await? {
+ return Ok(());
+ }
+ }
+ }
+ cx.update(|_, cx| {
+ cx.quit();
+ })?;
+
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
+}
+
+fn open_log_file(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
+ const MAX_LINES: usize = 1000;
+ workspace
+ .with_local_workspace(cx, move |workspace, cx| {
+ let fs = workspace.app_state().fs.clone();
+ cx.spawn(|workspace, mut cx| async move {
+ let (old_log, new_log) =
+ futures::join!(fs.load(&paths::OLD_LOG), fs.load(&paths::LOG));
+
+ let mut lines = VecDeque::with_capacity(MAX_LINES);
+ for line in old_log
+ .iter()
+ .flat_map(|log| log.lines())
+ .chain(new_log.iter().flat_map(|log| log.lines()))
+ {
+ if lines.len() == MAX_LINES {
+ lines.pop_front();
+ }
+ lines.push_back(line);
+ }
+ let log = lines
+ .into_iter()
+ .flat_map(|line| [line, "\n"])
+ .collect::<String>();
+
+ workspace
+ .update(&mut cx, |workspace, cx| {
+ let project = workspace.project().clone();
+ let buffer = project
+ .update(cx, |project, cx| project.create_buffer("", None, cx))
+ .expect("creating buffers on a local workspace always succeeds");
+ buffer.update(cx, |buffer, cx| buffer.edit([(0..0, log)], None, cx));
+
+ let buffer = cx.build_model(|cx| {
+ MultiBuffer::singleton(buffer, cx).with_title("Log".into())
+ });
+ workspace.add_item(
+ Box::new(cx.build_view(|cx| {
+ Editor::for_multibuffer(buffer, Some(project), cx)
+ })),
+ cx,
+ );
+ })
+ .log_err();
+ })
+ .detach();
+ })
+ .detach();
+}
+
+fn open_local_settings_file(
+ workspace: &mut Workspace,
+ _: &OpenLocalSettings,
+ cx: &mut ViewContext<Workspace>,
+) {
+ let project = workspace.project().clone();
+ let worktree = project
+ .read(cx)
+ .visible_worktrees(cx)
+ .find_map(|tree| tree.read(cx).root_entry()?.is_dir().then_some(tree));
+ if let Some(worktree) = worktree {
+ let tree_id = worktree.read(cx).id();
+ cx.spawn(|workspace, mut cx| async move {
+ let file_path = &*LOCAL_SETTINGS_RELATIVE_PATH;
+
+ if let Some(dir_path) = file_path.parent() {
+ if worktree.update(&mut cx, |tree, _| tree.entry_for_path(dir_path).is_none())? {
+ project
+ .update(&mut cx, |project, cx| {
+ project.create_entry((tree_id, dir_path), true, cx)
+ })?
+ .ok_or_else(|| anyhow!("worktree was removed"))?
+ .await?;
+ }
+ }
+
+ if worktree.update(&mut cx, |tree, _| tree.entry_for_path(file_path).is_none())? {
+ project
+ .update(&mut cx, |project, cx| {
+ project.create_entry((tree_id, file_path), false, cx)
+ })?
+ .ok_or_else(|| anyhow!("worktree was removed"))?
+ .await?;
+ }
+
+ let editor = workspace
+ .update(&mut cx, |workspace, cx| {
+ workspace.open_path((tree_id, file_path), None, true, cx)
+ })?
+ .await?
+ .downcast::<Editor>()
+ .ok_or_else(|| anyhow!("unexpected item type"))?;
+
+ editor
+ .downgrade()
+ .update(&mut cx, |editor, cx| {
+ if let Some(buffer) = editor.buffer().read(cx).as_singleton() {
+ if buffer.read(cx).is_empty() {
+ buffer.update(cx, |buffer, cx| {
+ buffer.edit([(0..0, initial_local_settings_content())], None, cx)
+ });
+ }
+ }
+ })
+ .ok();
+
+ anyhow::Ok(())
+ })
+ .detach();
+ } else {
+ workspace.show_notification(0, cx, |cx| {
+ cx.build_view(|_| MessageNotification::new("This project has no folders open."))
+ })
+ }
+}
+
+fn open_telemetry_log_file(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
+ workspace.with_local_workspace(cx, move |workspace, cx| {
+ let app_state = workspace.app_state().clone();
+ cx.spawn(|workspace, mut cx| async move {
+ async fn fetch_log_string(app_state: &Arc<AppState>) -> Option<String> {
+ let path = app_state.client.telemetry().log_file_path()?;
+ app_state.fs.load(&path).await.log_err()
+ }
+
+ let log = fetch_log_string(&app_state).await.unwrap_or_else(|| "// No data has been collected yet".to_string());
+
+ const MAX_TELEMETRY_LOG_LEN: usize = 5 * 1024 * 1024;
+ let mut start_offset = log.len().saturating_sub(MAX_TELEMETRY_LOG_LEN);
+ if let Some(newline_offset) = log[start_offset..].find('\n') {
+ start_offset += newline_offset + 1;
+ }
+ let log_suffix = &log[start_offset..];
+ let json = app_state.languages.language_for_name("JSON").await.log_err();
+
+ workspace.update(&mut cx, |workspace, cx| {
+ let project = workspace.project().clone();
+ let buffer = project
+ .update(cx, |project, cx| project.create_buffer("", None, cx))
+ .expect("creating buffers on a local workspace always succeeds");
+ buffer.update(cx, |buffer, cx| {
+ buffer.set_language(json, cx);
+ buffer.edit(
+ [(
+ 0..0,
+ concat!(
+ "// Zed collects anonymous usage data to help us understand how people are using the app.\n",
+ "// Telemetry can be disabled via the `settings.json` file.\n",
+ "// Here is the data that has been reported for the current session:\n",
+ "\n"
+ ),
+ )],
+ None,
+ cx,
+ );
+ buffer.edit([(buffer.len()..buffer.len(), log_suffix)], None, cx);
+ });
+
+ let buffer = cx.build_model(|cx| {
+ MultiBuffer::singleton(buffer, cx).with_title("Telemetry Log".into())
+ });
+ workspace.add_item(
+ Box::new(cx.build_view(|cx| Editor::for_multibuffer(buffer, Some(project), cx))),
+ cx,
+ );
+ }).log_err()?;
+
+ Some(())
+ })
+ .detach();
+ }).detach();
+}
+
+fn open_bundled_file(
+ workspace: &mut Workspace,
+ text: Cow<'static, str>,
+ title: &'static str,
+ language: &'static str,
+ cx: &mut ViewContext<Workspace>,
+) {
+ let language = workspace.app_state().languages.language_for_name(language);
+ cx.spawn(|workspace, mut cx| async move {
+ let language = language.await.log_err();
+ workspace
+ .update(&mut cx, |workspace, cx| {
+ workspace.with_local_workspace(cx, |workspace, cx| {
+ let project = workspace.project();
+ let buffer = project.update(cx, move |project, cx| {
+ project
+ .create_buffer(text.as_ref(), language, cx)
+ .expect("creating buffers on a local workspace always succeeds")
+ });
+ let buffer = cx.build_model(|cx| {
+ MultiBuffer::singleton(buffer, cx).with_title(title.into())
+ });
+ workspace.add_item(
+ Box::new(cx.build_view(|cx| {
+ Editor::for_multibuffer(buffer, Some(project.clone()), cx)
+ })),
+ cx,
+ );
+ })
+ })?
+ .await
+ })
+ .detach_and_log_err(cx);
+}
@@ -1,33 +1,19 @@
-use gpui::{action, actions};
+use gpui::action;
-actions!(
- About,
- DebugElements,
- DecreaseBufferFontSize,
- Hide,
- HideOthers,
- IncreaseBufferFontSize,
- Minimize,
- OpenDefaultKeymap,
- OpenDefaultSettings,
- OpenKeymap,
- OpenLicenses,
- OpenLocalSettings,
- OpenLog,
- OpenSettings,
- OpenTelemetryLog,
- Quit,
- ResetBufferFontSize,
- ResetDatabase,
- ShowAll,
- ToggleFullScreen,
- Zoom,
-);
+// If the zed binary doesn't use anything in this crate, it will be optimized away
+// and the actions won't initialize. So we just provide an empty initialization function
+// to be called from main.
+//
+// These may provide relevant context:
+// https://github.com/rust-lang/rust/issues/47384
+// https://github.com/mmastrac/rust-ctor/issues/280
+pub fn init() {}
#[action]
pub struct OpenBrowser {
pub url: String,
}
+
#[action]
pub struct OpenZedURL {
pub url: String,