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

Merge pull request #2199 from zed-industries/welcome-experience

Browse source 
Welcome experience
This commit is contained in:
Mikayla Maki 2023-03-10 10:48:30 -08:00 • committed by GitHub
commit 37d01c7fb3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
63 changed files with 2649 additions and 675 deletions
Download patch file Download diff file Expand all files Collapse all files

35
Cargo.lock generated
View file

@ -3018,6 +3018,17 @@ version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "adab1eaa3408fb7f0c777a73e7465fd5656136fc93b670eb6df3c88c2c1344e3" checksum = "adab1eaa3408fb7f0c777a73e7465fd5656136fc93b670eb6df3c88c2c1344e3"
[[package]]
name = "install_cli"
version = "0.1.0"
dependencies = [
"anyhow",
"gpui",
"log",
"smol",
"util",
]
[[package]] [[package]]
name = "instant" name = "instant"
version = "0.1.12" version = "0.1.12"
@ -8030,6 +8041,26 @@ version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb" checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb"
[[package]]
name = "welcome"
version = "0.1.0"
dependencies = [
"anyhow",
"db",
"editor",
"fuzzy",
"gpui",
"install_cli",
"log",
"picker",
"project",
"settings",
"theme",
"theme_selector",
"util",
"workspace",
]
[[package]] [[package]]
name = "wepoll-ffi" name = "wepoll-ffi"
version = "0.1.2" version = "0.1.2"
@ -8305,6 +8336,7 @@ dependencies = [
"futures 0.3.25", "futures 0.3.25",
"gpui", "gpui",
"indoc", "indoc",
"install_cli",
"language", "language",
"lazy_static", "lazy_static",
"log", "log",
@ -8397,6 +8429,7 @@ dependencies = [
"command_palette", "command_palette",
"context_menu", "context_menu",
"ctor", "ctor",
"db",
"diagnostics", "diagnostics",
"easy-parallel", "easy-parallel",
"editor", "editor",
@ -8412,6 +8445,7 @@ dependencies = [
"ignore", "ignore",
"image", "image",
"indexmap", "indexmap",
"install_cli",
"isahc", "isahc",
"journal", "journal",
"language", "language",
@ -8477,6 +8511,7 @@ dependencies = [
"util", "util",
"uuid 1.2.2", "uuid 1.2.2",
"vim", "vim",
"welcome",
"workspace", "workspace",
] ]

2
Cargo.toml
View file

@ -26,6 +26,7 @@ members = [
"crates/go_to_line", "crates/go_to_line",
"crates/gpui", "crates/gpui",
"crates/gpui_macros", "crates/gpui_macros",
"crates/install_cli",
"crates/journal", "crates/journal",
"crates/language", "crates/language",
"crates/language_selector", "crates/language_selector",
@ -59,6 +60,7 @@ members = [
"crates/util", "crates/util",
"crates/vim", "crates/vim",
"crates/workspace", "crates/workspace",
"crates/welcome",
"crates/zed", "crates/zed",
] ]
default-members = ["crates/zed"] default-members = ["crates/zed"]

3
assets/icons/logo_96.svg Normal file
View file

@ -0,0 +1,3 @@
<svg width="96" height="96" viewBox="0 0 96 96" fill="none" xmlns="http://www.w3.org/2000/svg">
<path fill-rule="evenodd" clip-rule="evenodd" d="M9 6C7.34315 6 6 7.34315 6 9V75H0V9C0 4.02944 4.02944 0 9 0H89.3787C93.3878 0 95.3955 4.84715 92.5607 7.68198L43.0551 57.1875H57V51H63V58.6875C63 61.1728 60.9853 63.1875 58.5 63.1875H37.0551L26.7426 73.5H73.5V36H79.5V73.5C79.5 76.8137 76.8137 79.5 73.5 79.5H20.7426L10.2426 90H87C88.6569 90 90 88.6569 90 87V21H96V87C96 91.9706 91.9706 96 87 96H6.62132C2.61224 96 0.604504 91.1529 3.43934 88.318L52.7574 39H39V45H33V37.5C33 35.0147 35.0147 33 37.5 33H58.7574L69.2574 22.5H22.5V60H16.5V22.5C16.5 19.1863 19.1863 16.5 22.5 16.5H75.2574L85.7574 6H9Z" fill="white"/>
</svg>
Side by side

After

Width:  |  Height:  |  Size: 715 B

68
assets/keymaps/atom.json Normal file
View file

@ -0,0 +1,68 @@
[
{
"bindings": {
"cmd-k cmd-p": "workspace::ActivatePreviousPane",
"cmd-k cmd-n": "workspace::ActivateNextPane"
}
},
{
"context": "Editor",
"bindings": {
"cmd-b": "editor::GoToDefinition",
"cmd-<": "editor::ScrollCursorCenter",
"cmd-g": [
"editor::SelectNext",
{
"replace_newest": true
}
],
"ctrl-shift-down": "editor::AddSelectionBelow",
"ctrl-shift-up": "editor::AddSelectionAbove",
"cmd-shift-backspace": "editor::DeleteToBeginningOfLine"
}
},
{
"context": "Editor && mode == full",
"bindings": {
"cmd-r": "outline::Toggle"
}
},
{
"context": "BufferSearchBar",
"bindings": {
"cmd-f3": "search::SelectNextMatch",
"cmd-shift-f3": "search::SelectPrevMatch"
}
},
{
"context": "Workspace",
"bindings": {
"cmd-\\": "workspace::ToggleLeftSidebar",
"cmd-k cmd-b": "workspace::ToggleLeftSidebar",
"cmd-t": "file_finder::Toggle",
"cmd-shift-r": "project_symbols::Toggle"
}
},
{
"context": "Pane",
"bindings": {
"alt-cmd-/": "search::ToggleRegex",
"ctrl-0": "project_panel::ToggleFocus"
}
},
{
"context": "ProjectPanel",
"bindings": {
"ctrl-[": "project_panel::CollapseSelectedEntry",
"ctrl-b": "project_panel::CollapseSelectedEntry",
"h": "project_panel::CollapseSelectedEntry",
"ctrl-]": "project_panel::ExpandSelectedEntry",
"ctrl-f": "project_panel::ExpandSelectedEntry",
"ctrl-shift-c": "project_panel::CopyPath"
}
},
{
"context": "Dock",
"bindings": {}
}
]

78
assets/keymaps/jetbrains.json Normal file
View file

@ -0,0 +1,78 @@
[
{
"bindings": {
"cmd-shift-[": "pane::ActivatePrevItem",
"cmd-shift-]": "pane::ActivateNextItem"
}
},
{
"context": "Editor",
"bindings": {
"ctrl->": "zed::IncreaseBufferFontSize",
"ctrl-<": "zed::DecreaseBufferFontSize",
"cmd-d": "editor::DuplicateLine",
"cmd-pagedown": "editor::MovePageDown",
"cmd-pageup": "editor::MovePageUp",
"ctrl-alt-shift-b": "editor::SelectToPreviousWordStart",
"shift-enter": "editor::NewlineBelow",
"cmd--": "editor::Fold",
"cmd-=": "editor::UnfoldLines",
"alt-shift-g": "editor::SplitSelectionIntoLines",
"ctrl-g": [
"editor::SelectNext",
{
"replace_newest": false
}
],
"cmd-/": [
"editor::ToggleComments",
{
"advance_downwards": true
}
],
"shift-alt-up": "editor::MoveLineUp",
"shift-alt-down": "editor::MoveLineDown",
"cmd-[": "pane::GoBack",
"cmd-]": "pane::GoForward",
"alt-f7": "editor::FindAllReferences",
"cmd-alt-f7": "editor::FindAllReferences",
"cmd-b": "editor::GoToDefinition",
"cmd-alt-b": "editor::GoToDefinition",
"cmd-shift-b": "editor::GoToTypeDefinition",
"alt-enter": "editor::ToggleCodeActions",
"f2": "editor::GoToDiagnostic",
"cmd-f2": "editor::GoToPrevDiagnostic",
"ctrl-alt-shift-down": "editor::GoToHunk",
"ctrl-alt-shift-up": "editor::GoToPrevHunk",
"cmd-home": "editor::MoveToBeginning",
"cmd-end": "editor::MoveToEnd",
"cmd-shift-home": "editor::SelectToBeginning",
"cmd-shift-end": "editor::SelectToEnd"
}
},
{
"context": "Editor && mode == full",
"bindings": {
"cmd-f12": "outline::Toggle",
"cmd-7": "outline::Toggle",
"cmd-shift-o": "file_finder::Toggle",
"cmd-l": "go_to_line::Toggle"
}
},
{
"context": "Workspace",
"bindings": {
"cmd-shift-a": "command_palette::Toggle",
"cmd-alt-o": "project_symbols::Toggle",
"cmd-1": "workspace::ToggleLeftSidebar",
"cmd-6": "diagnostics::Deploy",
"alt-f12": "dock::FocusDock"
}
},
{
"context": "Dock",
"bindings": {
"alt-f12": "dock::HideDock"
}
}
]

60
assets/keymaps/sublime_text.json Normal file
View file

@ -0,0 +1,60 @@
[
{
"bindings": {
"cmd-shift-[": "pane::ActivatePrevItem",
"cmd-shift-]": "pane::ActivateNextItem",
"ctrl-pagedown": "pane::ActivatePrevItem",
"ctrl-pageup": "pane::ActivateNextItem",
"ctrl-shift-tab": "pane::ActivateNextItem",
"ctrl-tab": "pane::ActivatePrevItem",
"cmd-+": "zed::IncreaseBufferFontSize"
}
},
{
"context": "Editor",
"bindings": {
"ctrl-shift-up": "editor::AddSelectionAbove",
"ctrl-shift-down": "editor::AddSelectionBelow",
"cmd-shift-space": "editor::SelectAll",
"ctrl-shift-m": "editor::SelectLargerSyntaxNode",
"cmd-shift-a": "editor::SelectLargerSyntaxNode",
"shift-f12": "editor::FindAllReferences",
"alt-cmd-down": "editor::GoToDefinition",
"alt-shift-cmd-down": "editor::FindAllReferences",
"ctrl-.": "editor::GoToHunk",
"ctrl-,": "editor::GoToPrevHunk",
"ctrl-backspace": "editor::DeleteToPreviousWordStart",
"ctrl-delete": "editor::DeleteToNextWordEnd"
}
},
{
"context": "Editor && mode == full",
"bindings": {
"cmd-r": "outline::Toggle"
}
},
{
"context": "Pane",
"bindings": {
"f4": "search::SelectNextMatch",
"shift-f4": "search::SelectPrevMatch"
}
},
{
"context": "Workspace",
"bindings": {
"ctrl-`": "dock::FocusDock",
"cmd-k cmd-b": "workspace::ToggleLeftSidebar",
"cmd-t": "file_finder::Toggle",
"shift-cmd-r": "project_symbols::Toggle",
// Currently busted: https://github.com/zed-industries/feedback/issues/898
"ctrl-0": "project_panel::ToggleFocus"
}
},
{
"context": "Dock",
"bindings": {
"ctrl-`": "dock::HideDock"
}
}
]

2
assets/settings/default.json
View file

@ -50,7 +50,7 @@
// "default_dock_anchor": "right" // "default_dock_anchor": "right"
// 3. Position the dock full screen over the entire workspace" // 3. Position the dock full screen over the entire workspace"
// "default_dock_anchor": "expanded" // "default_dock_anchor": "expanded"
"default_dock_anchor": "right", "default_dock_anchor": "bottom",
// Whether or not to remove any trailing whitespace from lines of a buffer // Whether or not to remove any trailing whitespace from lines of a buffer
// before saving it. // before saving it.
"remove_trailing_whitespace_on_save": true, "remove_trailing_whitespace_on_save": true,

13
crates/collab/src/tests.rs
View file

@ -197,7 +197,8 @@ impl TestServer {
fs: fs.clone(), fs: fs.clone(),
build_window_options: |_, _, _| Default::default(), build_window_options: |_, _, _| Default::default(),
initialize_workspace: |_, _, _| unimplemented!(), initialize_workspace: |_, _, _| unimplemented!(),
dock_default_item_factory: |_, _| unimplemented!(), dock_default_item_factory: |_, _| None,
background_actions: || &[],
}); });
Project::init(&client); Project::init(&client);
@ -434,15 +435,7 @@ impl TestClient {
cx: &mut TestAppContext, cx: &mut TestAppContext,
) -> ViewHandle<Workspace> { ) -> ViewHandle<Workspace> {
let (_, root_view) = cx.add_window(|_| EmptyView); let (_, root_view) = cx.add_window(|_| EmptyView);
cx.add_view(&root_view, |cx| { cx.add_view(&root_view, |cx| Workspace::test_new(project.clone(), cx))
Workspace::new(
Default::default(),
0,
project.clone(),
|_, _| unimplemented!(),
cx,
)
})
} }
fn create_new_root_dir(&mut self) -> PathBuf { fn create_new_root_dir(&mut self) -> PathBuf {

30
crates/collab/src/tests/integration_tests.rs
View file

@ -1449,15 +1449,7 @@ async fn test_host_disconnect(
deterministic.run_until_parked(); deterministic.run_until_parked();
assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared())); assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
let (_, workspace_b) = cx_b.add_window(|cx| { let (_, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
Workspace::new(
Default::default(),
0,
project_b.clone(),
|_, _| unimplemented!(),
cx,
)
});
let editor_b = workspace_b let editor_b = workspace_b
.update(cx_b, |workspace, cx| { .update(cx_b, |workspace, cx| {
workspace.open_path((worktree_id, "b.txt"), None, true, cx) workspace.open_path((worktree_id, "b.txt"), None, true, cx)
@ -4706,15 +4698,7 @@ async fn test_collaborating_with_code_actions(
// Join the project as client B. // Join the project as client B.
let project_b = client_b.build_remote_project(project_id, cx_b).await; let project_b = client_b.build_remote_project(project_id, cx_b).await;
let (_window_b, workspace_b) = cx_b.add_window(|cx| { let (_window_b, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
Workspace::new(
Default::default(),
0,
project_b.clone(),
|_, _| unimplemented!(),
cx,
)
});
let editor_b = workspace_b let editor_b = workspace_b
.update(cx_b, |workspace, cx| { .update(cx_b, |workspace, cx| {
workspace.open_path((worktree_id, "main.rs"), None, true, cx) workspace.open_path((worktree_id, "main.rs"), None, true, cx)
@ -4937,15 +4921,7 @@ async fn test_collaborating_with_renames(
.unwrap(); .unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await; let project_b = client_b.build_remote_project(project_id, cx_b).await;
let (_window_b, workspace_b) = cx_b.add_window(|cx| { let (_window_b, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
Workspace::new(
Default::default(),
0,
project_b.clone(),
|_, _| unimplemented!(),
cx,
)
});
let editor_b = workspace_b let editor_b = workspace_b
.update(cx_b, |workspace, cx| { .update(cx_b, |workspace, cx| {
workspace.open_path((worktree_id, "one.rs"), None, true, cx) workspace.open_path((worktree_id, "one.rs"), None, true, cx)

2
crates/collab_ui/src/collab_titlebar_item.rs
View file

@ -821,7 +821,7 @@ impl CollabTitlebarItem {
avatar_style: AvatarStyle, avatar_style: AvatarStyle,
background_color: Color, background_color: Color,
) -> ElementBox { ) -> ElementBox {
Image::new(avatar) Image::from_data(avatar)
.with_style(avatar_style.image) .with_style(avatar_style.image)
.aligned() .aligned()
.contained() .contained()

1
crates/collab_ui/src/collab_ui.rs
View file

@ -86,6 +86,7 @@ fn join_project(action: &JoinProject, app_state: Arc<AppState>, cx: &mut Mutable
0, 0,
project, project,
app_state.dock_default_item_factory, app_state.dock_default_item_factory,
app_state.background_actions,
cx, cx,
); );
(app_state.initialize_workspace)(&mut workspace, &app_state, cx); (app_state.initialize_workspace)(&mut workspace, &app_state, cx);

2
crates/collab_ui/src/contact_finder.rs
View file

@ -128,7 +128,7 @@ impl PickerDelegate for ContactFinder {
.style_for(mouse_state, selected); .style_for(mouse_state, selected);
Flex::row() Flex::row()
.with_children(user.avatar.clone().map(|avatar| { .with_children(user.avatar.clone().map(|avatar| {
Image::new(avatar) Image::from_data(avatar)
.with_style(theme.contact_finder.contact_avatar) .with_style(theme.contact_finder.contact_avatar)
.aligned() .aligned()
.left() .left()

6
crates/collab_ui/src/contact_list.rs
View file

@ -736,7 +736,7 @@ impl ContactList {
) -> ElementBox { ) -> ElementBox {
Flex::row() Flex::row()
.with_children(user.avatar.clone().map(|avatar| { .with_children(user.avatar.clone().map(|avatar| {
Image::new(avatar) Image::from_data(avatar)
.with_style(theme.contact_avatar) .with_style(theme.contact_avatar)
.aligned() .aligned()
.left() .left()
@ -1090,7 +1090,7 @@ impl ContactList {
}; };
Stack::new() Stack::new()
.with_child( .with_child(
Image::new(avatar) Image::from_data(avatar)
.with_style(theme.contact_avatar) .with_style(theme.contact_avatar)
.aligned() .aligned()
.left() .left()
@ -1183,7 +1183,7 @@ impl ContactList {
let mut row = Flex::row() let mut row = Flex::row()
.with_children(user.avatar.clone().map(|avatar| { .with_children(user.avatar.clone().map(|avatar| {
Image::new(avatar) Image::from_data(avatar)
.with_style(theme.contact_avatar) .with_style(theme.contact_avatar)
.aligned() .aligned()
.left() .left()

2
crates/collab_ui/src/incoming_call_notification.rs
View file

@ -108,7 +108,7 @@ impl IncomingCallNotification {
.unwrap_or(&default_project); .unwrap_or(&default_project);
Flex::row() Flex::row()
.with_children(self.call.calling_user.avatar.clone().map(|avatar| { .with_children(self.call.calling_user.avatar.clone().map(|avatar| {
Image::new(avatar) Image::from_data(avatar)
.with_style(theme.caller_avatar) .with_style(theme.caller_avatar)
.aligned() .aligned()
.boxed() .boxed()

2
crates/collab_ui/src/notifications.rs
View file

@ -24,7 +24,7 @@ pub fn render_user_notification<V: View, A: Action + Clone>(
.with_child( .with_child(
Flex::row() Flex::row()
.with_children(user.avatar.clone().map(|avatar| { .with_children(user.avatar.clone().map(|avatar| {
Image::new(avatar) Image::from_data(avatar)
.with_style(theme.header_avatar) .with_style(theme.header_avatar)
.aligned() .aligned()
.constrained() .constrained()

2
crates/collab_ui/src/project_shared_notification.rs
View file

@ -108,7 +108,7 @@ impl ProjectSharedNotification {
let theme = &cx.global::<Settings>().theme.project_shared_notification; let theme = &cx.global::<Settings>().theme.project_shared_notification;
Flex::row() Flex::row()
.with_children(self.owner.avatar.clone().map(|avatar| { .with_children(self.owner.avatar.clone().map(|avatar| {
Image::new(avatar) Image::from_data(avatar)
.with_style(theme.owner_avatar) .with_style(theme.owner_avatar)
.aligned() .aligned()
.boxed() .boxed()

4
crates/command_palette/src/command_palette.rs
View file

@ -352,9 +352,7 @@ mod tests {
}); });
let project = Project::test(app_state.fs.clone(), [], cx).await; let project = Project::test(app_state.fs.clone(), [], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let editor = cx.add_view(&workspace, |cx| { let editor = cx.add_view(&workspace, |cx| {
let mut editor = Editor::single_line(None, cx); let mut editor = Editor::single_line(None, cx);
editor.set_text("abc", cx); editor.set_text("abc", cx);

12
crates/db/src/db.rs
View file

@ -4,6 +4,7 @@ pub mod query;
// Re-export // Re-export
pub use anyhow; pub use anyhow;
use anyhow::Context; use anyhow::Context;
use gpui::MutableAppContext;
pub use indoc::indoc; pub use indoc::indoc;
pub use lazy_static; pub use lazy_static;
use parking_lot::{Mutex, RwLock}; use parking_lot::{Mutex, RwLock};
@ -17,6 +18,7 @@ use sqlez::domain::Migrator;
use sqlez::thread_safe_connection::ThreadSafeConnection; use sqlez::thread_safe_connection::ThreadSafeConnection;
use sqlez_macros::sql; use sqlez_macros::sql;
use std::fs::create_dir_all; use std::fs::create_dir_all;
use std::future::Future;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{SystemTime, UNIX_EPOCH}; use std::time::{SystemTime, UNIX_EPOCH};
@ -39,6 +41,7 @@ const FALLBACK_DB_NAME: &'static str = "FALLBACK_MEMORY_DB";
const DB_FILE_NAME: &'static str = "db.sqlite"; const DB_FILE_NAME: &'static str = "db.sqlite";
lazy_static::lazy_static! { lazy_static::lazy_static! {
// !!!!!!! CHANGE BACK TO DEFAULT FALSE BEFORE SHIPPING
static ref ZED_STATELESS: bool = std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty()); static ref ZED_STATELESS: bool = std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty());
static ref DB_FILE_OPERATIONS: Mutex<()> = Mutex::new(()); static ref DB_FILE_OPERATIONS: Mutex<()> = Mutex::new(());
pub static ref BACKUP_DB_PATH: RwLock<Option<PathBuf>> = RwLock::new(None); pub static ref BACKUP_DB_PATH: RwLock<Option<PathBuf>> = RwLock::new(None);
@ -236,6 +239,15 @@ macro_rules! define_connection {
}; };
} }
pub fn write_and_log<F>(cx: &mut MutableAppContext, db_write: impl FnOnce() -> F + Send + 'static)
where
F: Future<Output = anyhow::Result<()>> + Send,
{
cx.background()
.spawn(async move { db_write().await.log_err() })
.detach()
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::{fs, thread}; use std::{fs, thread};

10
crates/diagnostics/src/diagnostics.rs
View file

@ -805,15 +805,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/test".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/test".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(
Default::default(),
0,
project.clone(),
|_, _| unimplemented!(),
cx,
)
});
// Create some diagnostics // Create some diagnostics
project.update(cx, |project, cx| { project.update(cx, |project, cx| {

20
crates/editor/src/editor_tests.rs
View file

@ -484,7 +484,7 @@ fn test_navigation_history(cx: &mut gpui::MutableAppContext) {
cx.set_global(Settings::test(cx)); cx.set_global(Settings::test(cx));
cx.set_global(DragAndDrop::<Workspace>::default()); cx.set_global(DragAndDrop::<Workspace>::default());
use workspace::item::Item; use workspace::item::Item;
let (_, pane) = cx.add_window(Default::default(), |cx| Pane::new(None, cx)); let (_, pane) = cx.add_window(Default::default(), |cx| Pane::new(0, None, || &[], cx));
let buffer = MultiBuffer::build_simple(&sample_text(300, 5, 'a'), cx); let buffer = MultiBuffer::build_simple(&sample_text(300, 5, 'a'), cx);
cx.add_view(&pane, |cx| { cx.add_view(&pane, |cx| {
@ -2353,12 +2353,16 @@ async fn test_clipboard(cx: &mut gpui::TestAppContext) {
e.paste(&Paste, cx); e.paste(&Paste, cx);
e.handle_input(") ", cx); e.handle_input(") ", cx);
}); });
cx.assert_editor_state(indoc! {" cx.assert_editor_state(
( one✅ &([
three "( one✅ ",
five ) ˇtwo one✅ four three six five ( one✅ "three ",
three "five ) ˇtwo one✅ four three six five ( one✅ ",
five ) ˇ"}); "three ",
"five ) ˇ",
]
.join("\n")),
);
// Cut with three selections, one of which is full-line. // Cut with three selections, one of which is full-line.
cx.set_state(indoc! {" cx.set_state(indoc! {"
@ -5562,7 +5566,7 @@ async fn test_following_with_multiple_excerpts(cx: &mut gpui::TestAppContext) {
Settings::test_async(cx); Settings::test_async(cx);
let fs = FakeFs::new(cx.background()); let fs = FakeFs::new(cx.background());
let project = Project::test(fs, ["/file.rs".as_ref()], cx).await; let project = Project::test(fs, ["/file.rs".as_ref()], cx).await;
let (_, pane) = cx.add_window(|cx| Pane::new(None, cx)); let (_, pane) = cx.add_window(|cx| Pane::new(0, None, || &[], cx));
let leader = pane.update(cx, |_, cx| { let leader = pane.update(cx, |_, cx| {
let multibuffer = cx.add_model(|_| MultiBuffer::new(0)); let multibuffer = cx.add_model(|_| MultiBuffer::new(0));

10
crates/editor/src/test/editor_lsp_test_context.rs
View file

@ -65,15 +65,7 @@ impl<'a> EditorLspTestContext<'a> {
.insert_tree("/root", json!({ "dir": { file_name.clone(): "" }})) .insert_tree("/root", json!({ "dir": { file_name.clone(): "" }}))
.await; .await;
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(
Default::default(),
0,
project.clone(),
|_, _| unimplemented!(),
cx,
)
});
project project
.update(cx, |project, cx| { .update(cx, |project, cx| {
project.find_or_create_local_worktree("/root", true, cx) project.find_or_create_local_worktree("/root", true, cx)

28
crates/file_finder/src/file_finder.rs
View file

@ -329,9 +329,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
cx.dispatch_action(window_id, Toggle); cx.dispatch_action(window_id, Toggle);
let finder = cx.read(|cx| workspace.read(cx).modal::<FileFinder>().unwrap()); let finder = cx.read(|cx| workspace.read(cx).modal::<FileFinder>().unwrap());
@ -385,9 +383,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/dir".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/dir".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let (_, finder) = let (_, finder) =
cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx)); cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
@ -461,9 +457,7 @@ mod tests {
cx, cx,
) )
.await; .await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let (_, finder) = let (_, finder) =
cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx)); cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
finder finder
@ -487,9 +481,7 @@ mod tests {
cx, cx,
) )
.await; .await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let (_, finder) = let (_, finder) =
cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx)); cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
@ -541,9 +533,7 @@ mod tests {
cx, cx,
) )
.await; .await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let (_, finder) = let (_, finder) =
cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx)); cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
@ -585,9 +575,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
// When workspace has an active item, sort items which are closer to that item // When workspace has an active item, sort items which are closer to that item
// first when they have the same name. In this case, b.txt is closer to dir2's a.txt // first when they have the same name. In this case, b.txt is closer to dir2's a.txt
@ -624,9 +612,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let (_, finder) = let (_, finder) =
cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx)); cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
finder finder

2
crates/gpui/src/app.rs
View file

@ -5086,7 +5086,7 @@ impl<T: Entity> From<WeakModelHandle<T>> for AnyWeakModelHandle {
} }
} }
#[derive(Debug)] #[derive(Debug, Copy)]
pub struct WeakViewHandle<T> { pub struct WeakViewHandle<T> {
window_id: usize, window_id: usize,
view_id: usize, view_id: usize,

21
crates/gpui/src/assets.rs
View file

@ -1,5 +1,8 @@
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Result};
use std::{borrow::Cow, cell::RefCell, collections::HashMap}; use image::ImageFormat;
use std::{borrow::Cow, cell::RefCell, collections::HashMap, sync::Arc};
use crate::ImageData;
pub trait AssetSource: 'static + Send + Sync { pub trait AssetSource: 'static + Send + Sync {
fn load(&self, path: &str) -> Result<Cow<[u8]>>; fn load(&self, path: &str) -> Result<Cow<[u8]>>;
@ -22,6 +25,7 @@ impl AssetSource for () {
pub struct AssetCache { pub struct AssetCache {
source: Box<dyn AssetSource>, source: Box<dyn AssetSource>,
svgs: RefCell<HashMap<String, usvg::Tree>>, svgs: RefCell<HashMap<String, usvg::Tree>>,
pngs: RefCell<HashMap<String, Arc<ImageData>>>,
} }
impl AssetCache { impl AssetCache {
@ -29,6 +33,7 @@ impl AssetCache {
Self { Self {
source: Box::new(source), source: Box::new(source),
svgs: RefCell::new(HashMap::new()), svgs: RefCell::new(HashMap::new()),
pngs: RefCell::new(HashMap::new()),
} }
} }
@ -43,4 +48,18 @@ impl AssetCache {
Ok(svg) Ok(svg)
} }
} }
pub fn png(&self, path: &str) -> Result<Arc<ImageData>> {
let mut pngs = self.pngs.borrow_mut();
if let Some(png) = pngs.get(path) {
Ok(png.clone())
} else {
let bytes = self.source.load(path)?;
let image = ImageData::new(
image::load_from_memory_with_format(&bytes, ImageFormat::Png)?.into_bgra8(),
);
pngs.insert(path.to_string(), image.clone());
Ok(image)
}
}
} }

4
crates/gpui/src/elements/constrained_box.rs
View file

@ -153,7 +153,9 @@ impl Element for ConstrainedBox {
_: &mut Self::LayoutState, _: &mut Self::LayoutState,
cx: &mut PaintContext, cx: &mut PaintContext,
) -> Self::PaintState { ) -> Self::PaintState {
self.child.paint(bounds.origin(), visible_bounds, cx); cx.paint_layer(Some(visible_bounds), |cx| {
self.child.paint(bounds.origin(), visible_bounds, cx);
})
} }
fn rect_for_text_range( fn rect_for_text_range(

36
crates/gpui/src/elements/flex.rs
View file

@ -22,6 +22,7 @@ pub struct Flex {
axis: Axis, axis: Axis,
children: Vec<ElementBox>, children: Vec<ElementBox>,
scroll_state: Option<(ElementStateHandle<Rc<ScrollState>>, usize)>, scroll_state: Option<(ElementStateHandle<Rc<ScrollState>>, usize)>,
child_alignment: f32,
} }
impl Flex { impl Flex {
@ -30,6 +31,7 @@ impl Flex {
axis, axis,
children: Default::default(), children: Default::default(),
scroll_state: None, scroll_state: None,
child_alignment: -1.,
} }
} }
@ -41,6 +43,15 @@ impl Flex {
Self::new(Axis::Vertical) Self::new(Axis::Vertical)
} }
/// Render children centered relative to the cross-axis of the parent flex.
///
/// If this is a flex row, children will be centered vertically. If this is a
/// flex column, children will be centered horizontally.
pub fn align_children_center(mut self) -> Self {
self.child_alignment = 0.;
self
}
pub fn scrollable<Tag, V>( pub fn scrollable<Tag, V>(
mut self, mut self,
element_id: usize, element_id: usize,
@ -309,7 +320,30 @@ impl Element for Flex {
} }
} }
child.paint(child_origin, visible_bounds, cx); // We use the child_alignment f32 to determine a point along the cross axis of the
// overall flex element and each child. We then align these points. So 0 would center
// each child relative to the overall height/width of the flex. -1 puts children at
// the start. 1 puts children at the end.
let aligned_child_origin = {
let cross_axis = self.axis.invert();
let my_center = bounds.size().along(cross_axis) / 2.;
let my_target = my_center + my_center * self.child_alignment;
let child_center = child.size().along(cross_axis) / 2.;
let child_target = child_center + child_center * self.child_alignment;
let mut aligned_child_origin = child_origin;
match self.axis {
Axis::Horizontal => aligned_child_origin
.set_y(aligned_child_origin.y() - (child_target - my_target)),
Axis::Vertical => aligned_child_origin
.set_x(aligned_child_origin.x() - (child_target - my_target)),
}
aligned_child_origin
};
child.paint(aligned_child_origin, visible_bounds, cx);
match self.axis { match self.axis {
Axis::Horizontal => child_origin += vec2f(child.size().x(), 0.0), Axis::Horizontal => child_origin += vec2f(child.size().x(), 0.0),

56
crates/gpui/src/elements/image.rs
View file

@ -11,8 +11,13 @@ use crate::{
use serde::Deserialize; use serde::Deserialize;
use std::{ops::Range, sync::Arc}; use std::{ops::Range, sync::Arc};
enum ImageSource {
Path(&'static str),
Data(Arc<ImageData>),
}
pub struct Image { pub struct Image {
data: Arc<ImageData>, source: ImageSource,
style: ImageStyle, style: ImageStyle,
} }
@ -31,9 +36,16 @@ pub struct ImageStyle {
} }
impl Image { impl Image {
pub fn new(data: Arc<ImageData>) -> Self { pub fn new(asset_path: &'static str) -> Self {
Self { Self {
data, source: ImageSource::Path(asset_path),
style: Default::default(),
}
}
pub fn from_data(data: Arc<ImageData>) -> Self {
Self {
source: ImageSource::Data(data),
style: Default::default(), style: Default::default(),
} }
} }
@ -45,39 +57,53 @@ impl Image {
} }
impl Element for Image { impl Element for Image {
type LayoutState = (); type LayoutState = Option<Arc<ImageData>>;
type PaintState = (); type PaintState = ();
fn layout( fn layout(
&mut self, &mut self,
constraint: SizeConstraint, constraint: SizeConstraint,
_: &mut LayoutContext, cx: &mut LayoutContext,
) -> (Vector2F, Self::LayoutState) { ) -> (Vector2F, Self::LayoutState) {
let data = match &self.source {
ImageSource::Path(path) => match cx.asset_cache.png(path) {
Ok(data) => data,
Err(error) => {
log::error!("could not load image: {}", error);
return (Vector2F::zero(), None);
}
},
ImageSource::Data(data) => data.clone(),
};
let desired_size = vec2f( let desired_size = vec2f(
self.style.width.unwrap_or_else(|| constraint.max.x()), self.style.width.unwrap_or_else(|| constraint.max.x()),
self.style.height.unwrap_or_else(|| constraint.max.y()), self.style.height.unwrap_or_else(|| constraint.max.y()),
); );
let size = constrain_size_preserving_aspect_ratio( let size = constrain_size_preserving_aspect_ratio(
constraint.constrain(desired_size), constraint.constrain(desired_size),
self.data.size().to_f32(), data.size().to_f32(),
); );
(size, ())
(size, Some(data))
} }
fn paint( fn paint(
&mut self, &mut self,
bounds: RectF, bounds: RectF,
_: RectF, _: RectF,
_: &mut Self::LayoutState, layout: &mut Self::LayoutState,
cx: &mut PaintContext, cx: &mut PaintContext,
) -> Self::PaintState { ) -> Self::PaintState {
cx.scene.push_image(scene::Image { if let Some(data) = layout {
bounds, cx.scene.push_image(scene::Image {
border: self.style.border, bounds,
corner_radius: self.style.corner_radius, border: self.style.border,
grayscale: self.style.grayscale, corner_radius: self.style.corner_radius,
data: self.data.clone(), grayscale: self.style.grayscale,
}); data: data.clone(),
});
}
} }
fn rect_for_text_range( fn rect_for_text_range(

18
crates/install_cli/Cargo.toml Normal file
View file

@ -0,0 +1,18 @@
[package]
name = "install_cli"
version = "0.1.0"
edition = "2021"
publish = false
[lib]
path = "src/install_cli.rs"
[features]
test-support = []
[dependencies]
smol = "1.2.5"
anyhow = "1.0.38"
log = "0.4"
gpui = { path = "../gpui" }
util = { path = "../util" }

55
crates/install_cli/src/install_cli.rs Normal file
View file

@ -0,0 +1,55 @@
use std::path::Path;
use anyhow::{anyhow, Result};
use gpui::{actions, AsyncAppContext};
use util::ResultExt;
actions!(cli, [Install]);
pub async fn install_cli(cx: &AsyncAppContext) -> Result<()> {
let cli_path = cx.platform().path_for_auxiliary_executable("cli")?;
let link_path = Path::new("/usr/local/bin/zed");
let bin_dir_path = link_path.parent().unwrap();
// Don't re-create symlink if it points to the same CLI binary.
if smol::fs::read_link(link_path).await.ok().as_ref() == Some(&cli_path) {
return Ok(());
}
// If the symlink is not there or is outdated, first try replacing it
// without escalating.
smol::fs::remove_file(link_path).await.log_err();
if smol::fs::unix::symlink(&cli_path, link_path)
.await
.log_err()
.is_some()
{
return Ok(());
}
// The symlink could not be created, so use osascript with admin privileges
// to create it.
let status = smol::process::Command::new("osascript")
.args([
"-e",
&format!(
"do shell script \" \
mkdir -p \'{}\' && \
ln -sf \'{}\' \'{}\' \
\" with administrator privileges",
bin_dir_path.to_string_lossy(),
cli_path.to_string_lossy(),
link_path.to_string_lossy(),
),
])
.stdout(smol::process::Stdio::inherit())
.stderr(smol::process::Stdio::inherit())
.output()
.await?
.status;
if status.success() {
Ok(())
} else {
Err(anyhow!("error running osascript"))
}
}

2
crates/journal/src/journal.rs
View file

@ -48,7 +48,7 @@ pub fn new_journal_entry(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
async move { async move {
let (journal_dir, entry_path) = create_entry.await?; let (journal_dir, entry_path) = create_entry.await?;
let (workspace, _) = cx let (workspace, _) = cx
.update(|cx| workspace::open_paths(&[journal_dir], &app_state, cx)) .update(|cx| workspace::open_paths(&[journal_dir], &app_state, None, cx))
.await; .await;
let opened = workspace let opened = workspace

5
crates/picker/src/picker.rs
View file

@ -102,7 +102,10 @@ impl<D: PickerDelegate> View for Picker<D> {
.read(cx) .read(cx)
.render_match(ix, state, ix == selected_ix, cx) .render_match(ix, state, ix == selected_ix, cx)
}) })
.on_down(MouseButton::Left, move |_, cx| { // Capture mouse events
.on_down(MouseButton::Left, |_, _| {})
.on_up(MouseButton::Left, |_, _| {})
.on_click(MouseButton::Left, move |_, cx| {
cx.dispatch_action(SelectIndex(ix)) cx.dispatch_action(SelectIndex(ix))
}) })
.with_cursor_style(CursorStyle::PointingHand) .with_cursor_style(CursorStyle::PointingHand)

2
crates/project/src/worktree.rs
View file

@ -867,7 +867,7 @@ impl LocalWorktree {
let old_path = self.entry_for_id(entry_id)?.path.clone(); let old_path = self.entry_for_id(entry_id)?.path.clone();
let new_path = new_path.into(); let new_path = new_path.into();
let abs_old_path = self.absolutize(&old_path); let abs_old_path = self.absolutize(&old_path);
let abs_new_path = self.absolutize(&new_path); let abs_new_path = self.absolutize(new_path.as_ref());
let rename = cx.background().spawn({ let rename = cx.background().spawn({
let fs = self.fs.clone(); let fs = self.fs.clone();
let abs_new_path = abs_new_path.clone(); let abs_new_path = abs_new_path.clone();

151
crates/project_panel/src/project_panel.rs
View file

@ -1262,54 +1262,89 @@ impl View for ProjectPanel {
let padding = std::mem::take(&mut container_style.padding); let padding = std::mem::take(&mut container_style.padding);
let last_worktree_root_id = self.last_worktree_root_id; let last_worktree_root_id = self.last_worktree_root_id;
Stack::new() let has_worktree = self.visible_entries.len() != 0;
.with_child(
MouseEventHandler::<ProjectPanel>::new(0, cx, |_, cx| { if has_worktree {
UniformList::new( Stack::new()
self.list.clone(), .with_child(
self.visible_entries MouseEventHandler::<ProjectPanel>::new(0, cx, |_, cx| {
.iter() UniformList::new(
.map(|(_, worktree_entries)| worktree_entries.len()) self.list.clone(),
.sum(), self.visible_entries
cx, .iter()
move |this, range, items, cx| { .map(|(_, worktree_entries)| worktree_entries.len())
let theme = cx.global::<Settings>().theme.clone(); .sum(),
let mut dragged_entry_destination = cx,
this.dragged_entry_destination.clone(); move |this, range, items, cx| {
this.for_each_visible_entry(range, cx, |id, details, cx| { let theme = cx.global::<Settings>().theme.clone();
items.push(Self::render_entry( let mut dragged_entry_destination =
id, this.dragged_entry_destination.clone();
details, this.for_each_visible_entry(range, cx, |id, details, cx| {
&this.filename_editor, items.push(Self::render_entry(
&mut dragged_entry_destination, id,
&theme.project_panel, details,
cx, &this.filename_editor,
)); &mut dragged_entry_destination,
}); &theme.project_panel,
this.dragged_entry_destination = dragged_entry_destination; cx,
}, ));
) });
.with_padding_top(padding.top) this.dragged_entry_destination = dragged_entry_destination;
.with_padding_bottom(padding.bottom) },
.contained() )
.with_style(container_style) .with_padding_top(padding.top)
.expanded() .with_padding_bottom(padding.bottom)
.boxed() .contained()
}) .with_style(container_style)
.on_down(MouseButton::Right, move |e, cx| { .expanded()
// When deploying the context menu anywhere below the last project entry, .boxed()
// act as if the user clicked the root of the last worktree. })
if let Some(entry_id) = last_worktree_root_id { .on_down(MouseButton::Right, move |e, cx| {
cx.dispatch_action(DeployContextMenu { // When deploying the context menu anywhere below the last project entry,
entry_id, // act as if the user clicked the root of the last worktree.
position: e.position, if let Some(entry_id) = last_worktree_root_id {
}) cx.dispatch_action(DeployContextMenu {
} entry_id,
}) position: e.position,
.boxed(), })
) }
.with_child(ChildView::new(&self.context_menu, cx).boxed()) })
.boxed() .boxed(),
)
.with_child(ChildView::new(&self.context_menu, cx).boxed())
.boxed()
} else {
Flex::column()
.with_child(
MouseEventHandler::<Self>::new(2, cx, {
let button_style = theme.open_project_button.clone();
let context_menu_item_style =
cx.global::<Settings>().theme.context_menu.item.clone();
move |state, cx| {
let button_style = button_style.style_for(state, false).clone();
let context_menu_item =
context_menu_item_style.style_for(state, true).clone();
theme::ui::keystroke_label(
"Open a project",
&button_style,
&context_menu_item.keystroke,
Box::new(workspace::Open),
cx,
)
.boxed()
}
})
.on_click(MouseButton::Left, move |_, cx| {
cx.dispatch_action(workspace::Open)
})
.with_cursor_style(CursorStyle::PointingHand)
.boxed(),
)
.contained()
.with_style(container_style)
.boxed()
}
} }
fn keymap_context(&self, _: &AppContext) -> KeymapContext { fn keymap_context(&self, _: &AppContext) -> KeymapContext {
@ -1404,15 +1439,7 @@ mod tests {
.await; .await;
let project = Project::test(fs.clone(), ["/root1".as_ref(), "/root2".as_ref()], cx).await; let project = Project::test(fs.clone(), ["/root1".as_ref(), "/root2".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(
Default::default(),
0,
project.clone(),
|_, _| unimplemented!(),
cx,
)
});
let panel = workspace.update(cx, |_, cx| ProjectPanel::new(project, cx)); let panel = workspace.update(cx, |_, cx| ProjectPanel::new(project, cx));
assert_eq!( assert_eq!(
visible_entries_as_strings(&panel, 0..50, cx), visible_entries_as_strings(&panel, 0..50, cx),
@ -1504,15 +1531,7 @@ mod tests {
.await; .await;
let project = Project::test(fs.clone(), ["/root1".as_ref(), "/root2".as_ref()], cx).await; let project = Project::test(fs.clone(), ["/root1".as_ref(), "/root2".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(
Default::default(),
0,
project.clone(),
|_, _| unimplemented!(),
cx,
)
});
let panel = workspace.update(cx, |_, cx| ProjectPanel::new(project, cx)); let panel = workspace.update(cx, |_, cx| ProjectPanel::new(project, cx));
select_path(&panel, "root1", cx); select_path(&panel, "root1", cx);

6
crates/settings/src/keymap_file.rs
View file

@ -1,4 +1,4 @@
use crate::parse_json_with_comments; use crate::{parse_json_with_comments, Settings};
use anyhow::{Context, Result}; use anyhow::{Context, Result};
use assets::Assets; use assets::Assets;
use collections::BTreeMap; use collections::BTreeMap;
@ -45,6 +45,10 @@ impl KeymapFileContent {
for path in ["keymaps/default.json", "keymaps/vim.json"] { for path in ["keymaps/default.json", "keymaps/vim.json"] {
Self::load(path, cx).unwrap(); Self::load(path, cx).unwrap();
} }
if let Some(asset_path) = cx.global::<Settings>().base_keymap.asset_path() {
Self::load(asset_path, cx).log_err();
}
} }
pub fn load(asset_path: &str, cx: &mut MutableAppContext) -> Result<()> { pub fn load(asset_path: &str, cx: &mut MutableAppContext) -> Result<()> {

573
crates/settings/src/settings.rs
View file

@ -18,12 +18,13 @@ use sqlez::{
bindable::{Bind, Column, StaticColumnCount}, bindable::{Bind, Column, StaticColumnCount},
statement::Statement, statement::Statement,
}; };
use std::{collections::HashMap, fmt::Write as _, num::NonZeroU32, str, sync::Arc}; use std::{collections::HashMap, num::NonZeroU32, str, sync::Arc};
use theme::{Theme, ThemeRegistry}; use theme::{Theme, ThemeRegistry};
use tree_sitter::Query; use tree_sitter::Query;
use util::ResultExt as _; use util::ResultExt as _;
pub use keymap_file::{keymap_file_json_schema, KeymapFileContent}; pub use keymap_file::{keymap_file_json_schema, KeymapFileContent};
pub use watched_json::watch_files;
#[derive(Clone)] #[derive(Clone)]
pub struct Settings { pub struct Settings {
@ -54,6 +55,46 @@ pub struct Settings {
pub telemetry_defaults: TelemetrySettings, pub telemetry_defaults: TelemetrySettings,
pub telemetry_overrides: TelemetrySettings, pub telemetry_overrides: TelemetrySettings,
pub auto_update: bool, pub auto_update: bool,
pub base_keymap: BaseKeymap,
}
#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq, Default)]
pub enum BaseKeymap {
#[default]
VSCode,
JetBrains,
Sublime,
Atom,
}
impl BaseKeymap {
pub const OPTIONS: [(&'static str, Self); 4] = [
("VSCode (Default)", Self::VSCode),
("Atom", Self::Atom),
("JetBrains", Self::JetBrains),
("Sublime", Self::Sublime),
];
pub fn asset_path(&self) -> Option<&'static str> {
match self {
BaseKeymap::JetBrains => Some("keymaps/jetbrains.json"),
BaseKeymap::Sublime => Some("keymaps/sublime_text.json"),
BaseKeymap::Atom => Some("keymaps/atom.json"),
BaseKeymap::VSCode => None,
}
}
pub fn names() -> impl Iterator<Item = &'static str> {
Self::OPTIONS.iter().map(|(name, _)| *name)
}
pub fn from_names(option: &str) -> BaseKeymap {
Self::OPTIONS
.iter()
.copied()
.find_map(|(name, value)| (name == option).then(|| value))
.unwrap_or_default()
}
} }
#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)] #[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
@ -66,9 +107,18 @@ impl TelemetrySettings {
pub fn metrics(&self) -> bool { pub fn metrics(&self) -> bool {
self.metrics.unwrap() self.metrics.unwrap()
} }
pub fn diagnostics(&self) -> bool { pub fn diagnostics(&self) -> bool {
self.diagnostics.unwrap() self.diagnostics.unwrap()
} }
pub fn set_metrics(&mut self, value: bool) {
self.metrics = Some(value);
}
pub fn set_diagnostics(&mut self, value: bool) {
self.diagnostics = Some(value);
}
} }
#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)] #[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
@ -317,6 +367,8 @@ pub struct SettingsFileContent {
pub telemetry: TelemetrySettings, pub telemetry: TelemetrySettings,
#[serde(default)] #[serde(default)]
pub auto_update: Option<bool>, pub auto_update: Option<bool>,
#[serde(default)]
pub base_keymap: Option<BaseKeymap>,
} }
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
@ -387,6 +439,7 @@ impl Settings {
telemetry_defaults: defaults.telemetry, telemetry_defaults: defaults.telemetry,
telemetry_overrides: Default::default(), telemetry_overrides: Default::default(),
auto_update: defaults.auto_update.unwrap(), auto_update: defaults.auto_update.unwrap(),
base_keymap: Default::default(),
} }
} }
@ -424,6 +477,7 @@ impl Settings {
merge(&mut self.vim_mode, data.vim_mode); merge(&mut self.vim_mode, data.vim_mode);
merge(&mut self.autosave, data.autosave); merge(&mut self.autosave, data.autosave);
merge(&mut self.default_dock_anchor, data.default_dock_anchor); merge(&mut self.default_dock_anchor, data.default_dock_anchor);
merge(&mut self.base_keymap, data.base_keymap);
// Ensure terminal font is loaded, so we can request it in terminal_element layout // Ensure terminal font is loaded, so we can request it in terminal_element layout
if let Some(terminal_font) = &data.terminal.font_family { if let Some(terminal_font) = &data.terminal.font_family {
@ -601,6 +655,7 @@ impl Settings {
}, },
telemetry_overrides: Default::default(), telemetry_overrides: Default::default(),
auto_update: true, auto_update: true,
base_keymap: Default::default(),
} }
} }
@ -677,13 +732,19 @@ pub fn settings_file_json_schema(
serde_json::to_value(root_schema).unwrap() serde_json::to_value(root_schema).unwrap()
} }
/// Expects the key to be unquoted, and the value to be valid JSON fn merge<T: Copy>(target: &mut T, value: Option<T>) {
/// (e.g. values should be unquoted for numbers and bools, quoted for strings) if let Some(value) = value {
pub fn write_top_level_setting( *target = value;
mut settings_content: String, }
top_level_key: &str, }
new_val: &str,
) -> String { pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
Ok(serde_json::from_reader(
json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
)?)
}
fn write_settings_key(settings_content: &mut String, key_path: &[&str], new_value: &Value) {
let mut parser = tree_sitter::Parser::new(); let mut parser = tree_sitter::Parser::new();
parser.set_language(tree_sitter_json::language()).unwrap(); parser.set_language(tree_sitter_json::language()).unwrap();
let tree = parser.parse(&settings_content, None).unwrap(); let tree = parser.parse(&settings_content, None).unwrap();
@ -693,56 +754,64 @@ pub fn write_top_level_setting(
let query = Query::new( let query = Query::new(
tree_sitter_json::language(), tree_sitter_json::language(),
" "
(document (pair
(object key: (string) @key
(pair value: (_) @value)
key: (string) @key ",
value: (_) @value)))
",
) )
.unwrap(); .unwrap();
let mut depth = 0;
let mut first_key_start = None; let mut first_key_start = None;
let mut existing_value_range = None; let mut existing_value_range = 0..settings_content.len();
let matches = cursor.matches(&query, tree.root_node(), settings_content.as_bytes()); let matches = cursor.matches(&query, tree.root_node(), settings_content.as_bytes());
for mat in matches { for mat in matches {
if mat.captures.len() != 2 { if mat.captures.len() != 2 {
continue; continue;
} }
let key = mat.captures[0]; let key_range = mat.captures[0].node.byte_range();
let value = mat.captures[1]; let value_range = mat.captures[1].node.byte_range();
first_key_start.get_or_insert_with(|| key.node.start_byte()); if key_range.start > existing_value_range.end {
break;
}
if let Some(key_text) = settings_content.get(key.node.byte_range()) { first_key_start.get_or_insert_with(|| key_range.start);
if key_text == format!("\"{top_level_key}\"") {
existing_value_range = Some(value.node.byte_range()); let found_key = settings_content
.get(key_range.clone())
.map(|key_text| key_text == format!("\"{}\"", key_path[depth]))
.unwrap_or(false);
if found_key {
existing_value_range = value_range;
depth += 1;
if depth == key_path.len() {
break; break;
} else {
first_key_start = None;
} }
} }
} }
match (first_key_start, existing_value_range) { // We found the exact key we want, insert the new value
(None, None) => { if depth == key_path.len() {
// No document, create a new object and overwrite let new_val = serde_json::to_string_pretty(new_value)
settings_content.clear(); .expect("Could not serialize new json field to string");
write!( settings_content.replace_range(existing_value_range, &new_val);
settings_content, } else {
"{{\n \"{}\": {new_val}\n}}\n", // We have key paths, construct the sub objects
top_level_key let new_key = key_path[depth];
)
.unwrap(); // We don't have the key, construct the nested objects
let mut new_value = serde_json::to_value(new_value).unwrap();
for key in key_path[(depth + 1)..].iter().rev() {
new_value = serde_json::json!({ key.to_string(): new_value });
} }
(_, Some(existing_value_range)) => { if let Some(first_key_start) = first_key_start {
// Existing theme key, overwrite
settings_content.replace_range(existing_value_range, &new_val);
}
(Some(first_key_start), None) => {
// No existing theme key, but other settings. Prepend new theme settings and
// match style of first key
let mut row = 0; let mut row = 0;
let mut column = 0; let mut column = 0;
for (ix, char) in settings_content.char_indices() { for (ix, char) in settings_content.char_indices() {
@ -757,142 +826,374 @@ pub fn write_top_level_setting(
} }
} }
let content = format!(r#""{top_level_key}": {new_val},"#);
settings_content.insert_str(first_key_start, &content);
if row > 0 { if row > 0 {
let new_val = to_pretty_json(&new_value, column, column);
let content = format!(r#""{new_key}": {new_val},"#);
settings_content.insert_str(first_key_start, &content);
settings_content.insert_str( settings_content.insert_str(
first_key_start + content.len(), first_key_start + content.len(),
&format!("\n{:width$}", ' ', width = column), &format!("\n{:width$}", ' ', width = column),
) )
} else { } else {
settings_content.insert_str(first_key_start + content.len(), " ") let new_val = serde_json::to_string(&new_value).unwrap();
let mut content = format!(r#""{new_key}": {new_val},"#);
content.push(' ');
settings_content.insert_str(first_key_start, &content);
}
} else {
new_value = serde_json::json!({ new_key.to_string(): new_value });
let indent_prefix_len = 4 * depth;
let new_val = to_pretty_json(&new_value, 4, indent_prefix_len);
settings_content.replace_range(existing_value_range, &new_val);
if depth == 0 {
settings_content.push('\n');
}
}
}
}
fn to_pretty_json(
value: &serde_json::Value,
indent_size: usize,
indent_prefix_len: usize,
) -> String {
const SPACES: [u8; 32] = [b' '; 32];
debug_assert!(indent_size <= SPACES.len());
debug_assert!(indent_prefix_len <= SPACES.len());
let mut output = Vec::new();
let mut ser = serde_json::Serializer::with_formatter(
&mut output,
serde_json::ser::PrettyFormatter::with_indent(&SPACES[0..indent_size.min(SPACES.len())]),
);
value.serialize(&mut ser).unwrap();
let text = String::from_utf8(output).unwrap();
let mut adjusted_text = String::new();
for (i, line) in text.split('\n').enumerate() {
if i > 0 {
adjusted_text.push_str(str::from_utf8(&SPACES[0..indent_prefix_len]).unwrap());
}
adjusted_text.push_str(line);
adjusted_text.push('\n');
}
adjusted_text.pop();
adjusted_text
}
pub fn update_settings_file(
mut text: String,
old_file_content: SettingsFileContent,
update: impl FnOnce(&mut SettingsFileContent),
) -> String {
let mut new_file_content = old_file_content.clone();
update(&mut new_file_content);
let old_object = to_json_object(old_file_content);
let new_object = to_json_object(new_file_content);
fn apply_changes_to_json_text(
old_object: &serde_json::Map<String, Value>,
new_object: &serde_json::Map<String, Value>,
current_key_path: Vec<&str>,
json_text: &mut String,
) {
for (key, old_value) in old_object.iter() {
// We know that these two are from the same shape of object, so we can just unwrap
let new_value = new_object.get(key).unwrap();
if old_value != new_value {
match new_value {
Value::Bool(_) | Value::Number(_) | Value::String(_) => {
let mut key_path = current_key_path.clone();
key_path.push(key);
write_settings_key(json_text, &key_path, &new_value);
}
Value::Object(new_sub_object) => {
let mut key_path = current_key_path.clone();
key_path.push(key);
if let Value::Object(old_sub_object) = old_value {
apply_changes_to_json_text(
old_sub_object,
new_sub_object,
key_path,
json_text,
);
} else {
unimplemented!("This function doesn't support changing values from simple values to objects yet");
}
}
Value::Null | Value::Array(_) => {
unimplemented!("We only support objects and simple values");
}
}
} }
} }
} }
settings_content apply_changes_to_json_text(&old_object, &new_object, vec![], &mut text);
text
} }
fn merge<T: Copy>(target: &mut T, value: Option<T>) { fn to_json_object(settings_file: SettingsFileContent) -> serde_json::Map<String, Value> {
if let Some(value) = value { let tmp = serde_json::to_value(settings_file).unwrap();
*target = value; match tmp {
Value::Object(map) => map,
_ => unreachable!("SettingsFileContent represents a JSON map"),
} }
} }
pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
Ok(serde_json::from_reader(
json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
)?)
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::write_top_level_setting; use super::*;
use unindent::Unindent; use unindent::Unindent;
fn assert_new_settings<S1: Into<String>, S2: Into<String>>(
old_json: S1,
update: fn(&mut SettingsFileContent),
expected_new_json: S2,
) {
let old_json = old_json.into();
let old_content: SettingsFileContent = serde_json::from_str(&old_json).unwrap_or_default();
let new_json = update_settings_file(old_json, old_content, update);
assert_eq!(new_json, expected_new_json.into());
}
#[test]
fn test_update_telemetry_setting_multiple_fields() {
assert_new_settings(
r#"
{
"telemetry": {
"metrics": false,
"diagnostics": false
}
}
"#
.unindent(),
|settings| {
settings.telemetry.set_diagnostics(true);
settings.telemetry.set_metrics(true);
},
r#"
{
"telemetry": {
"metrics": true,
"diagnostics": true
}
}
"#
.unindent(),
);
}
#[test]
fn test_update_telemetry_setting_weird_formatting() {
assert_new_settings(
r#"{
"telemetry": { "metrics": false, "diagnostics": true }
}"#
.unindent(),
|settings| settings.telemetry.set_diagnostics(false),
r#"{
"telemetry": { "metrics": false, "diagnostics": false }
}"#
.unindent(),
);
}
#[test]
fn test_update_telemetry_setting_other_fields() {
assert_new_settings(
r#"
{
"telemetry": {
"metrics": false,
"diagnostics": true
}
}
"#
.unindent(),
|settings| settings.telemetry.set_diagnostics(false),
r#"
{
"telemetry": {
"metrics": false,
"diagnostics": false
}
}
"#
.unindent(),
);
}
#[test]
fn test_update_telemetry_setting_empty_telemetry() {
assert_new_settings(
r#"
{
"telemetry": {}
}
"#
.unindent(),
|settings| settings.telemetry.set_diagnostics(false),
r#"
{
"telemetry": {
"diagnostics": false
}
}
"#
.unindent(),
);
}
#[test]
fn test_update_telemetry_setting_pre_existing() {
assert_new_settings(
r#"
{
"telemetry": {
"diagnostics": true
}
}
"#
.unindent(),
|settings| settings.telemetry.set_diagnostics(false),
r#"
{
"telemetry": {
"diagnostics": false
}
}
"#
.unindent(),
);
}
#[test]
fn test_update_telemetry_setting() {
assert_new_settings(
"{}",
|settings| settings.telemetry.set_diagnostics(true),
r#"
{
"telemetry": {
"diagnostics": true
}
}
"#
.unindent(),
);
}
#[test]
fn test_update_object_empty_doc() {
assert_new_settings(
"",
|settings| settings.telemetry.set_diagnostics(true),
r#"
{
"telemetry": {
"diagnostics": true
}
}
"#
.unindent(),
);
}
#[test] #[test]
fn test_write_theme_into_settings_with_theme() { fn test_write_theme_into_settings_with_theme() {
let settings = r#" assert_new_settings(
{ r#"
"theme": "One Dark" {
} "theme": "One Dark"
"# }
.unindent(); "#
.unindent(),
let new_settings = r#" |settings| settings.theme = Some("summerfruit-light".to_string()),
{ r#"
"theme": "summerfruit-light" {
} "theme": "summerfruit-light"
"# }
.unindent(); "#
.unindent(),
let settings_after_theme = );
write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
assert_eq!(settings_after_theme, new_settings)
} }
#[test] #[test]
fn test_write_theme_into_empty_settings() { fn test_write_theme_into_empty_settings() {
let settings = r#" assert_new_settings(
{ r#"
} {
"# }
.unindent(); "#
.unindent(),
let new_settings = r#" |settings| settings.theme = Some("summerfruit-light".to_string()),
{ r#"
"theme": "summerfruit-light" {
} "theme": "summerfruit-light"
"# }
.unindent(); "#
.unindent(),
let settings_after_theme = );
write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
assert_eq!(settings_after_theme, new_settings)
} }
#[test] #[test]
fn test_write_theme_into_no_settings() { fn write_key_no_document() {
let settings = "".to_string(); assert_new_settings(
"",
let new_settings = r#" |settings| settings.theme = Some("summerfruit-light".to_string()),
{ r#"
"theme": "summerfruit-light" {
} "theme": "summerfruit-light"
"# }
.unindent(); "#
.unindent(),
let settings_after_theme = );
write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
assert_eq!(settings_after_theme, new_settings)
} }
#[test] #[test]
fn test_write_theme_into_single_line_settings_without_theme() { fn test_write_theme_into_single_line_settings_without_theme() {
let settings = r#"{ "a": "", "ok": true }"#.to_string(); assert_new_settings(
let new_settings = r#"{ "theme": "summerfruit-light", "a": "", "ok": true }"#; r#"{ "a": "", "ok": true }"#,
|settings| settings.theme = Some("summerfruit-light".to_string()),
let settings_after_theme = r#"{ "theme": "summerfruit-light", "a": "", "ok": true }"#,
write_top_level_setting(settings, "theme", "\"summerfruit-light\""); );
assert_eq!(settings_after_theme, new_settings)
} }
#[test] #[test]
fn test_write_theme_pre_object_whitespace() { fn test_write_theme_pre_object_whitespace() {
let settings = r#" { "a": "", "ok": true }"#.to_string(); assert_new_settings(
let new_settings = r#" { "theme": "summerfruit-light", "a": "", "ok": true }"#; r#" { "a": "", "ok": true }"#,
|settings| settings.theme = Some("summerfruit-light".to_string()),
let settings_after_theme = r#" { "theme": "summerfruit-light", "a": "", "ok": true }"#.unindent(),
write_top_level_setting(settings, "theme", "\"summerfruit-light\""); );
assert_eq!(settings_after_theme, new_settings)
} }
#[test] #[test]
fn test_write_theme_into_multi_line_settings_without_theme() { fn test_write_theme_into_multi_line_settings_without_theme() {
let settings = r#" assert_new_settings(
{ r#"
"a": "b" {
} "a": "b"
"# }
.unindent(); "#
.unindent(),
let new_settings = r#" |settings| settings.theme = Some("summerfruit-light".to_string()),
{ r#"
"theme": "summerfruit-light", {
"a": "b" "theme": "summerfruit-light",
} "a": "b"
"# }
.unindent(); "#
.unindent(),
let settings_after_theme = );
write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
assert_eq!(settings_after_theme, new_settings)
} }
} }

206
crates/settings/src/settings_file.rs
View file

@ -1,8 +1,7 @@
use crate::{watched_json::WatchedJsonFile, write_top_level_setting, SettingsFileContent}; use crate::{update_settings_file, watched_json::WatchedJsonFile, SettingsFileContent};
use anyhow::Result; use anyhow::Result;
use fs::Fs; use fs::Fs;
use gpui::MutableAppContext; use gpui::MutableAppContext;
use serde_json::Value;
use std::{path::Path, sync::Arc}; use std::{path::Path, sync::Arc};
// TODO: Switch SettingsFile to open a worktree and buffer for synchronization // TODO: Switch SettingsFile to open a worktree and buffer for synchronization
@ -27,57 +26,24 @@ impl SettingsFile {
} }
} }
pub fn update(cx: &mut MutableAppContext, update: impl FnOnce(&mut SettingsFileContent)) { pub fn update(
cx: &mut MutableAppContext,
update: impl 'static + Send + FnOnce(&mut SettingsFileContent),
) {
let this = cx.global::<SettingsFile>(); let this = cx.global::<SettingsFile>();
let current_file_content = this.settings_file_content.current(); let current_file_content = this.settings_file_content.current();
let mut new_file_content = current_file_content.clone();
update(&mut new_file_content);
let fs = this.fs.clone(); let fs = this.fs.clone();
let path = this.path.clone(); let path = this.path.clone();
cx.background() cx.background()
.spawn(async move { .spawn(async move {
// Unwrap safety: These values are all guarnteed to be well formed, and we know let old_text = fs.load(path).await?;
// that they will deserialize to our settings object. All of the following unwraps
// are therefore safe.
let tmp = serde_json::to_value(current_file_content).unwrap();
let old_json = tmp.as_object().unwrap();
let new_tmp = serde_json::to_value(new_file_content).unwrap(); let new_text = update_settings_file(old_text, current_file_content, update);
let new_json = new_tmp.as_object().unwrap();
// Find changed fields fs.atomic_write(path.to_path_buf(), new_text).await?;
let mut diffs = vec![];
for (key, old_value) in old_json.iter() {
let new_value = new_json.get(key).unwrap();
if old_value != new_value {
if matches!(
new_value,
&Value::Null | &Value::Object(_) | &Value::Array(_)
) {
unimplemented!(
"We only support updating basic values at the top level"
);
}
let new_json = serde_json::to_string_pretty(new_value)
.expect("Could not serialize new json field to string");
diffs.push((key, new_json));
}
}
// Have diffs, rewrite the settings file now.
let mut content = fs.load(path).await?;
for (key, new_value) in diffs {
content = write_top_level_setting(content, key, &new_value)
}
fs.atomic_write(path.to_path_buf(), content).await?;
Ok(()) as Result<()> Ok(()) as Result<()>
}) })
@ -88,10 +54,164 @@ impl SettingsFile {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::{watched_json::watch_settings_file, EditorSettings, Settings, SoftWrap}; use crate::{
watch_files, watched_json::watch_settings_file, EditorSettings, Settings, SoftWrap,
};
use fs::FakeFs; use fs::FakeFs;
use gpui::{actions, Action};
use theme::ThemeRegistry; use theme::ThemeRegistry;
#[gpui::test]
async fn test_base_keymap(cx: &mut gpui::TestAppContext) {
let executor = cx.background();
let fs = FakeFs::new(executor.clone());
let font_cache = cx.font_cache();
actions!(test, [A, B]);
// From the Atom keymap
actions!(workspace, [ActivatePreviousPane]);
// From the JetBrains keymap
actions!(pane, [ActivatePrevItem]);
fs.save(
"/settings.json".as_ref(),
&r#"
{
"base_keymap": "Atom"
}
"#
.into(),
Default::default(),
)
.await
.unwrap();
fs.save(
"/keymap.json".as_ref(),
&r#"
[
{
"bindings": {
"backspace": "test::A"
}
}
]
"#
.into(),
Default::default(),
)
.await
.unwrap();
let settings_file =
WatchedJsonFile::new(fs.clone(), &executor, "/settings.json".as_ref()).await;
let keymaps_file =
WatchedJsonFile::new(fs.clone(), &executor, "/keymap.json".as_ref()).await;
let default_settings = cx.read(Settings::test);
cx.update(|cx| {
cx.add_global_action(|_: &A, _cx| {});
cx.add_global_action(|_: &B, _cx| {});
cx.add_global_action(|_: &ActivatePreviousPane, _cx| {});
cx.add_global_action(|_: &ActivatePrevItem, _cx| {});
watch_files(
default_settings,
settings_file,
ThemeRegistry::new((), font_cache),
keymaps_file,
cx,
)
});
cx.foreground().run_until_parked();
// Test loading the keymap base at all
cx.update(|cx| {
assert_keybindings_for(
cx,
vec![("backspace", &A), ("k", &ActivatePreviousPane)],
line!(),
);
});
// Test modifying the users keymap, while retaining the base keymap
fs.save(
"/keymap.json".as_ref(),
&r#"
[
{
"bindings": {
"backspace": "test::B"
}
}
]
"#
.into(),
Default::default(),
)
.await
.unwrap();
cx.foreground().run_until_parked();
cx.update(|cx| {
assert_keybindings_for(
cx,
vec![("backspace", &B), ("k", &ActivatePreviousPane)],
line!(),
);
});
// Test modifying the base, while retaining the users keymap
fs.save(
"/settings.json".as_ref(),
&r#"
{
"base_keymap": "JetBrains"
}
"#
.into(),
Default::default(),
)
.await
.unwrap();
cx.foreground().run_until_parked();
cx.update(|cx| {
assert_keybindings_for(
cx,
vec![("backspace", &B), ("[", &ActivatePrevItem)],
line!(),
);
});
}
fn assert_keybindings_for<'a>(
cx: &mut MutableAppContext,
actions: Vec<(&'static str, &'a dyn Action)>,
line: u32,
) {
for (key, action) in actions {
// assert that...
assert!(
cx.available_actions(0, 0).any(|(_, bound_action, b)| {
// action names match...
bound_action.name() == action.name()
&& bound_action.namespace() == action.namespace()
// and key strokes contain the given key
&& b.iter()
.any(|binding| binding.keystrokes().iter().any(|k| k.key == key))
}),
"On {} Failed to find {} with keybinding {}",
line,
action.name(),
key
);
}
}
#[gpui::test] #[gpui::test]
async fn test_watch_settings_files(cx: &mut gpui::TestAppContext) { async fn test_watch_settings_files(cx: &mut gpui::TestAppContext) {
let executor = cx.background(); let executor = cx.background();

31
crates/settings/src/watched_json.rs
View file

@ -62,7 +62,18 @@ where
} }
} }
pub fn watch_settings_file( pub fn watch_files(
defaults: Settings,
settings_file: WatchedJsonFile<SettingsFileContent>,
theme_registry: Arc<ThemeRegistry>,
keymap_file: WatchedJsonFile<KeymapFileContent>,
cx: &mut MutableAppContext,
) {
watch_settings_file(defaults, settings_file, theme_registry, cx);
watch_keymap_file(keymap_file, cx);
}
pub(crate) fn watch_settings_file(
defaults: Settings, defaults: Settings,
mut file: WatchedJsonFile<SettingsFileContent>, mut file: WatchedJsonFile<SettingsFileContent>,
theme_registry: Arc<ThemeRegistry>, theme_registry: Arc<ThemeRegistry>,
@ -77,13 +88,13 @@ pub fn watch_settings_file(
.detach(); .detach();
} }
pub fn keymap_updated(content: KeymapFileContent, cx: &mut MutableAppContext) { fn keymap_updated(content: KeymapFileContent, cx: &mut MutableAppContext) {
cx.clear_bindings(); cx.clear_bindings();
KeymapFileContent::load_defaults(cx); KeymapFileContent::load_defaults(cx);
content.add_to_cx(cx).log_err(); content.add_to_cx(cx).log_err();
} }
pub fn settings_updated( fn settings_updated(
defaults: &Settings, defaults: &Settings,
content: SettingsFileContent, content: SettingsFileContent,
theme_registry: &Arc<ThemeRegistry>, theme_registry: &Arc<ThemeRegistry>,
@ -95,10 +106,20 @@ pub fn settings_updated(
cx.refresh_windows(); cx.refresh_windows();
} }
pub fn watch_keymap_file(mut file: WatchedJsonFile<KeymapFileContent>, cx: &mut MutableAppContext) { fn watch_keymap_file(mut file: WatchedJsonFile<KeymapFileContent>, cx: &mut MutableAppContext) {
cx.spawn(|mut cx| async move { cx.spawn(|mut cx| async move {
let mut settings_subscription = None;
while let Some(content) = file.0.recv().await { while let Some(content) = file.0.recv().await {
cx.update(|cx| keymap_updated(content, cx)); cx.update(|cx| {
let old_base_keymap = cx.global::<Settings>().base_keymap;
keymap_updated(content.clone(), cx);
settings_subscription = Some(cx.observe_global::<Settings, _>(move |cx| {
let settings = cx.global::<Settings>();
if settings.base_keymap != old_base_keymap {
keymap_updated(content.clone(), cx);
}
}));
});
} }
}) })
.detach(); .detach();

2
crates/terminal_view/src/terminal_element.rs
View file

@ -720,7 +720,7 @@ impl Element for TerminalElement {
cx.paint_layer(clip_bounds, |cx| { cx.paint_layer(clip_bounds, |cx| {
let origin = bounds.origin() + vec2f(layout.size.cell_width, 0.); let origin = bounds.origin() + vec2f(layout.size.cell_width, 0.);
//Elements are ephemeral, only at paint time do we know what could be clicked by a mouse // Elements are ephemeral, only at paint time do we know what could be clicked by a mouse
self.attach_mouse_handlers(origin, self.view.id(), visible_bounds, layout.mode, cx); self.attach_mouse_handlers(origin, self.view.id(), visible_bounds, layout.mode, cx);
cx.scene.push_cursor_region(gpui::CursorRegion { cx.scene.push_cursor_region(gpui::CursorRegion {

10
crates/terminal_view/src/terminal_view.rs
View file

@ -970,15 +970,7 @@ mod tests {
let params = cx.update(AppState::test); let params = cx.update(AppState::test);
let project = Project::test(params.fs.clone(), [], cx).await; let project = Project::test(params.fs.clone(), [], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(
Default::default(),
0,
project.clone(),
|_, _| unimplemented!(),
cx,
)
});
(project, workspace) (project, workspace)
} }

32
crates/theme/src/theme.rs
View file

@ -9,6 +9,9 @@ use gpui::{
use serde::{de::DeserializeOwned, Deserialize}; use serde::{de::DeserializeOwned, Deserialize};
use serde_json::Value; use serde_json::Value;
use std::{collections::HashMap, sync::Arc}; use std::{collections::HashMap, sync::Arc};
use ui::{CheckboxStyle, IconStyle};
pub mod ui;
pub use theme_registry::*; pub use theme_registry::*;
@ -37,6 +40,7 @@ pub struct Theme {
pub tooltip: TooltipStyle, pub tooltip: TooltipStyle,
pub terminal: TerminalStyle, pub terminal: TerminalStyle,
pub feedback: FeedbackStyle, pub feedback: FeedbackStyle,
pub welcome: WelcomeStyle,
pub color_scheme: ColorScheme, pub color_scheme: ColorScheme,
} }
@ -49,6 +53,7 @@ pub struct ThemeMeta {
#[derive(Deserialize, Default)] #[derive(Deserialize, Default)]
pub struct Workspace { pub struct Workspace {
pub background: Color, pub background: Color,
pub blank_pane: BlankPaneStyle,
pub titlebar: Titlebar, pub titlebar: Titlebar,
pub tab_bar: TabBar, pub tab_bar: TabBar,
pub pane_divider: Border, pub pane_divider: Border,
@ -68,6 +73,16 @@ pub struct Workspace {
pub drop_target_overlay_color: Color, pub drop_target_overlay_color: Color,
} }
#[derive(Clone, Deserialize, Default)]
pub struct BlankPaneStyle {
pub logo: IconStyle,
pub logo_shadow: IconStyle,
pub logo_container: ContainerStyle,
pub keyboard_hints: ContainerStyle,
pub keyboard_hint: Interactive<ContainedText>,
pub keyboard_hint_width: f32,
}
#[derive(Clone, Deserialize, Default)] #[derive(Clone, Deserialize, Default)]
pub struct Titlebar { pub struct Titlebar {
#[serde(flatten)] #[serde(flatten)]
@ -345,6 +360,7 @@ pub struct ProjectPanel {
pub cut_entry: Interactive<ProjectPanelEntry>, pub cut_entry: Interactive<ProjectPanelEntry>,
pub filename_editor: FieldEditor, pub filename_editor: FieldEditor,
pub indent_width: f32, pub indent_width: f32,
pub open_project_button: Interactive<ContainedText>,
} }
#[derive(Clone, Debug, Deserialize, Default)] #[derive(Clone, Debug, Deserialize, Default)]
@ -850,13 +866,25 @@ pub struct FeedbackStyle {
pub link_text_hover: ContainedText, pub link_text_hover: ContainedText,
} }
#[derive(Clone, Deserialize, Default)]
pub struct WelcomeStyle {
pub page_width: f32,
pub logo: IconStyle,
pub logo_subheading: ContainedText,
pub usage_note: ContainedText,
pub checkbox: CheckboxStyle,
pub checkbox_container: ContainerStyle,
pub button: Interactive<ContainedText>,
pub button_group: ContainerStyle,
pub heading_group: ContainerStyle,
pub checkbox_group: ContainerStyle,
}
#[derive(Clone, Deserialize, Default)] #[derive(Clone, Deserialize, Default)]
pub struct ColorScheme { pub struct ColorScheme {
pub name: String, pub name: String,
pub is_light: bool, pub is_light: bool,
pub ramps: RampSet, pub ramps: RampSet,
pub lowest: Layer, pub lowest: Layer,
pub middle: Layer, pub middle: Layer,
pub highest: Layer, pub highest: Layer,

149
crates/theme/src/ui.rs Normal file
View file

@ -0,0 +1,149 @@
use gpui::{
color::Color,
elements::{
ConstrainedBox, Container, ContainerStyle, Empty, Flex, KeystrokeLabel, Label,
MouseEventHandler, ParentElement, Svg,
},
Action, Element, ElementBox, EventContext, RenderContext, View,
};
use serde::Deserialize;
use crate::ContainedText;
#[derive(Clone, Deserialize, Default)]
pub struct CheckboxStyle {
pub icon: IconStyle,
pub label: ContainedText,
pub default: ContainerStyle,
pub checked: ContainerStyle,
pub hovered: ContainerStyle,
pub hovered_and_checked: ContainerStyle,
}
pub fn checkbox<T: 'static, V: View>(
label: &'static str,
style: &CheckboxStyle,
checked: bool,
cx: &mut RenderContext<V>,
change: fn(checked: bool, cx: &mut EventContext) -> (),
) -> MouseEventHandler<T> {
let label = Label::new(label, style.label.text.clone())
.contained()
.with_style(style.label.container)
.boxed();
checkbox_with_label(label, style, checked, cx, change)
}
pub fn checkbox_with_label<T: 'static, V: View>(
label: ElementBox,
style: &CheckboxStyle,
checked: bool,
cx: &mut RenderContext<V>,
change: fn(checked: bool, cx: &mut EventContext) -> (),
) -> MouseEventHandler<T> {
MouseEventHandler::<T>::new(0, cx, |state, _| {
let indicator = if checked {
icon(&style.icon)
} else {
Empty::new()
.constrained()
.with_width(style.icon.dimensions.width)
.with_height(style.icon.dimensions.height)
};
Flex::row()
.with_children([
indicator
.contained()
.with_style(if checked {
if state.hovered() {
style.hovered_and_checked
} else {
style.checked
}
} else {
if state.hovered() {
style.hovered
} else {
style.default
}
})
.boxed(),
label,
])
.align_children_center()
.boxed()
})
.on_click(gpui::MouseButton::Left, move |_, cx| change(!checked, cx))
.with_cursor_style(gpui::CursorStyle::PointingHand)
}
#[derive(Clone, Deserialize, Default)]
pub struct IconStyle {
pub color: Color,
pub icon: String,
pub dimensions: Dimensions,
}
#[derive(Clone, Deserialize, Default)]
pub struct Dimensions {
pub width: f32,
pub height: f32,
}
pub fn icon(style: &IconStyle) -> ConstrainedBox {
Svg::new(style.icon.clone())
.with_color(style.color)
.constrained()
.with_width(style.dimensions.width)
.with_height(style.dimensions.height)
}
pub fn keystroke_label<V: View>(
label_text: &'static str,
label_style: &ContainedText,
keystroke_style: &ContainedText,
action: Box<dyn Action>,
cx: &mut RenderContext<V>,
) -> Container {
// FIXME: Put the theme in it's own global so we can
// query the keystroke style on our own
keystroke_label_for(
cx.window_id(),
cx.handle().id(),
label_text,
label_style,
keystroke_style,
action,
)
}
pub fn keystroke_label_for(
window_id: usize,
view_id: usize,
label_text: &'static str,
label_style: &ContainedText,
keystroke_style: &ContainedText,
action: Box<dyn Action>,
) -> Container {
Flex::row()
.with_child(
Label::new(label_text, label_style.text.clone())
.contained()
.boxed(),
)
.with_child({
KeystrokeLabel::new(
window_id,
view_id,
action,
keystroke_style.container,
keystroke_style.text.clone(),
)
.flex_float()
.boxed()
})
.contained()
.with_style(label_style.container)
}

7
crates/theme_selector/src/theme_selector.rs
View file

@ -47,12 +47,7 @@ impl ThemeSelector {
let mut theme_names = registry let mut theme_names = registry
.list(**cx.default_global::<StaffMode>()) .list(**cx.default_global::<StaffMode>())
.collect::<Vec<_>>(); .collect::<Vec<_>>();
theme_names.sort_unstable_by(|a, b| { theme_names.sort_unstable_by(|a, b| a.is_light.cmp(&b.is_light).then(a.name.cmp(&b.name)));
a.is_light
.cmp(&b.is_light)
.reverse()
.then(a.name.cmp(&b.name))
});
let matches = theme_names let matches = theme_names
.iter() .iter()
.map(|meta| StringMatch { .map(|meta| StringMatch {

27
crates/welcome/Cargo.toml Normal file
View file

@ -0,0 +1,27 @@
[package]
name = "welcome"
version = "0.1.0"
edition = "2021"
publish = false
[lib]
path = "src/welcome.rs"
[features]
test-support = []
[dependencies]
anyhow = "1.0.38"
log = "0.4"
editor = { path = "../editor" }
fuzzy = { path = "../fuzzy" }
gpui = { path = "../gpui" }
db = { path = "../db" }
install_cli = { path = "../install_cli" }
project = { path = "../project" }
settings = { path = "../settings" }
theme = { path = "../theme" }
theme_selector = { path = "../theme_selector" }
util = { path = "../util" }
picker = { path = "../picker" }
workspace = { path = "../workspace" }

175
crates/welcome/src/base_keymap_picker.rs Normal file
View file

@ -0,0 +1,175 @@
use fuzzy::{match_strings, StringMatch, StringMatchCandidate};
use gpui::{
actions,
elements::{ChildView, Element as _, Label},
AnyViewHandle, Entity, MutableAppContext, View, ViewContext, ViewHandle,
};
use picker::{Picker, PickerDelegate};
use settings::{settings_file::SettingsFile, BaseKeymap, Settings};
use workspace::Workspace;
pub struct BaseKeymapSelector {
matches: Vec<StringMatch>,
picker: ViewHandle<Picker<Self>>,
selected_index: usize,
}
actions!(welcome, [ToggleBaseKeymapSelector]);
pub fn init(cx: &mut MutableAppContext) {
Picker::<BaseKeymapSelector>::init(cx);
cx.add_action({
move |workspace, _: &ToggleBaseKeymapSelector, cx| BaseKeymapSelector::toggle(workspace, cx)
});
}
pub enum Event {
Dismissed,
}
impl BaseKeymapSelector {
fn toggle(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
workspace.toggle_modal(cx, |_, cx| {
let this = cx.add_view(|cx| Self::new(cx));
cx.subscribe(&this, Self::on_event).detach();
this
});
}
fn new(cx: &mut ViewContext<Self>) -> Self {
let base = cx.global::<Settings>().base_keymap;
let selected_index = BaseKeymap::OPTIONS
.iter()
.position(|(_, value)| *value == base)
.unwrap_or(0);
let this = cx.weak_handle();
Self {
picker: cx.add_view(|cx| Picker::new("Select a base keymap", this, cx)),
matches: Vec::new(),
selected_index,
}
}
fn on_event(
workspace: &mut Workspace,
_: ViewHandle<BaseKeymapSelector>,
event: &Event,
cx: &mut ViewContext<Workspace>,
) {
match event {
Event::Dismissed => {
workspace.dismiss_modal(cx);
}
}
}
}
impl Entity for BaseKeymapSelector {
type Event = Event;
}
impl View for BaseKeymapSelector {
fn ui_name() -> &'static str {
"BaseKeymapSelector"
}
fn render(&mut self, cx: &mut gpui::RenderContext<'_, Self>) -> gpui::ElementBox {
ChildView::new(self.picker.clone(), cx).boxed()
}
fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.picker);
}
}
}
impl PickerDelegate for BaseKeymapSelector {
fn match_count(&self) -> usize {
self.matches.len()
}
fn selected_index(&self) -> usize {
self.selected_index
}
fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Self>) {
self.selected_index = ix;
}
fn update_matches(&mut self, query: String, cx: &mut ViewContext<Self>) -> gpui::Task<()> {
let background = cx.background().clone();
let candidates = BaseKeymap::names()
.enumerate()
.map(|(id, name)| StringMatchCandidate {
id,
char_bag: name.into(),
string: name.into(),
})
.collect::<Vec<_>>();
cx.spawn(|this, mut cx| async move {
let matches = if query.is_empty() {
candidates
.into_iter()
.enumerate()
.map(|(index, candidate)| StringMatch {
candidate_id: index,
string: candidate.string,
positions: Vec::new(),
score: 0.0,
})
.collect()
} else {
match_strings(
&candidates,
&query,
false,
100,
&Default::default(),
background,
)
.await
};
this.update(&mut cx, |this, cx| {
this.matches = matches;
this.selected_index = this
.selected_index
.min(this.matches.len().saturating_sub(1));
cx.notify();
});
})
}
fn confirm(&mut self, cx: &mut ViewContext<Self>) {
if let Some(selection) = self.matches.get(self.selected_index) {
let base_keymap = BaseKeymap::from_names(&selection.string);
SettingsFile::update(cx, move |settings| settings.base_keymap = Some(base_keymap));
}
cx.emit(Event::Dismissed);
}
fn dismiss(&mut self, cx: &mut ViewContext<Self>) {
cx.emit(Event::Dismissed)
}
fn render_match(
&self,
ix: usize,
mouse_state: &mut gpui::MouseState,
selected: bool,
cx: &gpui::AppContext,
) -> gpui::ElementBox {
let theme = &cx.global::<Settings>().theme;
let keymap_match = &self.matches[ix];
let style = theme.picker.item.style_for(mouse_state, selected);
Label::new(keymap_match.string.clone(), style.label.clone())
.with_highlights(keymap_match.positions.clone())
.contained()
.with_style(style.container)
.boxed()
}
}

316
crates/welcome/src/welcome.rs Normal file
View file

@ -0,0 +1,316 @@
mod base_keymap_picker;
use std::{borrow::Cow, sync::Arc};
use db::kvp::KEY_VALUE_STORE;
use gpui::{
elements::{Flex, Label, MouseEventHandler, ParentElement},
Action, Element, ElementBox, Entity, MouseButton, MutableAppContext, RenderContext,
Subscription, View, ViewContext,
};
use settings::{settings_file::SettingsFile, Settings};
use workspace::{
item::Item, open_new, sidebar::SidebarSide, AppState, PaneBackdrop, Welcome, Workspace,
WorkspaceId,
};
use crate::base_keymap_picker::ToggleBaseKeymapSelector;
pub const FIRST_OPEN: &str = "first_open";
pub fn init(cx: &mut MutableAppContext) {
cx.add_action(|workspace: &mut Workspace, _: &Welcome, cx| {
let welcome_page = cx.add_view(WelcomePage::new);
workspace.add_item(Box::new(welcome_page), cx)
});
base_keymap_picker::init(cx);
}
pub fn show_welcome_experience(app_state: &Arc<AppState>, cx: &mut MutableAppContext) {
open_new(&app_state, cx, |workspace, cx| {
workspace.toggle_sidebar(SidebarSide::Left, cx);
let welcome_page = cx.add_view(|cx| WelcomePage::new(cx));
workspace.add_item_to_center(Box::new(welcome_page.clone()), cx);
cx.focus(welcome_page);
cx.notify();
})
.detach();
db::write_and_log(cx, || {
KEY_VALUE_STORE.write_kvp(FIRST_OPEN.to_string(), "false".to_string())
});
}
pub struct WelcomePage {
_settings_subscription: Subscription,
}
impl Entity for WelcomePage {
type Event = ();
}
impl View for WelcomePage {
fn ui_name() -> &'static str {
"WelcomePage"
}
fn render(&mut self, cx: &mut gpui::RenderContext<'_, Self>) -> ElementBox {
let self_handle = cx.handle();
let settings = cx.global::<Settings>();
let theme = settings.theme.clone();
let width = theme.welcome.page_width;
let (diagnostics, metrics) = {
let telemetry = settings.telemetry();
(telemetry.diagnostics(), telemetry.metrics())
};
enum Metrics {}
enum Diagnostics {}
PaneBackdrop::new(
self_handle.id(),
Flex::column()
.with_children([
Flex::column()
.with_children([
theme::ui::icon(&theme.welcome.logo)
.aligned()
.contained()
.aligned()
.boxed(),
Label::new(
"Code at the speed of thought",
theme.welcome.logo_subheading.text.clone(),
)
.aligned()
.contained()
.with_style(theme.welcome.logo_subheading.container)
.boxed(),
])
.contained()
.with_style(theme.welcome.heading_group)
.constrained()
.with_width(width)
.boxed(),
Flex::column()
.with_children([
self.render_cta_button(
"Choose a theme",
theme_selector::Toggle,
width,
cx,
),
self.render_cta_button(
"Choose a keymap",
ToggleBaseKeymapSelector,
width,
cx,
),
self.render_cta_button(
"Install the CLI",
install_cli::Install,
width,
cx,
),
])
.contained()
.with_style(theme.welcome.button_group)
.constrained()
.with_width(width)
.boxed(),
Flex::column()
.with_children([
theme::ui::checkbox_with_label::<Metrics, Self>(
Flex::column()
.with_children([
Label::new(
"Send anonymous usage data",
theme.welcome.checkbox.label.text.clone(),
)
.contained()
.with_style(theme.welcome.checkbox.label.container)
.boxed(),
Label::new(
"Help > View Telemetry",
theme.welcome.usage_note.text.clone(),
)
.contained()
.with_style(theme.welcome.usage_note.container)
.boxed(),
])
.boxed(),
&theme.welcome.checkbox,
metrics,
cx,
|checked, cx| {
SettingsFile::update(cx, move |file| {
file.telemetry.set_metrics(checked)
})
},
)
.contained()
.with_style(theme.welcome.checkbox_container)
.boxed(),
theme::ui::checkbox::<Diagnostics, Self>(
"Send crash reports",
&theme.welcome.checkbox,
diagnostics,
cx,
|checked, cx| {
SettingsFile::update(cx, move |file| {
file.telemetry.set_diagnostics(checked)
})
},
)
.contained()
.with_style(theme.welcome.checkbox_container)
.boxed(),
])
.contained()
.with_style(theme.welcome.checkbox_group)
.constrained()
.with_width(width)
.boxed(),
])
.constrained()
.with_max_width(width)
.contained()
.with_uniform_padding(10.)
.aligned()
.boxed(),
)
.boxed()
}
}
impl WelcomePage {
pub fn new(cx: &mut ViewContext<Self>) -> Self {
let handle = cx.weak_handle();
let settings_subscription = cx.observe_global::<Settings, _>(move |cx| {
if let Some(handle) = handle.upgrade(cx) {
handle.update(cx, |_, cx| cx.notify())
}
});
WelcomePage {
_settings_subscription: settings_subscription,
}
}
fn render_cta_button<L, A>(
&self,
label: L,
action: A,
width: f32,
cx: &mut RenderContext<Self>,
) -> ElementBox
where
L: Into<Cow<'static, str>>,
A: 'static + Action + Clone,
{
let theme = cx.global::<Settings>().theme.clone();
MouseEventHandler::<A>::new(0, cx, |state, _| {
let style = theme.welcome.button.style_for(state, false);
Label::new(label, style.text.clone())
.aligned()
.contained()
.with_style(style.container)
.constrained()
.with_max_width(width)
.boxed()
})
.on_click(MouseButton::Left, move |_, cx| {
cx.dispatch_action(action.clone())
})
.with_cursor_style(gpui::CursorStyle::PointingHand)
.boxed()
}
// fn render_settings_checkbox<T: 'static>(
// &self,
// label: &'static str,
// style: &CheckboxStyle,
// checked: bool,
// cx: &mut RenderContext<Self>,
// set_value: fn(&mut SettingsFileContent, checked: bool) -> (),
// ) -> ElementBox {
// MouseEventHandler::<T>::new(0, cx, |state, _| {
// let indicator = if checked {
// Svg::new(style.check_icon.clone())
// .with_color(style.check_icon_color)
// .constrained()
// } else {
// Empty::new().constrained()
// };
// Flex::row()
// .with_children([
// indicator
// .with_width(style.width)
// .with_height(style.height)
// .contained()
// .with_style(if checked {
// if state.hovered() {
// style.hovered_and_checked
// } else {
// style.checked
// }
// } else {
// if state.hovered() {
// style.hovered
// } else {
// style.default
// }
// })
// .boxed(),
// Label::new(label, style.label.text.clone())
// .contained()
// .with_style(style.label.container)
// .boxed(),
// ])
// .align_children_center()
// .boxed()
// })
// .on_click(gpui::MouseButton::Left, move |_, cx| {
// SettingsFile::update(cx, move |content| set_value(content, !checked))
// })
// .with_cursor_style(gpui::CursorStyle::PointingHand)
// .contained()
// .with_style(style.container)
// .boxed()
// }
}
impl Item for WelcomePage {
fn tab_content(
&self,
_detail: Option<usize>,
style: &theme::Tab,
_cx: &gpui::AppContext,
) -> gpui::ElementBox {
Flex::row()
.with_child(
Label::new("Welcome to Zed!", style.label.clone())
.aligned()
.contained()
.boxed(),
)
.boxed()
}
fn show_toolbar(&self) -> bool {
false
}
fn clone_on_split(
&self,
_workspace_id: WorkspaceId,
cx: &mut ViewContext<Self>,
) -> Option<Self> {
Some(WelcomePage::new(cx))
}
}

1
crates/workspace/Cargo.toml
View file

@ -27,6 +27,7 @@ context_menu = { path = "../context_menu" }
drag_and_drop = { path = "../drag_and_drop" } drag_and_drop = { path = "../drag_and_drop" }
fs = { path = "../fs" } fs = { path = "../fs" }
gpui = { path = "../gpui" } gpui = { path = "../gpui" }
install_cli = { path = "../install_cli" }
language = { path = "../language" } language = { path = "../language" }
menu = { path = "../menu" } menu = { path = "../menu" }
project = { path = "../project" } project = { path = "../project" }

63
crates/workspace/src/dock.rs
View file

@ -13,7 +13,7 @@ use gpui::{
use settings::{DockAnchor, Settings}; use settings::{DockAnchor, Settings};
use theme::Theme; use theme::Theme;
use crate::{sidebar::SidebarSide, ItemHandle, Pane, Workspace}; use crate::{sidebar::SidebarSide, BackgroundActions, ItemHandle, Pane, Workspace};
pub use toggle_dock_button::ToggleDockButton; pub use toggle_dock_button::ToggleDockButton;
#[derive(PartialEq, Clone, Deserialize)] #[derive(PartialEq, Clone, Deserialize)]
@ -39,20 +39,24 @@ impl_internal_actions!(dock, [MoveDock, AddDefaultItemToDock]);
pub fn init(cx: &mut MutableAppContext) { pub fn init(cx: &mut MutableAppContext) {
cx.add_action(Dock::focus_dock); cx.add_action(Dock::focus_dock);
cx.add_action(Dock::hide_dock); cx.add_action(Dock::hide_dock);
cx.add_action(Dock::move_dock); cx.add_action(
|workspace: &mut Workspace, &MoveDock(dock_anchor), cx: &mut ViewContext<Workspace>| {
Dock::move_dock(workspace, dock_anchor, true, cx);
},
);
cx.add_action( cx.add_action(
|workspace: &mut Workspace, _: &AnchorDockRight, cx: &mut ViewContext<Workspace>| { |workspace: &mut Workspace, _: &AnchorDockRight, cx: &mut ViewContext<Workspace>| {
Dock::move_dock(workspace, &MoveDock(DockAnchor::Right), cx) Dock::move_dock(workspace, DockAnchor::Right, true, cx);
}, },
); );
cx.add_action( cx.add_action(
|workspace: &mut Workspace, _: &AnchorDockBottom, cx: &mut ViewContext<Workspace>| { |workspace: &mut Workspace, _: &AnchorDockBottom, cx: &mut ViewContext<Workspace>| {
Dock::move_dock(workspace, &MoveDock(DockAnchor::Bottom), cx) Dock::move_dock(workspace, DockAnchor::Bottom, true, cx)
}, },
); );
cx.add_action( cx.add_action(
|workspace: &mut Workspace, _: &ExpandDock, cx: &mut ViewContext<Workspace>| { |workspace: &mut Workspace, _: &ExpandDock, cx: &mut ViewContext<Workspace>| {
Dock::move_dock(workspace, &MoveDock(DockAnchor::Expanded), cx) Dock::move_dock(workspace, DockAnchor::Expanded, true, cx)
}, },
); );
cx.add_action( cx.add_action(
@ -177,12 +181,21 @@ pub struct Dock {
impl Dock { impl Dock {
pub fn new( pub fn new(
workspace_id: usize,
default_item_factory: DockDefaultItemFactory, default_item_factory: DockDefaultItemFactory,
background_actions: BackgroundActions,
cx: &mut ViewContext<Workspace>, cx: &mut ViewContext<Workspace>,
) -> Self { ) -> Self {
let position = DockPosition::Hidden(cx.global::<Settings>().default_dock_anchor); let position = DockPosition::Hidden(cx.global::<Settings>().default_dock_anchor);
let pane = cx.add_view(|cx| Pane::new(Some(position.anchor()), cx)); let pane = cx.add_view(|cx| {
Pane::new(
workspace_id,
Some(position.anchor()),
background_actions,
cx,
)
});
pane.update(cx, |pane, cx| { pane.update(cx, |pane, cx| {
pane.set_active(false, cx); pane.set_active(false, cx);
}); });
@ -215,6 +228,7 @@ impl Dock {
pub(crate) fn set_dock_position( pub(crate) fn set_dock_position(
workspace: &mut Workspace, workspace: &mut Workspace,
new_position: DockPosition, new_position: DockPosition,
focus: bool,
cx: &mut ViewContext<Workspace>, cx: &mut ViewContext<Workspace>,
) { ) {
workspace.dock.position = new_position; workspace.dock.position = new_position;
@ -235,19 +249,23 @@ impl Dock {
let pane = workspace.dock.pane.clone(); let pane = workspace.dock.pane.clone();
if pane.read(cx).items().next().is_none() { if pane.read(cx).items().next().is_none() {
if let Some(item_to_add) = (workspace.dock.default_item_factory)(workspace, cx) { if let Some(item_to_add) = (workspace.dock.default_item_factory)(workspace, cx) {
Pane::add_item(workspace, &pane, item_to_add, true, true, None, cx); Pane::add_item(workspace, &pane, item_to_add, focus, focus, None, cx);
} else { } else {
workspace.dock.position = workspace.dock.position.hide(); workspace.dock.position = workspace.dock.position.hide();
} }
} else { } else {
cx.focus(pane); if focus {
cx.focus(pane);
}
} }
} else if let Some(last_active_center_pane) = workspace } else if let Some(last_active_center_pane) = workspace
.last_active_center_pane .last_active_center_pane
.as_ref() .as_ref()
.and_then(|pane| pane.upgrade(cx)) .and_then(|pane| pane.upgrade(cx))
{ {
cx.focus(last_active_center_pane); if focus {
cx.focus(last_active_center_pane);
}
} }
cx.emit(crate::Event::DockAnchorChanged); cx.emit(crate::Event::DockAnchorChanged);
workspace.serialize_workspace(cx); workspace.serialize_workspace(cx);
@ -255,11 +273,11 @@ impl Dock {
} }
pub fn hide(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) { pub fn hide(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
Self::set_dock_position(workspace, workspace.dock.position.hide(), cx); Self::set_dock_position(workspace, workspace.dock.position.hide(), true, cx);
} }
pub fn show(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) { pub fn show(workspace: &mut Workspace, focus: bool, cx: &mut ViewContext<Workspace>) {
Self::set_dock_position(workspace, workspace.dock.position.show(), cx); Self::set_dock_position(workspace, workspace.dock.position.show(), focus, cx);
} }
pub fn hide_on_sidebar_shown( pub fn hide_on_sidebar_shown(
@ -275,19 +293,20 @@ impl Dock {
} }
fn focus_dock(workspace: &mut Workspace, _: &FocusDock, cx: &mut ViewContext<Workspace>) { fn focus_dock(workspace: &mut Workspace, _: &FocusDock, cx: &mut ViewContext<Workspace>) {
Self::set_dock_position(workspace, workspace.dock.position.show(), cx); Self::set_dock_position(workspace, workspace.dock.position.show(), true, cx);
} }
fn hide_dock(workspace: &mut Workspace, _: &HideDock, cx: &mut ViewContext<Workspace>) { fn hide_dock(workspace: &mut Workspace, _: &HideDock, cx: &mut ViewContext<Workspace>) {
Self::set_dock_position(workspace, workspace.dock.position.hide(), cx); Self::set_dock_position(workspace, workspace.dock.position.hide(), true, cx);
} }
fn move_dock( pub fn move_dock(
workspace: &mut Workspace, workspace: &mut Workspace,
&MoveDock(new_anchor): &MoveDock, new_anchor: DockAnchor,
focus: bool,
cx: &mut ViewContext<Workspace>, cx: &mut ViewContext<Workspace>,
) { ) {
Self::set_dock_position(workspace, DockPosition::Shown(new_anchor), cx); Self::set_dock_position(workspace, DockPosition::Shown(new_anchor), focus, cx);
} }
pub fn render( pub fn render(
@ -482,6 +501,7 @@ mod tests {
0, 0,
project.clone(), project.clone(),
default_item_factory, default_item_factory,
|| &[],
cx, cx,
) )
}); });
@ -610,7 +630,14 @@ mod tests {
cx.update(|cx| init(cx)); cx.update(|cx| init(cx));
let project = Project::test(fs, [], cx).await; let project = Project::test(fs, [], cx).await;
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| {
Workspace::new(Default::default(), 0, project, default_item_factory, cx) Workspace::new(
Default::default(),
0,
project,
default_item_factory,
|| &[],
cx,
)
}); });
workspace.update(cx, |workspace, cx| { workspace.update(cx, |workspace, cx| {

8
crates/workspace/src/item.rs
View file

@ -151,6 +151,9 @@ pub trait Item: View {
"deserialize() must be implemented if serialized_item_kind() returns Some(_)" "deserialize() must be implemented if serialized_item_kind() returns Some(_)"
) )
} }
fn show_toolbar(&self) -> bool {
true
}
} }
pub trait ItemHandle: 'static + fmt::Debug { pub trait ItemHandle: 'static + fmt::Debug {
@ -213,6 +216,7 @@ pub trait ItemHandle: 'static + fmt::Debug {
fn breadcrumb_location(&self, cx: &AppContext) -> ToolbarItemLocation; fn breadcrumb_location(&self, cx: &AppContext) -> ToolbarItemLocation;
fn breadcrumbs(&self, theme: &Theme, cx: &AppContext) -> Option<Vec<ElementBox>>; fn breadcrumbs(&self, theme: &Theme, cx: &AppContext) -> Option<Vec<ElementBox>>;
fn serialized_item_kind(&self) -> Option<&'static str>; fn serialized_item_kind(&self) -> Option<&'static str>;
fn show_toolbar(&self, cx: &AppContext) -> bool;
} }
pub trait WeakItemHandle { pub trait WeakItemHandle {
@ -591,6 +595,10 @@ impl<T: Item> ItemHandle for ViewHandle<T> {
fn serialized_item_kind(&self) -> Option<&'static str> { fn serialized_item_kind(&self) -> Option<&'static str> {
T::serialized_item_kind() T::serialized_item_kind()
} }
fn show_toolbar(&self, cx: &AppContext) -> bool {
self.read(cx).show_toolbar()
}
} }
impl From<Box<dyn ItemHandle>> for AnyViewHandle { impl From<Box<dyn ItemHandle>> for AnyViewHandle {

28
crates/workspace/src/notifications.rs
View file

@ -122,6 +122,8 @@ impl Workspace {
pub mod simple_message_notification { pub mod simple_message_notification {
use std::borrow::Cow;
use gpui::{ use gpui::{
actions, actions,
elements::{Flex, MouseEventHandler, Padding, ParentElement, Svg, Text}, elements::{Flex, MouseEventHandler, Padding, ParentElement, Svg, Text},
@ -153,9 +155,9 @@ pub mod simple_message_notification {
} }
pub struct MessageNotification { pub struct MessageNotification {
message: String, message: Cow<'static, str>,
click_action: Option<Box<dyn Action>>, click_action: Option<Box<dyn Action>>,
click_message: Option<String>, click_message: Option<Cow<'static, str>>,
} }
pub enum MessageNotificationEvent { pub enum MessageNotificationEvent {
@ -167,23 +169,23 @@ pub mod simple_message_notification {
} }
impl MessageNotification { impl MessageNotification {
pub fn new_message<S: AsRef<str>>(message: S) -> MessageNotification { pub fn new_message<S: Into<Cow<'static, str>>>(message: S) -> MessageNotification {
Self { Self {
message: message.as_ref().to_string(), message: message.into(),
click_action: None, click_action: None,
click_message: None, click_message: None,
} }
} }
pub fn new<S1: AsRef<str>, A: Action, S2: AsRef<str>>( pub fn new<S1: Into<Cow<'static, str>>, A: Action, S2: Into<Cow<'static, str>>>(
message: S1, message: S1,
click_action: A, click_action: A,
click_message: S2, click_message: S2,
) -> Self { ) -> Self {
Self { Self {
message: message.as_ref().to_string(), message: message.into(),
click_action: Some(Box::new(click_action) as Box<dyn Action>), click_action: Some(Box::new(click_action) as Box<dyn Action>),
click_message: Some(click_message.as_ref().to_string()), click_message: Some(click_message.into()),
} }
} }
@ -210,6 +212,8 @@ pub mod simple_message_notification {
let click_message = self.click_message.as_ref().map(|message| message.clone()); let click_message = self.click_message.as_ref().map(|message| message.clone());
let message = self.message.clone(); let message = self.message.clone();
let has_click_action = click_action.is_some();
MouseEventHandler::<MessageNotificationTag>::new(0, cx, |state, cx| { MouseEventHandler::<MessageNotificationTag>::new(0, cx, |state, cx| {
Flex::column() Flex::column()
.with_child( .with_child(
@ -243,6 +247,7 @@ pub mod simple_message_notification {
.on_click(MouseButton::Left, move |_, cx| { .on_click(MouseButton::Left, move |_, cx| {
cx.dispatch_action(CancelMessageNotification) cx.dispatch_action(CancelMessageNotification)
}) })
.with_cursor_style(CursorStyle::PointingHand)
.aligned() .aligned()
.constrained() .constrained()
.with_height( .with_height(
@ -272,12 +277,19 @@ pub mod simple_message_notification {
.contained() .contained()
.boxed() .boxed()
}) })
.with_cursor_style(CursorStyle::PointingHand) // Since we're not using a proper overlay, we have to capture these extra events
.on_down(MouseButton::Left, |_, _| {})
.on_up(MouseButton::Left, |_, _| {})
.on_click(MouseButton::Left, move |_, cx| { .on_click(MouseButton::Left, move |_, cx| {
if let Some(click_action) = click_action.as_ref() { if let Some(click_action) = click_action.as_ref() {
cx.dispatch_any_action(click_action.boxed_clone()) cx.dispatch_any_action(click_action.boxed_clone())
} }
}) })
.with_cursor_style(if has_click_action {
CursorStyle::PointingHand
} else {
CursorStyle::Arrow
})
.boxed() .boxed()
} }
} }

141
crates/workspace/src/pane.rs
View file

@ -24,8 +24,8 @@ use gpui::{
keymap_matcher::KeymapContext, keymap_matcher::KeymapContext,
platform::{CursorStyle, NavigationDirection}, platform::{CursorStyle, NavigationDirection},
Action, AnyViewHandle, AnyWeakViewHandle, AppContext, AsyncAppContext, Entity, EventContext, Action, AnyViewHandle, AnyWeakViewHandle, AppContext, AsyncAppContext, Entity, EventContext,
ModelHandle, MouseButton, MutableAppContext, PromptLevel, Quad, RenderContext, Task, View, ModelHandle, MouseButton, MouseRegion, MutableAppContext, PromptLevel, Quad, RenderContext,
ViewContext, ViewHandle, WeakViewHandle, Task, View, ViewContext, ViewHandle, WeakViewHandle,
}; };
use project::{Project, ProjectEntryId, ProjectPath}; use project::{Project, ProjectEntryId, ProjectPath};
use serde::Deserialize; use serde::Deserialize;
@ -110,6 +110,8 @@ impl_internal_actions!(
const MAX_NAVIGATION_HISTORY_LEN: usize = 1024; const MAX_NAVIGATION_HISTORY_LEN: usize = 1024;
pub type BackgroundActions = fn() -> &'static [(&'static str, &'static dyn Action)];
pub fn init(cx: &mut MutableAppContext) { pub fn init(cx: &mut MutableAppContext) {
cx.add_action(|pane: &mut Pane, action: &ActivateItem, cx| { cx.add_action(|pane: &mut Pane, action: &ActivateItem, cx| {
pane.activate_item(action.0, true, true, cx); pane.activate_item(action.0, true, true, cx);
@ -215,6 +217,8 @@ pub struct Pane {
toolbar: ViewHandle<Toolbar>, toolbar: ViewHandle<Toolbar>,
tab_bar_context_menu: ViewHandle<ContextMenu>, tab_bar_context_menu: ViewHandle<ContextMenu>,
docked: Option<DockAnchor>, docked: Option<DockAnchor>,
_background_actions: BackgroundActions,
_workspace_id: usize,
} }
pub struct ItemNavHistory { pub struct ItemNavHistory {
@ -271,7 +275,12 @@ enum ItemType {
} }
impl Pane { impl Pane {
pub fn new(docked: Option<DockAnchor>, cx: &mut ViewContext<Self>) -> Self { pub fn new(
workspace_id: usize,
docked: Option<DockAnchor>,
background_actions: BackgroundActions,
cx: &mut ViewContext<Self>,
) -> Self {
let handle = cx.weak_handle(); let handle = cx.weak_handle();
let context_menu = cx.add_view(ContextMenu::new); let context_menu = cx.add_view(ContextMenu::new);
Self { Self {
@ -292,6 +301,8 @@ impl Pane {
toolbar: cx.add_view(|_| Toolbar::new(handle)), toolbar: cx.add_view(|_| Toolbar::new(handle)),
tab_bar_context_menu: context_menu, tab_bar_context_menu: context_menu,
docked, docked,
_background_actions: background_actions,
_workspace_id: workspace_id,
} }
} }
@ -1415,6 +1426,14 @@ impl Pane {
.flex(1., false) .flex(1., false)
.boxed() .boxed()
} }
fn render_blank_pane(&mut self, theme: &Theme, _cx: &mut RenderContext<Self>) -> ElementBox {
let background = theme.workspace.background;
Empty::new()
.contained()
.with_background_color(background)
.boxed()
}
} }
impl Entity for Pane { impl Entity for Pane {
@ -1485,11 +1504,12 @@ impl View for Pane {
cx, cx,
{ {
let toolbar = self.toolbar.clone(); let toolbar = self.toolbar.clone();
let toolbar_hidden = toolbar.read(cx).hidden();
move |_, cx| { move |_, cx| {
Flex::column() Flex::column()
.with_child( .with_children((!toolbar_hidden).then(|| {
ChildView::new(&toolbar, cx).expanded().boxed(), ChildView::new(&toolbar, cx).expanded().boxed()
) }))
.with_child( .with_child(
ChildView::new(active_item, cx) ChildView::new(active_item, cx)
.flex(1., true) .flex(1., true)
@ -1507,11 +1527,8 @@ impl View for Pane {
enum EmptyPane {} enum EmptyPane {}
let theme = cx.global::<Settings>().theme.clone(); let theme = cx.global::<Settings>().theme.clone();
dragged_item_receiver::<EmptyPane, _>(0, 0, false, None, cx, |_, _| { dragged_item_receiver::<EmptyPane, _>(0, 0, false, None, cx, |_, cx| {
Empty::new() self.render_blank_pane(&theme, cx)
.contained()
.with_background_color(theme.workspace.background)
.boxed()
}) })
.on_down(MouseButton::Left, |_, cx| { .on_down(MouseButton::Left, |_, cx| {
cx.focus_parent_view(); cx.focus_parent_view();
@ -1705,6 +1722,93 @@ impl NavHistory {
} }
} }
pub struct PaneBackdrop {
child_view: usize,
child: ElementBox,
}
impl PaneBackdrop {
pub fn new(pane_item_view: usize, child: ElementBox) -> Self {
PaneBackdrop {
child,
child_view: pane_item_view,
}
}
}
impl Element for PaneBackdrop {
type LayoutState = ();
type PaintState = ();
fn layout(
&mut self,
constraint: gpui::SizeConstraint,
cx: &mut gpui::LayoutContext,
) -> (Vector2F, Self::LayoutState) {
let size = self.child.layout(constraint, cx);
(size, ())
}
fn paint(
&mut self,
bounds: RectF,
visible_bounds: RectF,
_: &mut Self::LayoutState,
cx: &mut gpui::PaintContext,
) -> Self::PaintState {
let background = cx.global::<Settings>().theme.editor.background;
let visible_bounds = bounds.intersection(visible_bounds).unwrap_or_default();
cx.scene.push_quad(gpui::Quad {
bounds: RectF::new(bounds.origin(), bounds.size()),
background: Some(background),
..Default::default()
});
let child_view_id = self.child_view;
cx.scene.push_mouse_region(
MouseRegion::new::<Self>(child_view_id, 0, visible_bounds).on_down(
gpui::MouseButton::Left,
move |_, cx| {
let window_id = cx.window_id;
cx.focus(window_id, Some(child_view_id))
},
),
);
cx.paint_layer(Some(bounds), |cx| {
self.child.paint(bounds.origin(), visible_bounds, cx)
})
}
fn rect_for_text_range(
&self,
range_utf16: std::ops::Range<usize>,
_bounds: RectF,
_visible_bounds: RectF,
_layout: &Self::LayoutState,
_paint: &Self::PaintState,
cx: &gpui::MeasurementContext,
) -> Option<RectF> {
self.child.rect_for_text_range(range_utf16, cx)
}
fn debug(
&self,
_bounds: RectF,
_layout: &Self::LayoutState,
_paint: &Self::PaintState,
cx: &gpui::DebugContext,
) -> serde_json::Value {
gpui::json::json!({
"type": "Pane Back Drop",
"view": self.child_view,
"child": self.child.debug(cx),
})
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::sync::Arc; use std::sync::Arc;
@ -1721,9 +1825,7 @@ mod tests {
let fs = FakeFs::new(cx.background()); let fs = FakeFs::new(cx.background());
let project = Project::test(fs, None, cx).await; let project = Project::test(fs, None, cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone()); let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone());
// 1. Add with a destination index // 1. Add with a destination index
@ -1811,9 +1913,7 @@ mod tests {
let fs = FakeFs::new(cx.background()); let fs = FakeFs::new(cx.background());
let project = Project::test(fs, None, cx).await; let project = Project::test(fs, None, cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone()); let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone());
// 1. Add with a destination index // 1. Add with a destination index
@ -1889,9 +1989,7 @@ mod tests {
let fs = FakeFs::new(cx.background()); let fs = FakeFs::new(cx.background());
let project = Project::test(fs, None, cx).await; let project = Project::test(fs, None, cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone()); let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone());
// singleton view // singleton view
@ -2000,8 +2098,7 @@ mod tests {
let fs = FakeFs::new(cx.background()); let fs = FakeFs::new(cx.background());
let project = Project::test(fs, None, cx).await; let project = Project::test(fs, None, cx).await;
let (_, workspace) = let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
cx.add_window(|cx| Workspace::new(None, 0, project, |_, _| unimplemented!(), cx));
let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone()); let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone());
add_labled_item(&workspace, &pane, "A", cx); add_labled_item(&workspace, &pane, "A", cx);

12
crates/workspace/src/toolbar.rs
View file

@ -42,6 +42,7 @@ pub enum ToolbarItemLocation {
pub struct Toolbar { pub struct Toolbar {
active_pane_item: Option<Box<dyn ItemHandle>>, active_pane_item: Option<Box<dyn ItemHandle>>,
hidden: bool,
pane: WeakViewHandle<Pane>, pane: WeakViewHandle<Pane>,
items: Vec<(Box<dyn ToolbarItemViewHandle>, ToolbarItemLocation)>, items: Vec<(Box<dyn ToolbarItemViewHandle>, ToolbarItemLocation)>,
} }
@ -211,6 +212,7 @@ impl Toolbar {
active_pane_item: None, active_pane_item: None,
pane, pane,
items: Default::default(), items: Default::default(),
hidden: false,
} }
} }
@ -243,6 +245,12 @@ impl Toolbar {
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) { ) {
self.active_pane_item = pane_item.map(|item| item.boxed_clone()); self.active_pane_item = pane_item.map(|item| item.boxed_clone());
self.hidden = self
.active_pane_item
.as_ref()
.map(|item| !item.show_toolbar(cx))
.unwrap_or(false);
for (toolbar_item, current_location) in self.items.iter_mut() { for (toolbar_item, current_location) in self.items.iter_mut() {
let new_location = toolbar_item.set_active_pane_item(pane_item, cx); let new_location = toolbar_item.set_active_pane_item(pane_item, cx);
if new_location != *current_location { if new_location != *current_location {
@ -257,6 +265,10 @@ impl Toolbar {
.iter() .iter()
.find_map(|(item, _)| item.to_any().downcast()) .find_map(|(item, _)| item.to_any().downcast())
} }
pub fn hidden(&self) -> bool {
self.hidden
}
} }
impl<T: ToolbarItemView> ToolbarItemViewHandle for ViewHandle<T> { impl<T: ToolbarItemView> ToolbarItemViewHandle for ViewHandle<T> {

347
crates/workspace/src/workspace.rs
View file

@ -17,7 +17,7 @@ mod toolbar;
pub use smallvec; pub use smallvec;
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Context, Result};
use call::ActiveCall; use call::ActiveCall;
use client::{ use client::{
proto::{self, PeerId}, proto::{self, PeerId},
@ -44,7 +44,8 @@ use gpui::{
platform::{CursorStyle, WindowOptions}, platform::{CursorStyle, WindowOptions},
AnyModelHandle, AnyViewHandle, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, AnyModelHandle, AnyViewHandle, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle,
MouseButton, MutableAppContext, PathPromptOptions, Platform, PromptLevel, RenderContext, MouseButton, MutableAppContext, PathPromptOptions, Platform, PromptLevel, RenderContext,
SizeConstraint, Task, View, ViewContext, ViewHandle, WeakViewHandle, WindowBounds, SizeConstraint, Subscription, Task, View, ViewContext, ViewHandle, WeakViewHandle,
WindowBounds,
}; };
use item::{FollowableItem, FollowableItemHandle, Item, ItemHandle, ProjectItem}; use item::{FollowableItem, FollowableItemHandle, Item, ItemHandle, ProjectItem};
use language::LanguageRegistry; use language::LanguageRegistry;
@ -65,7 +66,7 @@ use crate::{
}; };
use lazy_static::lazy_static; use lazy_static::lazy_static;
use log::{error, warn}; use log::{error, warn};
use notifications::NotificationHandle; use notifications::{NotificationHandle, NotifyResultExt};
pub use pane::*; pub use pane::*;
pub use pane_group::*; pub use pane_group::*;
use persistence::{model::SerializedItem, DB}; use persistence::{model::SerializedItem, DB};
@ -118,7 +119,8 @@ actions!(
NewTerminal, NewTerminal,
NewSearch, NewSearch,
Feedback, Feedback,
Restart Restart,
Welcome
] ]
); );
@ -187,21 +189,66 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
dock::init(cx); dock::init(cx);
notifications::init(cx); notifications::init(cx);
cx.add_global_action(open); cx.add_global_action(|_: &Open, cx: &mut MutableAppContext| {
let mut paths = cx.prompt_for_paths(PathPromptOptions {
files: true,
directories: true,
multiple: true,
});
cx.spawn(|mut cx| async move {
if let Some(paths) = paths.recv().await.flatten() {
cx.update(|cx| cx.dispatch_global_action(OpenPaths { paths }));
}
})
.detach();
});
cx.add_action(|_, _: &Open, cx: &mut ViewContext<Workspace>| {
let mut paths = cx.prompt_for_paths(PathPromptOptions {
files: true,
directories: true,
multiple: true,
});
let handle = cx.handle().downgrade();
cx.spawn(|_, mut cx| async move {
if let Some(paths) = paths.recv().await.flatten() {
cx.update(|cx| {
cx.dispatch_action_at(handle.window_id(), handle.id(), OpenPaths { paths })
})
}
})
.detach();
});
cx.add_global_action({ cx.add_global_action({
let app_state = Arc::downgrade(&app_state); let app_state = Arc::downgrade(&app_state);
move |action: &OpenPaths, cx: &mut MutableAppContext| { move |action: &OpenPaths, cx: &mut MutableAppContext| {
if let Some(app_state) = app_state.upgrade() { if let Some(app_state) = app_state.upgrade() {
open_paths(&action.paths, &app_state, cx).detach(); open_paths(&action.paths, &app_state, None, cx).detach();
} }
} }
}); });
cx.add_global_action({ cx.add_async_action({
let app_state = Arc::downgrade(&app_state); let app_state = Arc::downgrade(&app_state);
move |_: &NewFile, cx: &mut MutableAppContext| { move |workspace, action: &OpenPaths, cx: &mut ViewContext<Workspace>| {
if let Some(app_state) = app_state.upgrade() { if !workspace.project().read(cx).is_local() {
open_new(&app_state, cx).detach(); cx.propagate_action();
return None;
} }
let app_state = app_state.upgrade()?;
let window_id = cx.window_id();
let action = action.clone();
let close = workspace.prepare_to_close(false, cx);
Some(cx.spawn_weak(|_, mut cx| async move {
let can_close = close.await?;
if can_close {
cx.update(|cx| open_paths(&action.paths, &app_state, Some(window_id), cx))
.await;
}
Ok(())
}))
} }
}); });
@ -209,7 +256,7 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
let app_state = Arc::downgrade(&app_state); let app_state = Arc::downgrade(&app_state);
move |_: &NewWindow, cx: &mut MutableAppContext| { move |_: &NewWindow, cx: &mut MutableAppContext| {
if let Some(app_state) = app_state.upgrade() { if let Some(app_state) = app_state.upgrade() {
open_new(&app_state, cx).detach(); open_new(&app_state, cx, |_, cx| cx.dispatch_action(NewFile)).detach();
} }
} }
}); });
@ -275,6 +322,31 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
}, },
); );
cx.add_action(|_: &mut Workspace, _: &install_cli::Install, cx| {
cx.spawn(|workspace, mut cx| async move {
let err = install_cli::install_cli(&cx)
.await
.context("Failed to create CLI symlink");
cx.update(|cx| {
workspace.update(cx, |workspace, cx| {
if matches!(err, Err(_)) {
err.notify_err(workspace, cx);
} else {
workspace.show_notification(1, cx, |cx| {
cx.add_view(|_| {
MessageNotification::new_message(
"Successfully installed the `zed` binary",
)
})
});
}
})
})
})
.detach();
});
let client = &app_state.client; let client = &app_state.client;
client.add_view_request_handler(Workspace::handle_follow); client.add_view_request_handler(Workspace::handle_follow);
client.add_view_message_handler(Workspace::handle_unfollow); client.add_view_message_handler(Workspace::handle_unfollow);
@ -360,6 +432,7 @@ pub struct AppState {
fn(Option<WindowBounds>, Option<uuid::Uuid>, &dyn Platform) -> WindowOptions<'static>, fn(Option<WindowBounds>, Option<uuid::Uuid>, &dyn Platform) -> WindowOptions<'static>,
pub initialize_workspace: fn(&mut Workspace, &Arc<AppState>, &mut ViewContext<Workspace>), pub initialize_workspace: fn(&mut Workspace, &Arc<AppState>, &mut ViewContext<Workspace>),
pub dock_default_item_factory: DockDefaultItemFactory, pub dock_default_item_factory: DockDefaultItemFactory,
pub background_actions: BackgroundActions,
} }
impl AppState { impl AppState {
@ -382,7 +455,8 @@ impl AppState {
user_store, user_store,
initialize_workspace: |_, _, _| {}, initialize_workspace: |_, _, _| {},
build_window_options: |_, _, _| Default::default(), build_window_options: |_, _, _| Default::default(),
dock_default_item_factory: |_, _| unimplemented!(), dock_default_item_factory: |_, _| None,
background_actions: || &[],
}) })
} }
} }
@ -470,6 +544,8 @@ pub struct Workspace {
active_call: Option<(ModelHandle<ActiveCall>, Vec<gpui::Subscription>)>, active_call: Option<(ModelHandle<ActiveCall>, Vec<gpui::Subscription>)>,
leader_updates_tx: mpsc::UnboundedSender<(PeerId, proto::UpdateFollowers)>, leader_updates_tx: mpsc::UnboundedSender<(PeerId, proto::UpdateFollowers)>,
database_id: WorkspaceId, database_id: WorkspaceId,
background_actions: BackgroundActions,
_window_subscriptions: [Subscription; 3],
_apply_leader_updates: Task<Result<()>>, _apply_leader_updates: Task<Result<()>>,
_observe_current_user: Task<()>, _observe_current_user: Task<()>,
} }
@ -499,12 +575,9 @@ impl Workspace {
workspace_id: WorkspaceId, workspace_id: WorkspaceId,
project: ModelHandle<Project>, project: ModelHandle<Project>,
dock_default_factory: DockDefaultItemFactory, dock_default_factory: DockDefaultItemFactory,
background_actions: BackgroundActions,
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) -> Self { ) -> Self {
cx.observe_fullscreen(|_, _, cx| cx.notify()).detach();
cx.observe_window_activation(Self::on_window_activation_changed)
.detach();
cx.observe(&project, |_, _, cx| cx.notify()).detach(); cx.observe(&project, |_, _, cx| cx.notify()).detach();
cx.subscribe(&project, move |this, _, event, cx| { cx.subscribe(&project, move |this, _, event, cx| {
match event { match event {
@ -533,7 +606,10 @@ impl Workspace {
}) })
.detach(); .detach();
let center_pane = cx.add_view(|cx| Pane::new(None, cx)); let weak_handle = cx.weak_handle();
let center_pane =
cx.add_view(|cx| Pane::new(weak_handle.id(), None, background_actions, cx));
let pane_id = center_pane.id(); let pane_id = center_pane.id();
cx.subscribe(&center_pane, move |this, _, event, cx| { cx.subscribe(&center_pane, move |this, _, event, cx| {
this.handle_pane_event(pane_id, event, cx) this.handle_pane_event(pane_id, event, cx)
@ -541,7 +617,12 @@ impl Workspace {
.detach(); .detach();
cx.focus(&center_pane); cx.focus(&center_pane);
cx.emit(Event::PaneAdded(center_pane.clone())); cx.emit(Event::PaneAdded(center_pane.clone()));
let dock = Dock::new(dock_default_factory, cx); let dock = Dock::new(
weak_handle.id(),
dock_default_factory,
background_actions,
cx,
);
let dock_pane = dock.pane().clone(); let dock_pane = dock.pane().clone();
let fs = project.read(cx).fs().clone(); let fs = project.read(cx).fs().clone();
@ -564,7 +645,6 @@ impl Workspace {
} }
}); });
let handle = cx.handle(); let handle = cx.handle();
let weak_handle = cx.weak_handle();
// All leader updates are enqueued and then processed in a single task, so // All leader updates are enqueued and then processed in a single task, so
// that each asynchronous operation can be run in order. // that each asynchronous operation can be run in order.
@ -611,6 +691,28 @@ impl Workspace {
active_call = Some((call, subscriptions)); active_call = Some((call, subscriptions));
} }
let subscriptions = [
cx.observe_fullscreen(|_, _, cx| cx.notify()),
cx.observe_window_activation(Self::on_window_activation_changed),
cx.observe_window_bounds(move |_, mut bounds, display, cx| {
// Transform fixed bounds to be stored in terms of the containing display
if let WindowBounds::Fixed(mut window_bounds) = bounds {
if let Some(screen) = cx.platform().screen_by_id(display) {
let screen_bounds = screen.bounds();
window_bounds
.set_origin_x(window_bounds.origin_x() - screen_bounds.origin_x());
window_bounds
.set_origin_y(window_bounds.origin_y() - screen_bounds.origin_y());
bounds = WindowBounds::Fixed(window_bounds);
}
}
cx.background()
.spawn(DB.set_window_bounds(workspace_id, bounds, display))
.detach_and_log_err(cx);
}),
];
let mut this = Workspace { let mut this = Workspace {
modal: None, modal: None,
weak_self: weak_handle.clone(), weak_self: weak_handle.clone(),
@ -639,9 +741,11 @@ impl Workspace {
window_edited: false, window_edited: false,
active_call, active_call,
database_id: workspace_id, database_id: workspace_id,
background_actions,
_observe_current_user, _observe_current_user,
_apply_leader_updates, _apply_leader_updates,
leader_updates_tx, leader_updates_tx,
_window_subscriptions: subscriptions,
}; };
this.project_remote_id_changed(project.read(cx).remote_id(), cx); this.project_remote_id_changed(project.read(cx).remote_id(), cx);
cx.defer(|this, cx| this.update_window_title(cx)); cx.defer(|this, cx| this.update_window_title(cx));
@ -650,6 +754,10 @@ impl Workspace {
cx.defer(move |_, cx| { cx.defer(move |_, cx| {
Self::load_from_serialized_workspace(weak_handle, serialized_workspace, cx) Self::load_from_serialized_workspace(weak_handle, serialized_workspace, cx)
}); });
} else {
if cx.global::<Settings>().default_dock_anchor != DockAnchor::Expanded {
Dock::show(&mut this, false, cx);
}
} }
this this
@ -658,6 +766,7 @@ impl Workspace {
fn new_local( fn new_local(
abs_paths: Vec<PathBuf>, abs_paths: Vec<PathBuf>,
app_state: Arc<AppState>, app_state: Arc<AppState>,
requesting_window_id: Option<usize>,
cx: &mut MutableAppContext, cx: &mut MutableAppContext,
) -> Task<( ) -> Task<(
ViewHandle<Workspace>, ViewHandle<Workspace>,
@ -713,73 +822,65 @@ impl Workspace {
)) ))
}); });
let (bounds, display) = if let Some(bounds) = window_bounds_override { let build_workspace =
(Some(bounds), None) |cx: &mut ViewContext<Workspace>,
} else { serialized_workspace: Option<SerializedWorkspace>| {
serialized_workspace
.as_ref()
.and_then(|serialized_workspace| {
let display = serialized_workspace.display?;
let mut bounds = serialized_workspace.bounds?;
// Stored bounds are relative to the containing display.
// So convert back to global coordinates if that screen still exists
if let WindowBounds::Fixed(mut window_bounds) = bounds {
if let Some(screen) = cx.platform().screen_by_id(display) {
let screen_bounds = screen.bounds();
window_bounds.set_origin_x(
window_bounds.origin_x() + screen_bounds.origin_x(),
);
window_bounds.set_origin_y(
window_bounds.origin_y() + screen_bounds.origin_y(),
);
bounds = WindowBounds::Fixed(window_bounds);
} else {
// Screen no longer exists. Return none here.
return None;
}
}
Some((bounds, display))
})
.unzip()
};
// Use the serialized workspace to construct the new window
let (_, workspace) = cx.add_window(
(app_state.build_window_options)(bounds, display, cx.platform().as_ref()),
|cx| {
let mut workspace = Workspace::new( let mut workspace = Workspace::new(
serialized_workspace, serialized_workspace,
workspace_id, workspace_id,
project_handle, project_handle,
app_state.dock_default_item_factory, app_state.dock_default_item_factory,
app_state.background_actions,
cx, cx,
); );
(app_state.initialize_workspace)(&mut workspace, &app_state, cx); (app_state.initialize_workspace)(&mut workspace, &app_state, cx);
cx.observe_window_bounds(move |_, mut bounds, display, cx| {
// Transform fixed bounds to be stored in terms of the containing display
if let WindowBounds::Fixed(mut window_bounds) = bounds {
if let Some(screen) = cx.platform().screen_by_id(display) {
let screen_bounds = screen.bounds();
window_bounds.set_origin_x(
window_bounds.origin_x() - screen_bounds.origin_x(),
);
window_bounds.set_origin_y(
window_bounds.origin_y() - screen_bounds.origin_y(),
);
bounds = WindowBounds::Fixed(window_bounds);
}
}
cx.background()
.spawn(DB.set_window_bounds(workspace_id, bounds, display))
.detach_and_log_err(cx);
})
.detach();
workspace workspace
}, };
);
let workspace = if let Some(window_id) = requesting_window_id {
cx.update(|cx| {
cx.replace_root_view(window_id, |cx| build_workspace(cx, serialized_workspace))
})
} else {
let (bounds, display) = if let Some(bounds) = window_bounds_override {
(Some(bounds), None)
} else {
serialized_workspace
.as_ref()
.and_then(|serialized_workspace| {
let display = serialized_workspace.display?;
let mut bounds = serialized_workspace.bounds?;
// Stored bounds are relative to the containing display.
// So convert back to global coordinates if that screen still exists
if let WindowBounds::Fixed(mut window_bounds) = bounds {
if let Some(screen) = cx.platform().screen_by_id(display) {
let screen_bounds = screen.bounds();
window_bounds.set_origin_x(
window_bounds.origin_x() + screen_bounds.origin_x(),
);
window_bounds.set_origin_y(
window_bounds.origin_y() + screen_bounds.origin_y(),
);
bounds = WindowBounds::Fixed(window_bounds);
} else {
// Screen no longer exists. Return none here.
return None;
}
}
Some((bounds, display))
})
.unzip()
};
// Use the serialized workspace to construct the new window
cx.add_window(
(app_state.build_window_options)(bounds, display, cx.platform().as_ref()),
|cx| build_workspace(cx, serialized_workspace),
)
.1
};
notify_if_database_failed(&workspace, &mut cx); notify_if_database_failed(&workspace, &mut cx);
@ -875,7 +976,7 @@ impl Workspace {
if self.project.read(cx).is_local() { if self.project.read(cx).is_local() {
Task::Ready(Some(callback(self, cx))) Task::Ready(Some(callback(self, cx)))
} else { } else {
let task = Self::new_local(Vec::new(), app_state.clone(), cx); let task = Self::new_local(Vec::new(), app_state.clone(), None, cx);
cx.spawn(|_vh, mut cx| async move { cx.spawn(|_vh, mut cx| async move {
let (workspace, _) = task.await; let (workspace, _) = task.await;
workspace.update(&mut cx, callback) workspace.update(&mut cx, callback)
@ -1344,7 +1445,8 @@ impl Workspace {
} }
fn add_pane(&mut self, cx: &mut ViewContext<Self>) -> ViewHandle<Pane> { fn add_pane(&mut self, cx: &mut ViewContext<Self>) -> ViewHandle<Pane> {
let pane = cx.add_view(|cx| Pane::new(None, cx)); let pane =
cx.add_view(|cx| Pane::new(self.weak_handle().id(), None, self.background_actions, cx));
let pane_id = pane.id(); let pane_id = pane.id();
cx.subscribe(&pane, move |this, _, event, cx| { cx.subscribe(&pane, move |this, _, event, cx| {
this.handle_pane_event(pane_id, event, cx) this.handle_pane_event(pane_id, event, cx)
@ -1356,6 +1458,23 @@ impl Workspace {
pane pane
} }
pub fn add_item_to_center(
&mut self,
item: Box<dyn ItemHandle>,
cx: &mut ViewContext<Self>,
) -> bool {
if let Some(center_pane) = self.last_active_center_pane.clone() {
if let Some(center_pane) = center_pane.upgrade(cx) {
Pane::add_item(self, &center_pane, item, true, true, None, cx);
true
} else {
false
}
} else {
false
}
}
pub fn add_item(&mut self, item: Box<dyn ItemHandle>, cx: &mut ViewContext<Self>) { pub fn add_item(&mut self, item: Box<dyn ItemHandle>, cx: &mut ViewContext<Self>) {
let active_pane = self.active_pane().clone(); let active_pane = self.active_pane().clone();
Pane::add_item(self, &active_pane, item, true, true, None, cx); Pane::add_item(self, &active_pane, item, true, true, None, cx);
@ -1513,7 +1632,7 @@ impl Workspace {
self.active_item_path_changed(cx); self.active_item_path_changed(cx);
if &pane == self.dock_pane() { if &pane == self.dock_pane() {
Dock::show(self, cx); Dock::show(self, true, cx);
} else { } else {
self.last_active_center_pane = Some(pane.downgrade()); self.last_active_center_pane = Some(pane.downgrade());
if self.dock.is_anchored_at(DockAnchor::Expanded) { if self.dock.is_anchored_at(DockAnchor::Expanded) {
@ -2526,7 +2645,12 @@ impl Workspace {
// the focus the dock generates start generating alternating // the focus the dock generates start generating alternating
// focus due to the deferred execution each triggering each other // focus due to the deferred execution each triggering each other
cx.after_window_update(move |workspace, cx| { cx.after_window_update(move |workspace, cx| {
Dock::set_dock_position(workspace, serialized_workspace.dock_position, cx); Dock::set_dock_position(
workspace,
serialized_workspace.dock_position,
true,
cx,
);
}); });
cx.notify(); cx.notify();
@ -2538,6 +2662,11 @@ impl Workspace {
}) })
.detach(); .detach();
} }
#[cfg(any(test, feature = "test-support"))]
pub fn test_new(project: ModelHandle<Project>, cx: &mut ViewContext<Self>) -> Self {
Self::new(None, 0, project, |_, _| None, || &[], cx)
}
} }
fn notify_if_database_failed(workspace: &ViewHandle<Workspace>, cx: &mut AsyncAppContext) { fn notify_if_database_failed(workspace: &ViewHandle<Workspace>, cx: &mut AsyncAppContext) {
@ -2769,20 +2898,6 @@ impl std::fmt::Debug for OpenPaths {
} }
} }
fn open(_: &Open, cx: &mut MutableAppContext) {
let mut paths = cx.prompt_for_paths(PathPromptOptions {
files: true,
directories: true,
multiple: true,
});
cx.spawn(|mut cx| async move {
if let Some(paths) = paths.recv().await.flatten() {
cx.update(|cx| cx.dispatch_global_action(OpenPaths { paths }));
}
})
.detach();
}
pub struct WorkspaceCreated(WeakViewHandle<Workspace>); pub struct WorkspaceCreated(WeakViewHandle<Workspace>);
pub fn activate_workspace_for_project( pub fn activate_workspace_for_project(
@ -2809,6 +2924,7 @@ pub async fn last_opened_workspace_paths() -> Option<WorkspaceLocation> {
pub fn open_paths( pub fn open_paths(
abs_paths: &[PathBuf], abs_paths: &[PathBuf],
app_state: &Arc<AppState>, app_state: &Arc<AppState>,
requesting_window_id: Option<usize>,
cx: &mut MutableAppContext, cx: &mut MutableAppContext,
) -> Task<( ) -> Task<(
ViewHandle<Workspace>, ViewHandle<Workspace>,
@ -2839,7 +2955,8 @@ pub fn open_paths(
.contains(&false); .contains(&false);
cx.update(|cx| { cx.update(|cx| {
let task = Workspace::new_local(abs_paths, app_state.clone(), cx); let task =
Workspace::new_local(abs_paths, app_state.clone(), requesting_window_id, cx);
cx.spawn(|mut cx| async move { cx.spawn(|mut cx| async move {
let (workspace, items) = task.await; let (workspace, items) = task.await;
@ -2858,14 +2975,18 @@ pub fn open_paths(
}) })
} }
pub fn open_new(app_state: &Arc<AppState>, cx: &mut MutableAppContext) -> Task<()> { pub fn open_new(
let task = Workspace::new_local(Vec::new(), app_state.clone(), cx); app_state: &Arc<AppState>,
cx: &mut MutableAppContext,
init: impl FnOnce(&mut Workspace, &mut ViewContext<Workspace>) + 'static,
) -> Task<()> {
let task = Workspace::new_local(Vec::new(), app_state.clone(), None, cx);
cx.spawn(|mut cx| async move { cx.spawn(|mut cx| async move {
let (workspace, opened_paths) = task.await; let (workspace, opened_paths) = task.await;
workspace.update(&mut cx, |_, cx| { workspace.update(&mut cx, |workspace, cx| {
if opened_paths.is_empty() { if opened_paths.is_empty() {
cx.dispatch_action(NewFile); init(workspace, cx)
} }
}) })
}) })
@ -2886,17 +3007,10 @@ mod tests {
use super::*; use super::*;
use fs::FakeFs; use fs::FakeFs;
use gpui::{executor::Deterministic, TestAppContext, ViewContext}; use gpui::{executor::Deterministic, TestAppContext};
use project::{Project, ProjectEntryId}; use project::{Project, ProjectEntryId};
use serde_json::json; use serde_json::json;
pub fn default_item_factory(
_workspace: &mut Workspace,
_cx: &mut ViewContext<Workspace>,
) -> Option<Box<dyn ItemHandle>> {
unimplemented!()
}
#[gpui::test] #[gpui::test]
async fn test_tab_disambiguation(cx: &mut TestAppContext) { async fn test_tab_disambiguation(cx: &mut TestAppContext) {
cx.foreground().forbid_parking(); cx.foreground().forbid_parking();
@ -2909,7 +3023,8 @@ mod tests {
Default::default(), Default::default(),
0, 0,
project.clone(), project.clone(),
default_item_factory, |_, _| None,
|| &[],
cx, cx,
) )
}); });
@ -2981,7 +3096,8 @@ mod tests {
Default::default(), Default::default(),
0, 0,
project.clone(), project.clone(),
default_item_factory, |_, _| None,
|| &[],
cx, cx,
) )
}); });
@ -3081,7 +3197,8 @@ mod tests {
Default::default(), Default::default(),
0, 0,
project.clone(), project.clone(),
default_item_factory, |_, _| None,
|| &[],
cx, cx,
) )
}); });
@ -3120,7 +3237,7 @@ mod tests {
let project = Project::test(fs, None, cx).await; let project = Project::test(fs, None, cx).await;
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| {
Workspace::new(Default::default(), 0, project, default_item_factory, cx) Workspace::new(Default::default(), 0, project, |_, _| None, || &[], cx)
}); });
let item1 = cx.add_view(&workspace, |cx| { let item1 = cx.add_view(&workspace, |cx| {
@ -3229,7 +3346,7 @@ mod tests {
let project = Project::test(fs, [], cx).await; let project = Project::test(fs, [], cx).await;
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| {
Workspace::new(Default::default(), 0, project, default_item_factory, cx) Workspace::new(Default::default(), 0, project, |_, _| None, || &[], cx)
}); });
// Create several workspace items with single project entries, and two // Create several workspace items with single project entries, and two
@ -3338,7 +3455,7 @@ mod tests {
let project = Project::test(fs, [], cx).await; let project = Project::test(fs, [], cx).await;
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| {
Workspace::new(Default::default(), 0, project, default_item_factory, cx) Workspace::new(Default::default(), 0, project, |_, _| None, || &[], cx)
}); });
let item = cx.add_view(&workspace, |cx| { let item = cx.add_view(&workspace, |cx| {
@ -3457,7 +3574,7 @@ mod tests {
let project = Project::test(fs, [], cx).await; let project = Project::test(fs, [], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| {
Workspace::new(Default::default(), 0, project, default_item_factory, cx) Workspace::new(Default::default(), 0, project, |_, _| None, || &[], cx)
}); });
let item = cx.add_view(&workspace, |cx| { let item = cx.add_view(&workspace, |cx| {

3
crates/zed/Cargo.toml
View file

@ -29,6 +29,7 @@ context_menu = { path = "../context_menu" }
client = { path = "../client" } client = { path = "../client" }
clock = { path = "../clock" } clock = { path = "../clock" }
diagnostics = { path = "../diagnostics" } diagnostics = { path = "../diagnostics" }
db = { path = "../db" }
editor = { path = "../editor" } editor = { path = "../editor" }
feedback = { path = "../feedback" } feedback = { path = "../feedback" }
file_finder = { path = "../file_finder" } file_finder = { path = "../file_finder" }
@ -38,6 +39,7 @@ fsevent = { path = "../fsevent" }
fuzzy = { path = "../fuzzy" } fuzzy = { path = "../fuzzy" }
go_to_line = { path = "../go_to_line" } go_to_line = { path = "../go_to_line" }
gpui = { path = "../gpui" } gpui = { path = "../gpui" }
install_cli = { path = "../install_cli" }
journal = { path = "../journal" } journal = { path = "../journal" }
language = { path = "../language" } language = { path = "../language" }
language_selector = { path = "../language_selector" } language_selector = { path = "../language_selector" }
@ -59,6 +61,7 @@ theme_testbench = { path = "../theme_testbench" }
util = { path = "../util" } util = { path = "../util" }
vim = { path = "../vim" } vim = { path = "../vim" }
workspace = { path = "../workspace" } workspace = { path = "../workspace" }
welcome = { path = "../welcome" }
anyhow = "1.0.38" anyhow = "1.0.38"
async-compression = { version = "0.3", features = ["gzip", "futures-bufread"] } async-compression = { version = "0.3", features = ["gzip", "futures-bufread"] }
async-tar = "0.4.2" async-tar = "0.4.2"

54
crates/zed/src/main.rs
View file

@ -13,11 +13,12 @@ use client::{
http::{self, HttpClient}, http::{self, HttpClient},
UserStore, ZED_APP_VERSION, ZED_SECRET_CLIENT_TOKEN, UserStore, ZED_APP_VERSION, ZED_SECRET_CLIENT_TOKEN,
}; };
use db::kvp::KEY_VALUE_STORE;
use futures::{ use futures::{
channel::{mpsc, oneshot}, channel::{mpsc, oneshot},
FutureExt, SinkExt, StreamExt, FutureExt, SinkExt, StreamExt,
}; };
use gpui::{App, AssetSource, AsyncAppContext, MutableAppContext, Task, ViewContext}; use gpui::{Action, App, AssetSource, AsyncAppContext, MutableAppContext, Task, ViewContext};
use isahc::{config::Configurable, Request}; use isahc::{config::Configurable, Request};
use language::LanguageRegistry; use language::LanguageRegistry;
use log::LevelFilter; use log::LevelFilter;
@ -35,17 +36,19 @@ use std::{
path::PathBuf, sync::Arc, thread, time::Duration, path::PathBuf, sync::Arc, thread, time::Duration,
}; };
use terminal_view::{get_working_directory, TerminalView}; use terminal_view::{get_working_directory, TerminalView};
use welcome::{show_welcome_experience, FIRST_OPEN};
use fs::RealFs; use fs::RealFs;
use settings::watched_json::{watch_keymap_file, watch_settings_file, WatchedJsonFile}; use settings::watched_json::WatchedJsonFile;
use theme::ThemeRegistry; use theme::ThemeRegistry;
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
use util::StaffMode; use util::StaffMode;
use util::{channel::RELEASE_CHANNEL, paths, ResultExt, TryFutureExt}; use util::{channel::RELEASE_CHANNEL, paths, ResultExt, TryFutureExt};
use workspace::{ use workspace::{
self, item::ItemHandle, notifications::NotifyResultExt, AppState, NewFile, OpenPaths, Workspace, self, dock::FocusDock, item::ItemHandle, notifications::NotifyResultExt, AppState, NewFile,
OpenPaths, Workspace,
}; };
use zed::{self, build_window_options, initialize_workspace, languages, menus}; use zed::{self, build_window_options, initialize_workspace, languages, menus, OpenSettings};
fn main() { fn main() {
let http = http::client(); let http = http::client();
@ -119,7 +122,14 @@ fn main() {
fs.clone(), fs.clone(),
)); ));
watch_settings_file(default_settings, settings_file_content, themes.clone(), cx); settings::watch_files(
default_settings,
settings_file_content,
themes.clone(),
keymap_file,
cx,
);
if !stdout_is_a_pty() { if !stdout_is_a_pty() {
upload_previous_panics(http.clone(), cx); upload_previous_panics(http.clone(), cx);
} }
@ -132,8 +142,6 @@ fn main() {
languages::init(languages.clone()); languages::init(languages.clone());
let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http.clone(), cx)); let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http.clone(), cx));
watch_keymap_file(keymap_file, cx);
cx.set_global(client.clone()); cx.set_global(client.clone());
context_menu::init(cx); context_menu::init(cx);
@ -179,6 +187,7 @@ fn main() {
build_window_options, build_window_options,
initialize_workspace, initialize_workspace,
dock_default_item_factory, dock_default_item_factory,
background_actions,
}); });
auto_update::init(http, client::ZED_SERVER_URL.clone(), cx); auto_update::init(http, client::ZED_SERVER_URL.clone(), cx);
@ -190,6 +199,7 @@ fn main() {
zed::init(&app_state, cx); zed::init(&app_state, cx);
collab_ui::init(app_state.clone(), cx); collab_ui::init(app_state.clone(), cx);
feedback::init(app_state.clone(), cx); feedback::init(app_state.clone(), cx);
welcome::init(cx);
cx.set_menus(menus::menus()); cx.set_menus(menus::menus());
@ -197,7 +207,7 @@ fn main() {
cx.platform().activate(true); cx.platform().activate(true);
let paths = collect_path_args(); let paths = collect_path_args();
if paths.is_empty() { if paths.is_empty() {
cx.spawn(|cx| async move { restore_or_create_workspace(cx).await }) cx.spawn(|cx| async move { restore_or_create_workspace(&app_state, cx).await })
.detach() .detach()
} else { } else {
cx.dispatch_global_action(OpenPaths { paths }); cx.dispatch_global_action(OpenPaths { paths });
@ -207,11 +217,14 @@ fn main() {
cx.spawn(|cx| handle_cli_connection(connection, app_state.clone(), cx)) cx.spawn(|cx| handle_cli_connection(connection, app_state.clone(), cx))
.detach(); .detach();
} else if let Ok(Some(paths)) = open_paths_rx.try_next() { } else if let Ok(Some(paths)) = open_paths_rx.try_next() {
cx.update(|cx| workspace::open_paths(&paths, &app_state, cx)) cx.update(|cx| workspace::open_paths(&paths, &app_state, None, cx))
.detach(); .detach();
} else { } else {
cx.spawn(|cx| async move { restore_or_create_workspace(cx).await }) cx.spawn({
.detach() let app_state = app_state.clone();
|cx| async move { restore_or_create_workspace(&app_state, cx).await }
})
.detach()
} }
cx.spawn(|cx| { cx.spawn(|cx| {
@ -228,8 +241,7 @@ fn main() {
let app_state = app_state.clone(); let app_state = app_state.clone();
async move { async move {
while let Some(paths) = open_paths_rx.next().await { while let Some(paths) = open_paths_rx.next().await {
log::error!("OPEN PATHS FROM HANDLE"); cx.update(|cx| workspace::open_paths(&paths, &app_state, None, cx))
cx.update(|cx| workspace::open_paths(&paths, &app_state, cx))
.detach(); .detach();
} }
} }
@ -251,13 +263,15 @@ fn main() {
}); });
} }
async fn restore_or_create_workspace(mut cx: AsyncAppContext) { async fn restore_or_create_workspace(app_state: &Arc<AppState>, mut cx: AsyncAppContext) {
if let Some(location) = workspace::last_opened_workspace_paths().await { if let Some(location) = workspace::last_opened_workspace_paths().await {
cx.update(|cx| { cx.update(|cx| {
cx.dispatch_global_action(OpenPaths { cx.dispatch_global_action(OpenPaths {
paths: location.paths().as_ref().clone(), paths: location.paths().as_ref().clone(),
}) })
}); });
} else if matches!(KEY_VALUE_STORE.read_kvp(FIRST_OPEN), Ok(None)) {
cx.update(|cx| show_welcome_experience(app_state, cx));
} else { } else {
cx.update(|cx| { cx.update(|cx| {
cx.dispatch_global_action(NewFile); cx.dispatch_global_action(NewFile);
@ -591,7 +605,7 @@ async fn handle_cli_connection(
paths paths
}; };
let (workspace, items) = cx let (workspace, items) = cx
.update(|cx| workspace::open_paths(&paths, &app_state, cx)) .update(|cx| workspace::open_paths(&paths, &app_state, None, cx))
.await; .await;
let mut errored = false; let mut errored = false;
@ -692,3 +706,13 @@ pub fn dock_default_item_factory(
Some(Box::new(terminal_view)) Some(Box::new(terminal_view))
} }
pub fn background_actions() -> &'static [(&'static str, &'static dyn Action)] {
&[
("Go to file", &file_finder::Toggle),
("Open command palette", &command_palette::Toggle),
("Focus the dock", &FocusDock),
("Open recent projects", &recent_projects::OpenRecent),
("Change your settings", &OpenSettings),
]
}

5
crates/zed/src/menus.rs
View file

@ -19,7 +19,7 @@ pub fn menus() -> Vec<Menu<'static>> {
MenuItem::action("Select Theme", theme_selector::Toggle), MenuItem::action("Select Theme", theme_selector::Toggle),
], ],
}), }),
MenuItem::action("Install CLI", super::InstallCommandLineInterface), MenuItem::action("Install CLI", install_cli::Install),
MenuItem::separator(), MenuItem::separator(),
MenuItem::action("Hide Zed", super::Hide), MenuItem::action("Hide Zed", super::Hide),
MenuItem::action("Hide Others", super::HideOthers), MenuItem::action("Hide Others", super::HideOthers),
@ -137,8 +137,9 @@ pub fn menus() -> Vec<Menu<'static>> {
items: vec![ items: vec![
MenuItem::action("Command Palette", command_palette::Toggle), MenuItem::action("Command Palette", command_palette::Toggle),
MenuItem::separator(), MenuItem::separator(),
MenuItem::action("View Telemetry Log", crate::OpenTelemetryLog), MenuItem::action("View Telemetry", crate::OpenTelemetryLog),
MenuItem::action("View Dependency Licenses", crate::OpenLicenses), MenuItem::action("View Dependency Licenses", crate::OpenLicenses),
MenuItem::action("Show Welcome", workspace::Welcome),
MenuItem::separator(), MenuItem::separator(),
MenuItem::action( MenuItem::action(
"Copy System Specs Into Clipboard", "Copy System Specs Into Clipboard",

148
crates/zed/src/zed.rs
View file

@ -2,7 +2,7 @@ pub mod languages;
pub mod menus; pub mod menus;
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
pub mod test; pub mod test;
use anyhow::{anyhow, Context, Result}; use anyhow::Context;
use assets::Assets; use assets::Assets;
use breadcrumbs::Breadcrumbs; use breadcrumbs::Breadcrumbs;
pub use client; pub use client;
@ -20,7 +20,7 @@ use gpui::{
geometry::vector::vec2f, geometry::vector::vec2f,
impl_actions, impl_actions,
platform::{WindowBounds, WindowOptions}, platform::{WindowBounds, WindowOptions},
AssetSource, AsyncAppContext, Platform, PromptLevel, TitlebarOptions, ViewContext, WindowKind, AssetSource, Platform, PromptLevel, TitlebarOptions, ViewContext, WindowKind,
}; };
use language::Rope; use language::Rope;
pub use lsp; pub use lsp;
@ -65,7 +65,6 @@ actions!(
IncreaseBufferFontSize, IncreaseBufferFontSize,
DecreaseBufferFontSize, DecreaseBufferFontSize,
ResetBufferFontSize, ResetBufferFontSize,
InstallCommandLineInterface,
ResetDatabase, ResetDatabase,
] ]
); );
@ -140,9 +139,13 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut gpui::MutableAppContext) {
cx.refresh_windows(); cx.refresh_windows();
}); });
}); });
cx.add_global_action(move |_: &InstallCommandLineInterface, cx| { cx.add_global_action(move |_: &install_cli::Install, cx| {
cx.spawn(|cx| async move { install_cli(&cx).await.context("error creating CLI symlink") }) cx.spawn(|cx| async move {
.detach_and_log_err(cx); install_cli::install_cli(&cx)
.await
.context("error creating CLI symlink")
})
.detach_and_log_err(cx);
}); });
cx.add_action({ cx.add_action({
let app_state = app_state.clone(); let app_state = app_state.clone();
@ -255,7 +258,6 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut gpui::MutableAppContext) {
workspace.toggle_sidebar_item_focus(SidebarSide::Left, 0, cx); workspace.toggle_sidebar_item_focus(SidebarSide::Left, 0, cx);
}, },
); );
activity_indicator::init(cx); activity_indicator::init(cx);
call::init(app_state.client.clone(), app_state.user_store.clone(), cx); call::init(app_state.client.clone(), app_state.user_store.clone(), cx);
settings::KeymapFileContent::load_defaults(cx); settings::KeymapFileContent::load_defaults(cx);
@ -482,54 +484,6 @@ fn about(_: &mut Workspace, _: &About, cx: &mut gpui::ViewContext<Workspace>) {
); );
} }
async fn install_cli(cx: &AsyncAppContext) -> Result<()> {
let cli_path = cx.platform().path_for_auxiliary_executable("cli")?;
let link_path = Path::new("/usr/local/bin/zed");
let bin_dir_path = link_path.parent().unwrap();
// Don't re-create symlink if it points to the same CLI binary.
if smol::fs::read_link(link_path).await.ok().as_ref() == Some(&cli_path) {
return Ok(());
}
// If the symlink is not there or is outdated, first try replacing it
// without escalating.
smol::fs::remove_file(link_path).await.log_err();
if smol::fs::unix::symlink(&cli_path, link_path)
.await
.log_err()
.is_some()
{
return Ok(());
}
// The symlink could not be created, so use osascript with admin privileges
// to create it.
let status = smol::process::Command::new("osascript")
.args([
"-e",
&format!(
"do shell script \" \
mkdir -p \'{}\' && \
ln -sf \'{}\' \'{}\' \
\" with administrator privileges",
bin_dir_path.to_string_lossy(),
cli_path.to_string_lossy(),
link_path.to_string_lossy(),
),
])
.stdout(smol::process::Stdio::inherit())
.stderr(smol::process::Stdio::inherit())
.output()
.await?
.status;
if status.success() {
Ok(())
} else {
Err(anyhow!("error running osascript"))
}
}
fn open_config_file( fn open_config_file(
path: &'static Path, path: &'static Path,
app_state: Arc<AppState>, app_state: Arc<AppState>,
@ -758,6 +712,10 @@ mod tests {
"ca": null, "ca": null,
"cb": null, "cb": null,
}, },
"d": {
"da": null,
"db": null,
},
}), }),
) )
.await; .await;
@ -766,13 +724,14 @@ mod tests {
open_paths( open_paths(
&[PathBuf::from("/root/a"), PathBuf::from("/root/b")], &[PathBuf::from("/root/a"), PathBuf::from("/root/b")],
&app_state, &app_state,
None,
cx, cx,
) )
}) })
.await; .await;
assert_eq!(cx.window_ids().len(), 1); assert_eq!(cx.window_ids().len(), 1);
cx.update(|cx| open_paths(&[PathBuf::from("/root/a")], &app_state, cx)) cx.update(|cx| open_paths(&[PathBuf::from("/root/a")], &app_state, None, cx))
.await; .await;
assert_eq!(cx.window_ids().len(), 1); assert_eq!(cx.window_ids().len(), 1);
let workspace_1 = cx.root_view::<Workspace>(cx.window_ids()[0]).unwrap(); let workspace_1 = cx.root_view::<Workspace>(cx.window_ids()[0]).unwrap();
@ -786,11 +745,37 @@ mod tests {
open_paths( open_paths(
&[PathBuf::from("/root/b"), PathBuf::from("/root/c")], &[PathBuf::from("/root/b"), PathBuf::from("/root/c")],
&app_state, &app_state,
None,
cx, cx,
) )
}) })
.await; .await;
assert_eq!(cx.window_ids().len(), 2); assert_eq!(cx.window_ids().len(), 2);
// Replace existing windows
let window_id = cx.window_ids()[0];
cx.update(|cx| {
open_paths(
&[PathBuf::from("/root/c"), PathBuf::from("/root/d")],
&app_state,
Some(window_id),
cx,
)
})
.await;
assert_eq!(cx.window_ids().len(), 2);
let workspace_1 = cx.root_view::<Workspace>(window_id).unwrap();
workspace_1.read_with(cx, |workspace, cx| {
assert_eq!(
workspace
.worktrees(cx)
.map(|w| w.read(cx).abs_path())
.collect::<Vec<_>>(),
&[Path::new("/root/c").into(), Path::new("/root/d").into()]
);
assert!(workspace.left_sidebar().read(cx).is_open());
assert!(workspace.active_pane().is_focused(cx));
});
} }
#[gpui::test] #[gpui::test]
@ -802,7 +787,7 @@ mod tests {
.insert_tree("/root", json!({"a": "hey"})) .insert_tree("/root", json!({"a": "hey"}))
.await; .await;
cx.update(|cx| open_paths(&[PathBuf::from("/root/a")], &app_state, cx)) cx.update(|cx| open_paths(&[PathBuf::from("/root/a")], &app_state, None, cx))
.await; .await;
assert_eq!(cx.window_ids().len(), 1); assert_eq!(cx.window_ids().len(), 1);
@ -840,7 +825,7 @@ mod tests {
assert!(!cx.is_window_edited(workspace.window_id())); assert!(!cx.is_window_edited(workspace.window_id()));
// Opening the buffer again doesn't impact the window's edited state. // Opening the buffer again doesn't impact the window's edited state.
cx.update(|cx| open_paths(&[PathBuf::from("/root/a")], &app_state, cx)) cx.update(|cx| open_paths(&[PathBuf::from("/root/a")], &app_state, None, cx))
.await; .await;
let editor = workspace.read_with(cx, |workspace, cx| { let editor = workspace.read_with(cx, |workspace, cx| {
workspace workspace
@ -870,7 +855,8 @@ mod tests {
#[gpui::test] #[gpui::test]
async fn test_new_empty_workspace(cx: &mut TestAppContext) { async fn test_new_empty_workspace(cx: &mut TestAppContext) {
let app_state = init(cx); let app_state = init(cx);
cx.update(|cx| open_new(&app_state, cx)).await; cx.update(|cx| open_new(&app_state, cx, |_, cx| cx.dispatch_action(NewFile)))
.await;
let window_id = *cx.window_ids().first().unwrap(); let window_id = *cx.window_ids().first().unwrap();
let workspace = cx.root_view::<Workspace>(window_id).unwrap(); let workspace = cx.root_view::<Workspace>(window_id).unwrap();
@ -915,9 +901,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let entries = cx.read(|cx| workspace.file_project_paths(cx)); let entries = cx.read(|cx| workspace.file_project_paths(cx));
let file1 = entries[0].clone(); let file1 = entries[0].clone();
@ -1036,9 +1020,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/dir1".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/dir1".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
// Open a file within an existing worktree. // Open a file within an existing worktree.
cx.update(|cx| { cx.update(|cx| {
@ -1197,9 +1179,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
// Open a file within an existing worktree. // Open a file within an existing worktree.
cx.update(|cx| { cx.update(|cx| {
@ -1241,9 +1221,7 @@ mod tests {
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
project.update(cx, |project, _| project.languages().add(rust_lang())); project.update(cx, |project, _| project.languages().add(rust_lang()));
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let worktree = cx.read(|cx| workspace.read(cx).worktrees(cx).next().unwrap()); let worktree = cx.read(|cx| workspace.read(cx).worktrees(cx).next().unwrap());
// Create a new untitled buffer // Create a new untitled buffer
@ -1332,9 +1310,7 @@ mod tests {
let project = Project::test(app_state.fs.clone(), [], cx).await; let project = Project::test(app_state.fs.clone(), [], cx).await;
project.update(cx, |project, _| project.languages().add(rust_lang())); project.update(cx, |project, _| project.languages().add(rust_lang()));
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
// Create a new untitled buffer // Create a new untitled buffer
cx.dispatch_action(window_id, NewFile); cx.dispatch_action(window_id, NewFile);
@ -1387,9 +1363,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
let (window_id, workspace) = cx.add_window(|cx| { let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
});
let entries = cx.read(|cx| workspace.file_project_paths(cx)); let entries = cx.read(|cx| workspace.file_project_paths(cx));
let file1 = entries[0].clone(); let file1 = entries[0].clone();
@ -1463,15 +1437,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
Workspace::new(
Default::default(),
0,
project.clone(),
|_, _| unimplemented!(),
cx,
)
});
let entries = cx.read(|cx| workspace.file_project_paths(cx)); let entries = cx.read(|cx| workspace.file_project_paths(cx));
let file1 = entries[0].clone(); let file1 = entries[0].clone();
@ -1735,15 +1701,7 @@ mod tests {
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await; let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| { let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
Workspace::new(
Default::default(),
0,
project.clone(),
|_, _| unimplemented!(),
cx,
)
});
let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone()); let pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone());
let entries = cx.read(|cx| workspace.file_project_paths(cx)); let entries = cx.read(|cx| workspace.file_project_paths(cx));

2
script/generate-licenses
View file

@ -10,7 +10,7 @@ echo -e "# ###### THEME LICENSES ######\n" >> $OUTPUT_FILE
echo "Generating theme licenses" echo "Generating theme licenses"
cd styles cd styles
npm ci npm --silent ci
npm run --silent build-licenses >> $OUTPUT_FILE npm run --silent build-licenses >> $OUTPUT_FILE
cd .. cd ..

2
styles/src/styleTree/app.ts
View file

@ -20,6 +20,7 @@ import contactList from "./contactList"
import incomingCallNotification from "./incomingCallNotification" import incomingCallNotification from "./incomingCallNotification"
import { ColorScheme } from "../themes/common/colorScheme" import { ColorScheme } from "../themes/common/colorScheme"
import feedback from "./feedback" import feedback from "./feedback"
import welcome from "./welcome"
export default function app(colorScheme: ColorScheme): Object { export default function app(colorScheme: ColorScheme): Object {
return { return {
@ -33,6 +34,7 @@ export default function app(colorScheme: ColorScheme): Object {
incomingCallNotification: incomingCallNotification(colorScheme), incomingCallNotification: incomingCallNotification(colorScheme),
picker: picker(colorScheme), picker: picker(colorScheme),
workspace: workspace(colorScheme), workspace: workspace(colorScheme),
welcome: welcome(colorScheme),
contextMenu: contextMenu(colorScheme), contextMenu: contextMenu(colorScheme),
editor: editor(colorScheme), editor: editor(colorScheme),
projectDiagnostics: projectDiagnostics(colorScheme), projectDiagnostics: projectDiagnostics(colorScheme),

2
styles/src/styleTree/components.ts
View file

@ -93,7 +93,7 @@ interface Text {
underline?: boolean underline?: boolean
} }
interface TextProperties { export interface TextProperties {
size?: keyof typeof fontSizes size?: keyof typeof fontSizes
weight?: FontWeight weight?: FontWeight
underline?: boolean underline?: boolean

9
styles/src/styleTree/contextMenu.ts
View file

@ -26,14 +26,19 @@ export default function contextMenu(colorScheme: ColorScheme) {
hover: { hover: {
background: background(layer, "hovered"), background: background(layer, "hovered"),
label: text(layer, "sans", "hovered", { size: "sm" }), label: text(layer, "sans", "hovered", { size: "sm" }),
keystroke: {
...text(layer, "sans", "hovered", {
size: "sm",
weight: "bold",
}),
padding: { left: 3, right: 3 },
},
}, },
active: { active: {
background: background(layer, "active"), background: background(layer, "active"),
label: text(layer, "sans", "active", { size: "sm" }),
}, },
activeHover: { activeHover: {
background: background(layer, "active"), background: background(layer, "active"),
label: text(layer, "sans", "active", { size: "sm" }),
}, },
}, },
separator: { separator: {

22
styles/src/styleTree/projectPanel.ts
View file

@ -29,6 +29,28 @@ export default function projectPanel(colorScheme: ColorScheme) {
} }
return { return {
openProjectButton: {
background: background(layer),
border: border(layer, "active"),
cornerRadius: 4,
margin: {
top: 16,
left: 16,
right: 16,
},
padding: {
top: 3,
bottom: 3,
left: 7,
right: 7,
},
...text(layer, "sans", "default", { size: "sm" }),
hover: {
...text(layer, "sans", "default", { size: "sm" }),
background: background(layer, "hovered"),
border: border(layer, "active"),
},
},
background: background(layer), background: background(layer),
padding: { left: 12, right: 12, top: 6, bottom: 6 }, padding: { left: 12, right: 12, top: 6, bottom: 6 },
indentWidth: 8, indentWidth: 8,

139
styles/src/styleTree/welcome.ts Normal file
View file

@ -0,0 +1,139 @@
import { ColorScheme } from "../themes/common/colorScheme";
import { withOpacity } from "../utils/color";
import { border, background, foreground, text, TextProperties } from "./components";
export default function welcome(colorScheme: ColorScheme) {
let layer = colorScheme.highest;
let checkboxBase = {
cornerRadius: 4,
padding: {
left: 3,
right: 3,
top: 3,
bottom: 3,
},
// shadow: colorScheme.popoverShadow,
border: border(layer),
margin: {
right: 8,
top: 5,
bottom: 5
},
};
let interactive_text_size: TextProperties = { size: "sm" }
return {
pageWidth: 320,
logo: {
color: foreground(layer, "default"),
icon: "icons/logo_96.svg",
dimensions: {
width: 64,
height: 64,
}
},
logoSubheading: {
...text(layer, "sans", "variant", { size: "md" }),
margin: {
top: 10,
bottom: 7,
},
},
buttonGroup: {
margin: {
top: 8,
bottom: 16
},
},
headingGroup: {
margin: {
top: 8,
bottom: 12
},
},
checkboxGroup: {
border: border(layer, "variant"),
background: withOpacity(background(layer, "hovered"), 0.25),
cornerRadius: 4,
padding: {
left: 12,
top: 2,
bottom: 2
},
},
button: {
background: background(layer),
border: border(layer, "active"),
cornerRadius: 4,
margin: {
top: 4,
bottom: 4
},
padding: {
top: 3,
bottom: 3,
left: 7,
right: 7,
},
...text(layer, "sans", "default", interactive_text_size),
hover: {
...text(layer, "sans", "default", interactive_text_size),
background: background(layer, "hovered"),
border: border(layer, "active"),
},
},
usageNote: {
...text(layer, "sans", "variant", { size: "2xs" }),
padding: {
top: -4,
}
},
checkboxContainer: {
margin: {
top: 4,
},
padding: {
bottom: 8,
}
},
checkbox: {
label: {
...text(layer, "sans", interactive_text_size),
// Also supports margin, container, border, etc.
},
icon: {
color: foreground(layer, "on"),
icon: "icons/check_12.svg",
dimensions: {
width: 12,
height: 12,
}
},
default: {
...checkboxBase,
background: background(layer, "default"),
border: border(layer, "active")
},
checked: {
...checkboxBase,
background: background(layer, "hovered"),
border: border(layer, "active")
},
hovered: {
...checkboxBase,
background: background(layer, "hovered"),
border: border(layer, "active")
},
hoveredAndChecked: {
...checkboxBase,
background: background(layer, "hovered"),
border: border(layer, "active")
}
}
}
}

46
styles/src/styleTree/workspace.ts
View file

@ -40,7 +40,49 @@ export default function workspace(colorScheme: ColorScheme) {
const followerAvatarOuterWidth = followerAvatarWidth + 4 const followerAvatarOuterWidth = followerAvatarWidth + 4
return { return {
background: background(layer), background: background(colorScheme.lowest),
blankPane: {
logoContainer: {
width: 256,
height: 256,
},
logo: {
color: withOpacity("#000000", colorScheme.isLight ? 0.6 : 0.8),
icon: "icons/logo_96.svg",
dimensions: {
width: 256,
height: 256,
},
},
logoShadow: {
color: withOpacity(colorScheme.isLight ? "#FFFFFF" : colorScheme.lowest.base.default.background, colorScheme.isLight ? 1 : 0.6),
icon: "icons/logo_96.svg",
dimensions: {
width: 256,
height: 256,
},
},
keyboardHints: {
margin: {
top: 96,
},
cornerRadius: 4,
},
keyboardHint: {
...text(layer, "sans", "variant", { size: "sm" }),
padding: {
top: 3,
left: 8,
right: 8,
bottom: 3
},
cornerRadius: 8,
hover: {
...text(layer, "sans", "active", { size: "sm" }),
}
},
keyboardHintWidth: 320,
},
joiningProjectAvatar: { joiningProjectAvatar: {
cornerRadius: 40, cornerRadius: 40,
width: 80, width: 80,
@ -248,7 +290,7 @@ export default function workspace(colorScheme: ColorScheme) {
}, },
dock: { dock: {
initialSizeRight: 640, initialSizeRight: 640,
initialSizeBottom: 480, initialSizeBottom: 304,
wash_color: withOpacity(background(colorScheme.highest), 0.5), wash_color: withOpacity(background(colorScheme.highest), 0.5),
panel: { panel: {
border: border(colorScheme.middle), border: border(colorScheme.middle),