1pub mod lsp_status;
2pub mod menu;
3pub mod pane;
4pub mod pane_group;
5pub mod sidebar;
6mod status_bar;
7mod toolbar;
8
9use anyhow::{anyhow, Context, Result};
10use client::{
11 proto, Authenticate, ChannelList, Client, PeerId, Subscription, TypedEnvelope, User, UserStore,
12};
13use clock::ReplicaId;
14use collections::{hash_map, HashMap, HashSet};
15use gpui::{
16 actions,
17 color::Color,
18 elements::*,
19 geometry::{rect::RectF, vector::vec2f, PathBuilder},
20 impl_internal_actions,
21 json::{self, ToJson},
22 platform::{CursorStyle, WindowOptions},
23 AnyModelHandle, AnyViewHandle, AppContext, AsyncAppContext, Border, Entity, ImageData,
24 ModelHandle, MutableAppContext, PathPromptOptions, PromptLevel, RenderContext, Task, View,
25 ViewContext, ViewHandle, WeakViewHandle,
26};
27use language::LanguageRegistry;
28use log::error;
29pub use pane::*;
30pub use pane_group::*;
31use postage::prelude::Stream;
32use project::{fs, Fs, Project, ProjectEntryId, ProjectPath, Worktree};
33use settings::Settings;
34use sidebar::{Side, Sidebar, SidebarButtons, ToggleSidebarItem, ToggleSidebarItemFocus};
35use status_bar::StatusBar;
36pub use status_bar::StatusItemView;
37use std::{
38 any::{Any, TypeId},
39 cell::RefCell,
40 fmt,
41 future::Future,
42 path::{Path, PathBuf},
43 rc::Rc,
44 sync::{
45 atomic::{AtomicBool, Ordering::SeqCst},
46 Arc,
47 },
48};
49use theme::{Theme, ThemeRegistry};
50pub use toolbar::{ToolbarItemLocation, ToolbarItemView};
51use util::ResultExt;
52
53type ProjectItemBuilders = HashMap<
54 TypeId,
55 fn(usize, ModelHandle<Project>, AnyModelHandle, &mut MutableAppContext) -> Box<dyn ItemHandle>,
56>;
57
58type FollowableItemBuilder = fn(
59 ViewHandle<Pane>,
60 ModelHandle<Project>,
61 &mut Option<proto::view::Variant>,
62 &mut MutableAppContext,
63) -> Option<Task<Result<Box<dyn FollowableItemHandle>>>>;
64type FollowableItemBuilders = HashMap<
65 TypeId,
66 (
67 FollowableItemBuilder,
68 fn(AnyViewHandle) -> Box<dyn FollowableItemHandle>,
69 ),
70>;
71
72actions!(
73 workspace,
74 [
75 ToggleShare,
76 Unfollow,
77 Save,
78 ActivatePreviousPane,
79 ActivateNextPane,
80 FollowNextCollaborator,
81 ]
82);
83
84#[derive(Clone)]
85pub struct Open(pub Arc<AppState>);
86
87#[derive(Clone)]
88pub struct OpenNew(pub Arc<AppState>);
89
90#[derive(Clone)]
91pub struct OpenPaths {
92 pub paths: Vec<PathBuf>,
93 pub app_state: Arc<AppState>,
94}
95
96#[derive(Clone)]
97pub struct ToggleFollow(pub PeerId);
98
99#[derive(Clone)]
100pub struct JoinProject {
101 pub project_id: u64,
102 pub app_state: Arc<AppState>,
103}
104
105impl_internal_actions!(
106 workspace,
107 [Open, OpenNew, OpenPaths, ToggleFollow, JoinProject]
108);
109
110pub fn init(client: &Arc<Client>, cx: &mut MutableAppContext) {
111 pane::init(cx);
112
113 cx.add_global_action(open);
114 cx.add_global_action(move |action: &OpenPaths, cx: &mut MutableAppContext| {
115 open_paths(&action.paths, &action.app_state, cx).detach();
116 });
117 cx.add_global_action(move |action: &OpenNew, cx: &mut MutableAppContext| {
118 open_new(&action.0, cx)
119 });
120 cx.add_global_action(move |action: &JoinProject, cx: &mut MutableAppContext| {
121 join_project(action.project_id, &action.app_state, cx).detach();
122 });
123
124 cx.add_action(Workspace::toggle_share);
125 cx.add_async_action(Workspace::toggle_follow);
126 cx.add_async_action(Workspace::follow_next_collaborator);
127 cx.add_action(
128 |workspace: &mut Workspace, _: &Unfollow, cx: &mut ViewContext<Workspace>| {
129 let pane = workspace.active_pane().clone();
130 workspace.unfollow(&pane, cx);
131 },
132 );
133 cx.add_action(
134 |workspace: &mut Workspace, _: &Save, cx: &mut ViewContext<Workspace>| {
135 workspace.save_active_item(cx).detach_and_log_err(cx);
136 },
137 );
138 cx.add_action(Workspace::toggle_sidebar_item);
139 cx.add_action(Workspace::toggle_sidebar_item_focus);
140 cx.add_action(|workspace: &mut Workspace, _: &ActivatePreviousPane, cx| {
141 workspace.activate_previous_pane(cx)
142 });
143 cx.add_action(|workspace: &mut Workspace, _: &ActivateNextPane, cx| {
144 workspace.activate_next_pane(cx)
145 });
146
147 client.add_view_request_handler(Workspace::handle_follow);
148 client.add_view_message_handler(Workspace::handle_unfollow);
149 client.add_view_message_handler(Workspace::handle_update_followers);
150}
151
152pub fn register_project_item<I: ProjectItem>(cx: &mut MutableAppContext) {
153 cx.update_default_global(|builders: &mut ProjectItemBuilders, _| {
154 builders.insert(TypeId::of::<I::Item>(), |window_id, project, model, cx| {
155 let item = model.downcast::<I::Item>().unwrap();
156 Box::new(cx.add_view(window_id, |cx| I::for_project_item(project, item, cx)))
157 });
158 });
159}
160
161pub fn register_followable_item<I: FollowableItem>(cx: &mut MutableAppContext) {
162 cx.update_default_global(|builders: &mut FollowableItemBuilders, _| {
163 builders.insert(
164 TypeId::of::<I>(),
165 (
166 |pane, project, state, cx| {
167 I::from_state_proto(pane, project, state, cx).map(|task| {
168 cx.foreground()
169 .spawn(async move { Ok(Box::new(task.await?) as Box<_>) })
170 })
171 },
172 |this| Box::new(this.downcast::<I>().unwrap()),
173 ),
174 );
175 });
176}
177
178pub struct AppState {
179 pub languages: Arc<LanguageRegistry>,
180 pub themes: Arc<ThemeRegistry>,
181 pub client: Arc<client::Client>,
182 pub user_store: ModelHandle<client::UserStore>,
183 pub fs: Arc<dyn fs::Fs>,
184 pub channel_list: ModelHandle<client::ChannelList>,
185 pub build_window_options: fn() -> WindowOptions<'static>,
186 pub build_workspace:
187 fn(ModelHandle<Project>, &Arc<AppState>, &mut ViewContext<Workspace>) -> Workspace,
188}
189
190pub trait Item: View {
191 fn deactivated(&mut self, _: &mut ViewContext<Self>) {}
192 fn navigate(&mut self, _: Box<dyn Any>, _: &mut ViewContext<Self>) -> bool {
193 false
194 }
195 fn tab_content(&self, style: &theme::Tab, cx: &AppContext) -> ElementBox;
196 fn project_path(&self, cx: &AppContext) -> Option<ProjectPath>;
197 fn project_entry_id(&self, cx: &AppContext) -> Option<ProjectEntryId>;
198 fn set_nav_history(&mut self, _: ItemNavHistory, _: &mut ViewContext<Self>);
199 fn clone_on_split(&self, _: &mut ViewContext<Self>) -> Option<Self>
200 where
201 Self: Sized,
202 {
203 None
204 }
205 fn is_dirty(&self, _: &AppContext) -> bool {
206 false
207 }
208 fn has_conflict(&self, _: &AppContext) -> bool {
209 false
210 }
211 fn can_save(&self, cx: &AppContext) -> bool;
212 fn save(
213 &mut self,
214 project: ModelHandle<Project>,
215 cx: &mut ViewContext<Self>,
216 ) -> Task<Result<()>>;
217 fn can_save_as(&self, cx: &AppContext) -> bool;
218 fn save_as(
219 &mut self,
220 project: ModelHandle<Project>,
221 abs_path: PathBuf,
222 cx: &mut ViewContext<Self>,
223 ) -> Task<Result<()>>;
224 fn reload(
225 &mut self,
226 project: ModelHandle<Project>,
227 cx: &mut ViewContext<Self>,
228 ) -> Task<Result<()>>;
229 fn should_activate_item_on_event(_: &Self::Event) -> bool {
230 false
231 }
232 fn should_close_item_on_event(_: &Self::Event) -> bool {
233 false
234 }
235 fn should_update_tab_on_event(_: &Self::Event) -> bool {
236 false
237 }
238 fn act_as_type(
239 &self,
240 type_id: TypeId,
241 self_handle: &ViewHandle<Self>,
242 _: &AppContext,
243 ) -> Option<AnyViewHandle> {
244 if TypeId::of::<Self>() == type_id {
245 Some(self_handle.into())
246 } else {
247 None
248 }
249 }
250}
251
252pub trait ProjectItem: Item {
253 type Item: project::Item;
254
255 fn for_project_item(
256 project: ModelHandle<Project>,
257 item: ModelHandle<Self::Item>,
258 cx: &mut ViewContext<Self>,
259 ) -> Self;
260}
261
262pub trait FollowableItem: Item {
263 fn to_state_proto(&self, cx: &AppContext) -> Option<proto::view::Variant>;
264 fn from_state_proto(
265 pane: ViewHandle<Pane>,
266 project: ModelHandle<Project>,
267 state: &mut Option<proto::view::Variant>,
268 cx: &mut MutableAppContext,
269 ) -> Option<Task<Result<ViewHandle<Self>>>>;
270 fn add_event_to_update_proto(
271 &self,
272 event: &Self::Event,
273 update: &mut Option<proto::update_view::Variant>,
274 cx: &AppContext,
275 ) -> bool;
276 fn apply_update_proto(
277 &mut self,
278 message: proto::update_view::Variant,
279 cx: &mut ViewContext<Self>,
280 ) -> Result<()>;
281
282 fn set_leader_replica_id(&mut self, leader_replica_id: Option<u16>, cx: &mut ViewContext<Self>);
283 fn should_unfollow_on_event(event: &Self::Event, cx: &AppContext) -> bool;
284}
285
286pub trait FollowableItemHandle: ItemHandle {
287 fn set_leader_replica_id(&self, leader_replica_id: Option<u16>, cx: &mut MutableAppContext);
288 fn to_state_proto(&self, cx: &AppContext) -> Option<proto::view::Variant>;
289 fn add_event_to_update_proto(
290 &self,
291 event: &dyn Any,
292 update: &mut Option<proto::update_view::Variant>,
293 cx: &AppContext,
294 ) -> bool;
295 fn apply_update_proto(
296 &self,
297 message: proto::update_view::Variant,
298 cx: &mut MutableAppContext,
299 ) -> Result<()>;
300 fn should_unfollow_on_event(&self, event: &dyn Any, cx: &AppContext) -> bool;
301}
302
303impl<T: FollowableItem> FollowableItemHandle for ViewHandle<T> {
304 fn set_leader_replica_id(&self, leader_replica_id: Option<u16>, cx: &mut MutableAppContext) {
305 self.update(cx, |this, cx| {
306 this.set_leader_replica_id(leader_replica_id, cx)
307 })
308 }
309
310 fn to_state_proto(&self, cx: &AppContext) -> Option<proto::view::Variant> {
311 self.read(cx).to_state_proto(cx)
312 }
313
314 fn add_event_to_update_proto(
315 &self,
316 event: &dyn Any,
317 update: &mut Option<proto::update_view::Variant>,
318 cx: &AppContext,
319 ) -> bool {
320 if let Some(event) = event.downcast_ref() {
321 self.read(cx).add_event_to_update_proto(event, update, cx)
322 } else {
323 false
324 }
325 }
326
327 fn apply_update_proto(
328 &self,
329 message: proto::update_view::Variant,
330 cx: &mut MutableAppContext,
331 ) -> Result<()> {
332 self.update(cx, |this, cx| this.apply_update_proto(message, cx))
333 }
334
335 fn should_unfollow_on_event(&self, event: &dyn Any, cx: &AppContext) -> bool {
336 if let Some(event) = event.downcast_ref() {
337 T::should_unfollow_on_event(event, cx)
338 } else {
339 false
340 }
341 }
342}
343
344pub trait ItemHandle: 'static + fmt::Debug {
345 fn tab_content(&self, style: &theme::Tab, cx: &AppContext) -> ElementBox;
346 fn project_path(&self, cx: &AppContext) -> Option<ProjectPath>;
347 fn project_entry_id(&self, cx: &AppContext) -> Option<ProjectEntryId>;
348 fn boxed_clone(&self) -> Box<dyn ItemHandle>;
349 fn set_nav_history(&self, nav_history: Rc<RefCell<NavHistory>>, cx: &mut MutableAppContext);
350 fn clone_on_split(&self, cx: &mut MutableAppContext) -> Option<Box<dyn ItemHandle>>;
351 fn added_to_pane(
352 &self,
353 workspace: &mut Workspace,
354 pane: ViewHandle<Pane>,
355 cx: &mut ViewContext<Workspace>,
356 );
357 fn deactivated(&self, cx: &mut MutableAppContext);
358 fn navigate(&self, data: Box<dyn Any>, cx: &mut MutableAppContext) -> bool;
359 fn id(&self) -> usize;
360 fn to_any(&self) -> AnyViewHandle;
361 fn is_dirty(&self, cx: &AppContext) -> bool;
362 fn has_conflict(&self, cx: &AppContext) -> bool;
363 fn can_save(&self, cx: &AppContext) -> bool;
364 fn can_save_as(&self, cx: &AppContext) -> bool;
365 fn save(&self, project: ModelHandle<Project>, cx: &mut MutableAppContext) -> Task<Result<()>>;
366 fn save_as(
367 &self,
368 project: ModelHandle<Project>,
369 abs_path: PathBuf,
370 cx: &mut MutableAppContext,
371 ) -> Task<Result<()>>;
372 fn reload(&self, project: ModelHandle<Project>, cx: &mut MutableAppContext)
373 -> Task<Result<()>>;
374 fn act_as_type(&self, type_id: TypeId, cx: &AppContext) -> Option<AnyViewHandle>;
375 fn to_followable_item_handle(&self, cx: &AppContext) -> Option<Box<dyn FollowableItemHandle>>;
376 fn on_release(
377 &self,
378 cx: &mut MutableAppContext,
379 callback: Box<dyn FnOnce(&mut MutableAppContext)>,
380 ) -> gpui::Subscription;
381}
382
383pub trait WeakItemHandle {
384 fn id(&self) -> usize;
385 fn upgrade(&self, cx: &AppContext) -> Option<Box<dyn ItemHandle>>;
386}
387
388impl dyn ItemHandle {
389 pub fn downcast<T: View>(&self) -> Option<ViewHandle<T>> {
390 self.to_any().downcast()
391 }
392
393 pub fn act_as<T: View>(&self, cx: &AppContext) -> Option<ViewHandle<T>> {
394 self.act_as_type(TypeId::of::<T>(), cx)
395 .and_then(|t| t.downcast())
396 }
397}
398
399impl<T: Item> ItemHandle for ViewHandle<T> {
400 fn tab_content(&self, style: &theme::Tab, cx: &AppContext) -> ElementBox {
401 self.read(cx).tab_content(style, cx)
402 }
403
404 fn project_path(&self, cx: &AppContext) -> Option<ProjectPath> {
405 self.read(cx).project_path(cx)
406 }
407
408 fn project_entry_id(&self, cx: &AppContext) -> Option<ProjectEntryId> {
409 self.read(cx).project_entry_id(cx)
410 }
411
412 fn boxed_clone(&self) -> Box<dyn ItemHandle> {
413 Box::new(self.clone())
414 }
415
416 fn set_nav_history(&self, nav_history: Rc<RefCell<NavHistory>>, cx: &mut MutableAppContext) {
417 self.update(cx, |item, cx| {
418 item.set_nav_history(ItemNavHistory::new(nav_history, &cx.handle()), cx);
419 })
420 }
421
422 fn clone_on_split(&self, cx: &mut MutableAppContext) -> Option<Box<dyn ItemHandle>> {
423 self.update(cx, |item, cx| {
424 cx.add_option_view(|cx| item.clone_on_split(cx))
425 })
426 .map(|handle| Box::new(handle) as Box<dyn ItemHandle>)
427 }
428
429 fn added_to_pane(
430 &self,
431 workspace: &mut Workspace,
432 pane: ViewHandle<Pane>,
433 cx: &mut ViewContext<Workspace>,
434 ) {
435 if let Some(followed_item) = self.to_followable_item_handle(cx) {
436 if let Some(message) = followed_item.to_state_proto(cx) {
437 workspace.update_followers(
438 proto::update_followers::Variant::CreateView(proto::View {
439 id: followed_item.id() as u64,
440 variant: Some(message),
441 leader_id: workspace.leader_for_pane(&pane).map(|id| id.0),
442 }),
443 cx,
444 );
445 }
446 }
447
448 let pending_update = Rc::new(RefCell::new(None));
449 let pending_update_scheduled = Rc::new(AtomicBool::new(false));
450 let pane = pane.downgrade();
451 cx.subscribe(self, move |workspace, item, event, cx| {
452 let pane = if let Some(pane) = pane.upgrade(cx) {
453 pane
454 } else {
455 log::error!("unexpected item event after pane was dropped");
456 return;
457 };
458
459 if let Some(item) = item.to_followable_item_handle(cx) {
460 let leader_id = workspace.leader_for_pane(&pane);
461
462 if leader_id.is_some() && item.should_unfollow_on_event(event, cx) {
463 workspace.unfollow(&pane, cx);
464 }
465
466 if item.add_event_to_update_proto(event, &mut *pending_update.borrow_mut(), cx)
467 && !pending_update_scheduled.load(SeqCst)
468 {
469 pending_update_scheduled.store(true, SeqCst);
470 cx.after_window_update({
471 let pending_update = pending_update.clone();
472 let pending_update_scheduled = pending_update_scheduled.clone();
473 move |this, cx| {
474 pending_update_scheduled.store(false, SeqCst);
475 this.update_followers(
476 proto::update_followers::Variant::UpdateView(proto::UpdateView {
477 id: item.id() as u64,
478 variant: pending_update.borrow_mut().take(),
479 leader_id: leader_id.map(|id| id.0),
480 }),
481 cx,
482 );
483 }
484 });
485 }
486 }
487
488 if T::should_close_item_on_event(event) {
489 Pane::close_item(workspace, pane, item.id(), cx).detach_and_log_err(cx);
490 return;
491 }
492
493 if T::should_activate_item_on_event(event) {
494 pane.update(cx, |pane, cx| {
495 if let Some(ix) = pane.index_for_item(&item) {
496 pane.activate_item(ix, true, true, cx);
497 pane.activate(cx);
498 }
499 });
500 }
501
502 if T::should_update_tab_on_event(event) {
503 pane.update(cx, |_, cx| cx.notify());
504 }
505 })
506 .detach();
507 }
508
509 fn deactivated(&self, cx: &mut MutableAppContext) {
510 self.update(cx, |this, cx| this.deactivated(cx));
511 }
512
513 fn navigate(&self, data: Box<dyn Any>, cx: &mut MutableAppContext) -> bool {
514 self.update(cx, |this, cx| this.navigate(data, cx))
515 }
516
517 fn id(&self) -> usize {
518 self.id()
519 }
520
521 fn to_any(&self) -> AnyViewHandle {
522 self.into()
523 }
524
525 fn is_dirty(&self, cx: &AppContext) -> bool {
526 self.read(cx).is_dirty(cx)
527 }
528
529 fn has_conflict(&self, cx: &AppContext) -> bool {
530 self.read(cx).has_conflict(cx)
531 }
532
533 fn can_save(&self, cx: &AppContext) -> bool {
534 self.read(cx).can_save(cx)
535 }
536
537 fn can_save_as(&self, cx: &AppContext) -> bool {
538 self.read(cx).can_save_as(cx)
539 }
540
541 fn save(&self, project: ModelHandle<Project>, cx: &mut MutableAppContext) -> Task<Result<()>> {
542 self.update(cx, |item, cx| item.save(project, cx))
543 }
544
545 fn save_as(
546 &self,
547 project: ModelHandle<Project>,
548 abs_path: PathBuf,
549 cx: &mut MutableAppContext,
550 ) -> Task<anyhow::Result<()>> {
551 self.update(cx, |item, cx| item.save_as(project, abs_path, cx))
552 }
553
554 fn reload(
555 &self,
556 project: ModelHandle<Project>,
557 cx: &mut MutableAppContext,
558 ) -> Task<Result<()>> {
559 self.update(cx, |item, cx| item.reload(project, cx))
560 }
561
562 fn act_as_type(&self, type_id: TypeId, cx: &AppContext) -> Option<AnyViewHandle> {
563 self.read(cx).act_as_type(type_id, self, cx)
564 }
565
566 fn to_followable_item_handle(&self, cx: &AppContext) -> Option<Box<dyn FollowableItemHandle>> {
567 if cx.has_global::<FollowableItemBuilders>() {
568 let builders = cx.global::<FollowableItemBuilders>();
569 let item = self.to_any();
570 Some(builders.get(&item.view_type())?.1(item))
571 } else {
572 None
573 }
574 }
575
576 fn on_release(
577 &self,
578 cx: &mut MutableAppContext,
579 callback: Box<dyn FnOnce(&mut MutableAppContext)>,
580 ) -> gpui::Subscription {
581 cx.observe_release(self, move |_, cx| callback(cx))
582 }
583}
584
585impl Into<AnyViewHandle> for Box<dyn ItemHandle> {
586 fn into(self) -> AnyViewHandle {
587 self.to_any()
588 }
589}
590
591impl Clone for Box<dyn ItemHandle> {
592 fn clone(&self) -> Box<dyn ItemHandle> {
593 self.boxed_clone()
594 }
595}
596
597impl<T: Item> WeakItemHandle for WeakViewHandle<T> {
598 fn id(&self) -> usize {
599 self.id()
600 }
601
602 fn upgrade(&self, cx: &AppContext) -> Option<Box<dyn ItemHandle>> {
603 self.upgrade(cx).map(|v| Box::new(v) as Box<dyn ItemHandle>)
604 }
605}
606
607#[derive(Clone)]
608pub struct WorkspaceParams {
609 pub project: ModelHandle<Project>,
610 pub client: Arc<Client>,
611 pub fs: Arc<dyn Fs>,
612 pub languages: Arc<LanguageRegistry>,
613 pub themes: Arc<ThemeRegistry>,
614 pub user_store: ModelHandle<UserStore>,
615 pub channel_list: ModelHandle<ChannelList>,
616}
617
618impl WorkspaceParams {
619 #[cfg(any(test, feature = "test-support"))]
620 pub fn test(cx: &mut MutableAppContext) -> Self {
621 let settings = Settings::test(cx);
622 cx.set_global(settings);
623
624 let fs = project::FakeFs::new(cx.background().clone());
625 let languages = Arc::new(LanguageRegistry::test());
626 let http_client = client::test::FakeHttpClient::with_404_response();
627 let client = Client::new(http_client.clone());
628 let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http_client, cx));
629 let project = Project::local(
630 client.clone(),
631 user_store.clone(),
632 languages.clone(),
633 fs.clone(),
634 cx,
635 );
636 Self {
637 project,
638 channel_list: cx
639 .add_model(|cx| ChannelList::new(user_store.clone(), client.clone(), cx)),
640 client,
641 themes: ThemeRegistry::new((), cx.font_cache().clone()),
642 fs,
643 languages,
644 user_store,
645 }
646 }
647
648 #[cfg(any(test, feature = "test-support"))]
649 pub fn local(app_state: &Arc<AppState>, cx: &mut MutableAppContext) -> Self {
650 Self {
651 project: Project::local(
652 app_state.client.clone(),
653 app_state.user_store.clone(),
654 app_state.languages.clone(),
655 app_state.fs.clone(),
656 cx,
657 ),
658 client: app_state.client.clone(),
659 fs: app_state.fs.clone(),
660 themes: app_state.themes.clone(),
661 languages: app_state.languages.clone(),
662 user_store: app_state.user_store.clone(),
663 channel_list: app_state.channel_list.clone(),
664 }
665 }
666}
667
668pub enum Event {
669 PaneAdded(ViewHandle<Pane>),
670}
671
672pub struct Workspace {
673 weak_self: WeakViewHandle<Self>,
674 client: Arc<Client>,
675 user_store: ModelHandle<client::UserStore>,
676 remote_entity_subscription: Option<Subscription>,
677 fs: Arc<dyn Fs>,
678 themes: Arc<ThemeRegistry>,
679 modal: Option<AnyViewHandle>,
680 center: PaneGroup,
681 left_sidebar: ViewHandle<Sidebar>,
682 right_sidebar: ViewHandle<Sidebar>,
683 panes: Vec<ViewHandle<Pane>>,
684 active_pane: ViewHandle<Pane>,
685 status_bar: ViewHandle<StatusBar>,
686 project: ModelHandle<Project>,
687 leader_state: LeaderState,
688 follower_states_by_leader: FollowerStatesByLeader,
689 last_leaders_by_pane: HashMap<WeakViewHandle<Pane>, PeerId>,
690 _observe_current_user: Task<()>,
691}
692
693#[derive(Default)]
694struct LeaderState {
695 followers: HashSet<PeerId>,
696}
697
698type FollowerStatesByLeader = HashMap<PeerId, HashMap<ViewHandle<Pane>, FollowerState>>;
699
700#[derive(Default)]
701struct FollowerState {
702 active_view_id: Option<u64>,
703 items_by_leader_view_id: HashMap<u64, FollowerItem>,
704}
705
706#[derive(Debug)]
707enum FollowerItem {
708 Loading(Vec<proto::update_view::Variant>),
709 Loaded(Box<dyn FollowableItemHandle>),
710}
711
712impl Workspace {
713 pub fn new(params: &WorkspaceParams, cx: &mut ViewContext<Self>) -> Self {
714 cx.observe(¶ms.project, |_, project, cx| {
715 if project.read(cx).is_read_only() {
716 cx.blur();
717 }
718 cx.notify()
719 })
720 .detach();
721
722 cx.subscribe(¶ms.project, move |this, project, event, cx| {
723 match event {
724 project::Event::RemoteIdChanged(remote_id) => {
725 this.project_remote_id_changed(*remote_id, cx);
726 }
727 project::Event::CollaboratorLeft(peer_id) => {
728 this.collaborator_left(*peer_id, cx);
729 }
730 _ => {}
731 }
732 if project.read(cx).is_read_only() {
733 cx.blur();
734 }
735 cx.notify()
736 })
737 .detach();
738
739 let pane = cx.add_view(|cx| Pane::new(cx));
740 let pane_id = pane.id();
741 cx.observe(&pane, move |me, _, cx| {
742 let active_entry = me.active_project_path(cx);
743 me.project
744 .update(cx, |project, cx| project.set_active_path(active_entry, cx));
745 })
746 .detach();
747 cx.subscribe(&pane, move |me, _, event, cx| {
748 me.handle_pane_event(pane_id, event, cx)
749 })
750 .detach();
751 cx.focus(&pane);
752 cx.emit(Event::PaneAdded(pane.clone()));
753
754 let mut current_user = params.user_store.read(cx).watch_current_user().clone();
755 let mut connection_status = params.client.status().clone();
756 let _observe_current_user = cx.spawn_weak(|this, mut cx| async move {
757 current_user.recv().await;
758 connection_status.recv().await;
759 let mut stream =
760 Stream::map(current_user, drop).merge(Stream::map(connection_status, drop));
761
762 while stream.recv().await.is_some() {
763 cx.update(|cx| {
764 if let Some(this) = this.upgrade(cx) {
765 this.update(cx, |_, cx| cx.notify());
766 }
767 })
768 }
769 });
770
771 let weak_self = cx.weak_handle();
772
773 cx.emit_global(WorkspaceCreated(weak_self.clone()));
774
775 let left_sidebar = cx.add_view(|_| Sidebar::new(Side::Left));
776 let right_sidebar = cx.add_view(|_| Sidebar::new(Side::Right));
777 let left_sidebar_buttons = cx.add_view(|cx| SidebarButtons::new(left_sidebar.clone(), cx));
778 let right_sidebar_buttons =
779 cx.add_view(|cx| SidebarButtons::new(right_sidebar.clone(), cx));
780 let status_bar = cx.add_view(|cx| {
781 let mut status_bar = StatusBar::new(&pane.clone(), cx);
782 status_bar.add_left_item(left_sidebar_buttons, cx);
783 status_bar.add_right_item(right_sidebar_buttons, cx);
784 status_bar
785 });
786
787 let mut this = Workspace {
788 modal: None,
789 weak_self,
790 center: PaneGroup::new(pane.clone()),
791 panes: vec![pane.clone()],
792 active_pane: pane.clone(),
793 status_bar,
794 client: params.client.clone(),
795 remote_entity_subscription: None,
796 user_store: params.user_store.clone(),
797 fs: params.fs.clone(),
798 themes: params.themes.clone(),
799 left_sidebar,
800 right_sidebar,
801 project: params.project.clone(),
802 leader_state: Default::default(),
803 follower_states_by_leader: Default::default(),
804 last_leaders_by_pane: Default::default(),
805 _observe_current_user,
806 };
807 this.project_remote_id_changed(this.project.read(cx).remote_id(), cx);
808 this
809 }
810
811 pub fn weak_handle(&self) -> WeakViewHandle<Self> {
812 self.weak_self.clone()
813 }
814
815 pub fn left_sidebar(&self) -> &ViewHandle<Sidebar> {
816 &self.left_sidebar
817 }
818
819 pub fn right_sidebar(&self) -> &ViewHandle<Sidebar> {
820 &self.right_sidebar
821 }
822
823 pub fn status_bar(&self) -> &ViewHandle<StatusBar> {
824 &self.status_bar
825 }
826
827 pub fn user_store(&self) -> &ModelHandle<UserStore> {
828 &self.user_store
829 }
830
831 pub fn project(&self) -> &ModelHandle<Project> {
832 &self.project
833 }
834
835 pub fn themes(&self) -> Arc<ThemeRegistry> {
836 self.themes.clone()
837 }
838
839 pub fn worktrees<'a>(
840 &self,
841 cx: &'a AppContext,
842 ) -> impl 'a + Iterator<Item = ModelHandle<Worktree>> {
843 self.project.read(cx).worktrees(cx)
844 }
845
846 pub fn contains_paths(&self, paths: &[PathBuf], cx: &AppContext) -> bool {
847 paths.iter().all(|path| self.contains_path(&path, cx))
848 }
849
850 pub fn contains_path(&self, path: &Path, cx: &AppContext) -> bool {
851 for worktree in self.worktrees(cx) {
852 let worktree = worktree.read(cx).as_local();
853 if worktree.map_or(false, |w| w.contains_abs_path(path)) {
854 return true;
855 }
856 }
857 false
858 }
859
860 pub fn worktree_scans_complete(&self, cx: &AppContext) -> impl Future<Output = ()> + 'static {
861 let futures = self
862 .worktrees(cx)
863 .filter_map(|worktree| worktree.read(cx).as_local())
864 .map(|worktree| worktree.scan_complete())
865 .collect::<Vec<_>>();
866 async move {
867 for future in futures {
868 future.await;
869 }
870 }
871 }
872
873 pub fn open_paths(
874 &mut self,
875 mut abs_paths: Vec<PathBuf>,
876 cx: &mut ViewContext<Self>,
877 ) -> Task<Vec<Option<Result<Box<dyn ItemHandle>, Arc<anyhow::Error>>>>> {
878 let fs = self.fs.clone();
879
880 // Sort the paths to ensure we add worktrees for parents before their children.
881 abs_paths.sort_unstable();
882 cx.spawn(|this, mut cx| async move {
883 let mut entries = Vec::new();
884 for path in &abs_paths {
885 entries.push(
886 this.update(&mut cx, |this, cx| this.project_path_for_path(path, cx))
887 .await
888 .ok(),
889 );
890 }
891
892 let tasks = abs_paths
893 .iter()
894 .cloned()
895 .zip(entries.into_iter())
896 .map(|(abs_path, project_path)| {
897 let this = this.clone();
898 cx.spawn(|mut cx| {
899 let fs = fs.clone();
900 async move {
901 let project_path = project_path?;
902 if fs.is_file(&abs_path).await {
903 Some(
904 this.update(&mut cx, |this, cx| {
905 this.open_path(project_path, true, cx)
906 })
907 .await,
908 )
909 } else {
910 None
911 }
912 }
913 })
914 })
915 .collect::<Vec<_>>();
916
917 futures::future::join_all(tasks).await
918 })
919 }
920
921 fn project_path_for_path(
922 &self,
923 abs_path: &Path,
924 cx: &mut ViewContext<Self>,
925 ) -> Task<Result<ProjectPath>> {
926 let entry = self.project().update(cx, |project, cx| {
927 project.find_or_create_local_worktree(abs_path, true, cx)
928 });
929 cx.spawn(|_, cx| async move {
930 let (worktree, path) = entry.await?;
931 Ok(ProjectPath {
932 worktree_id: worktree.read_with(&cx, |t, _| t.id()),
933 path: path.into(),
934 })
935 })
936 }
937
938 /// Returns the modal that was toggled closed if it was open.
939 pub fn toggle_modal<V, F>(
940 &mut self,
941 cx: &mut ViewContext<Self>,
942 add_view: F,
943 ) -> Option<ViewHandle<V>>
944 where
945 V: 'static + View,
946 F: FnOnce(&mut ViewContext<Self>, &mut Self) -> ViewHandle<V>,
947 {
948 cx.notify();
949 // Whatever modal was visible is getting clobbered. If its the same type as V, then return
950 // it. Otherwise, create a new modal and set it as active.
951 let already_open_modal = self.modal.take().and_then(|modal| modal.downcast::<V>());
952 if let Some(already_open_modal) = already_open_modal {
953 cx.focus_self();
954 Some(already_open_modal)
955 } else {
956 let modal = add_view(cx, self);
957 cx.focus(&modal);
958 self.modal = Some(modal.into());
959 None
960 }
961 }
962
963 pub fn modal(&self) -> Option<&AnyViewHandle> {
964 self.modal.as_ref()
965 }
966
967 pub fn dismiss_modal(&mut self, cx: &mut ViewContext<Self>) {
968 if self.modal.take().is_some() {
969 cx.focus(&self.active_pane);
970 cx.notify();
971 }
972 }
973
974 pub fn items<'a>(
975 &'a self,
976 cx: &'a AppContext,
977 ) -> impl 'a + Iterator<Item = &Box<dyn ItemHandle>> {
978 self.panes.iter().flat_map(|pane| pane.read(cx).items())
979 }
980
981 pub fn item_of_type<T: Item>(&self, cx: &AppContext) -> Option<ViewHandle<T>> {
982 self.items_of_type(cx).max_by_key(|item| item.id())
983 }
984
985 pub fn items_of_type<'a, T: Item>(
986 &'a self,
987 cx: &'a AppContext,
988 ) -> impl 'a + Iterator<Item = ViewHandle<T>> {
989 self.panes
990 .iter()
991 .flat_map(|pane| pane.read(cx).items_of_type())
992 }
993
994 pub fn active_item(&self, cx: &AppContext) -> Option<Box<dyn ItemHandle>> {
995 self.active_pane().read(cx).active_item()
996 }
997
998 fn active_project_path(&self, cx: &ViewContext<Self>) -> Option<ProjectPath> {
999 self.active_item(cx).and_then(|item| item.project_path(cx))
1000 }
1001
1002 pub fn save_active_item(&mut self, cx: &mut ViewContext<Self>) -> Task<Result<()>> {
1003 let project = self.project.clone();
1004 if let Some(item) = self.active_item(cx) {
1005 if item.can_save(cx) {
1006 if item.has_conflict(cx.as_ref()) {
1007 const CONFLICT_MESSAGE: &'static str = "This file has changed on disk since you started editing it. Do you want to overwrite it?";
1008
1009 let mut answer = cx.prompt(
1010 PromptLevel::Warning,
1011 CONFLICT_MESSAGE,
1012 &["Overwrite", "Cancel"],
1013 );
1014 cx.spawn(|_, mut cx| async move {
1015 let answer = answer.recv().await;
1016 if answer == Some(0) {
1017 cx.update(|cx| item.save(project, cx)).await?;
1018 }
1019 Ok(())
1020 })
1021 } else {
1022 item.save(project, cx)
1023 }
1024 } else if item.can_save_as(cx) {
1025 let worktree = self.worktrees(cx).next();
1026 let start_abs_path = worktree
1027 .and_then(|w| w.read(cx).as_local())
1028 .map_or(Path::new(""), |w| w.abs_path())
1029 .to_path_buf();
1030 let mut abs_path = cx.prompt_for_new_path(&start_abs_path);
1031 cx.spawn(|_, mut cx| async move {
1032 if let Some(abs_path) = abs_path.recv().await.flatten() {
1033 cx.update(|cx| item.save_as(project, abs_path, cx)).await?;
1034 }
1035 Ok(())
1036 })
1037 } else {
1038 Task::ready(Ok(()))
1039 }
1040 } else {
1041 Task::ready(Ok(()))
1042 }
1043 }
1044
1045 pub fn toggle_sidebar_item(&mut self, action: &ToggleSidebarItem, cx: &mut ViewContext<Self>) {
1046 let sidebar = match action.side {
1047 Side::Left => &mut self.left_sidebar,
1048 Side::Right => &mut self.right_sidebar,
1049 };
1050 let active_item = sidebar.update(cx, |sidebar, cx| {
1051 sidebar.toggle_item(action.item_index, cx);
1052 sidebar.active_item().cloned()
1053 });
1054 if let Some(active_item) = active_item {
1055 cx.focus(active_item);
1056 } else {
1057 cx.focus_self();
1058 }
1059 cx.notify();
1060 }
1061
1062 pub fn toggle_sidebar_item_focus(
1063 &mut self,
1064 action: &ToggleSidebarItemFocus,
1065 cx: &mut ViewContext<Self>,
1066 ) {
1067 let sidebar = match action.side {
1068 Side::Left => &mut self.left_sidebar,
1069 Side::Right => &mut self.right_sidebar,
1070 };
1071 let active_item = sidebar.update(cx, |sidebar, cx| {
1072 sidebar.activate_item(action.item_index, cx);
1073 sidebar.active_item().cloned()
1074 });
1075 if let Some(active_item) = active_item {
1076 if active_item.is_focused(cx) {
1077 cx.focus_self();
1078 } else {
1079 cx.focus(active_item);
1080 }
1081 }
1082 cx.notify();
1083 }
1084
1085 fn add_pane(&mut self, cx: &mut ViewContext<Self>) -> ViewHandle<Pane> {
1086 let pane = cx.add_view(|cx| Pane::new(cx));
1087 let pane_id = pane.id();
1088 cx.observe(&pane, move |me, _, cx| {
1089 let active_entry = me.active_project_path(cx);
1090 me.project
1091 .update(cx, |project, cx| project.set_active_path(active_entry, cx));
1092 })
1093 .detach();
1094 cx.subscribe(&pane, move |me, _, event, cx| {
1095 me.handle_pane_event(pane_id, event, cx)
1096 })
1097 .detach();
1098 self.panes.push(pane.clone());
1099 self.activate_pane(pane.clone(), cx);
1100 cx.emit(Event::PaneAdded(pane.clone()));
1101 pane
1102 }
1103
1104 pub fn add_item(&mut self, item: Box<dyn ItemHandle>, cx: &mut ViewContext<Self>) {
1105 let pane = self.active_pane().clone();
1106 Pane::add_item(self, pane, item, true, true, cx);
1107 }
1108
1109 pub fn open_path(
1110 &mut self,
1111 path: impl Into<ProjectPath>,
1112 focus_item: bool,
1113 cx: &mut ViewContext<Self>,
1114 ) -> Task<Result<Box<dyn ItemHandle>, Arc<anyhow::Error>>> {
1115 let pane = self.active_pane().downgrade();
1116 let task = self.load_path(path.into(), cx);
1117 cx.spawn(|this, mut cx| async move {
1118 let (project_entry_id, build_item) = task.await?;
1119 let pane = pane
1120 .upgrade(&cx)
1121 .ok_or_else(|| anyhow!("pane was closed"))?;
1122 this.update(&mut cx, |this, cx| {
1123 Ok(Pane::open_item(
1124 this,
1125 pane,
1126 project_entry_id,
1127 focus_item,
1128 cx,
1129 build_item,
1130 ))
1131 })
1132 })
1133 }
1134
1135 pub(crate) fn load_path(
1136 &mut self,
1137 path: ProjectPath,
1138 cx: &mut ViewContext<Self>,
1139 ) -> Task<
1140 Result<(
1141 ProjectEntryId,
1142 impl 'static + FnOnce(&mut MutableAppContext) -> Box<dyn ItemHandle>,
1143 )>,
1144 > {
1145 let project = self.project().clone();
1146 let project_item = project.update(cx, |project, cx| project.open_path(path, cx));
1147 let window_id = cx.window_id();
1148 cx.as_mut().spawn(|mut cx| async move {
1149 let (project_entry_id, project_item) = project_item.await?;
1150 let build_item = cx.update(|cx| {
1151 cx.default_global::<ProjectItemBuilders>()
1152 .get(&project_item.model_type())
1153 .ok_or_else(|| anyhow!("no item builder for project item"))
1154 .cloned()
1155 })?;
1156 let build_item =
1157 move |cx: &mut MutableAppContext| build_item(window_id, project, project_item, cx);
1158 Ok((project_entry_id, build_item))
1159 })
1160 }
1161
1162 pub fn open_project_item<T>(
1163 &mut self,
1164 project_item: ModelHandle<T::Item>,
1165 cx: &mut ViewContext<Self>,
1166 ) -> ViewHandle<T>
1167 where
1168 T: ProjectItem,
1169 {
1170 use project::Item as _;
1171
1172 let entry_id = project_item.read(cx).entry_id(cx);
1173 if let Some(item) = entry_id
1174 .and_then(|entry_id| self.active_pane().read(cx).item_for_entry(entry_id, cx))
1175 .and_then(|item| item.downcast())
1176 {
1177 self.activate_item(&item, cx);
1178 return item;
1179 }
1180
1181 let item = cx.add_view(|cx| T::for_project_item(self.project().clone(), project_item, cx));
1182 self.add_item(Box::new(item.clone()), cx);
1183 item
1184 }
1185
1186 pub fn activate_item(&mut self, item: &dyn ItemHandle, cx: &mut ViewContext<Self>) -> bool {
1187 let result = self.panes.iter().find_map(|pane| {
1188 if let Some(ix) = pane.read(cx).index_for_item(item) {
1189 Some((pane.clone(), ix))
1190 } else {
1191 None
1192 }
1193 });
1194 if let Some((pane, ix)) = result {
1195 self.activate_pane(pane.clone(), cx);
1196 pane.update(cx, |pane, cx| pane.activate_item(ix, true, true, cx));
1197 true
1198 } else {
1199 false
1200 }
1201 }
1202
1203 pub fn activate_next_pane(&mut self, cx: &mut ViewContext<Self>) {
1204 let next_pane = {
1205 let panes = self.center.panes();
1206 let ix = panes
1207 .iter()
1208 .position(|pane| **pane == self.active_pane)
1209 .unwrap();
1210 let next_ix = (ix + 1) % panes.len();
1211 panes[next_ix].clone()
1212 };
1213 self.activate_pane(next_pane, cx);
1214 }
1215
1216 pub fn activate_previous_pane(&mut self, cx: &mut ViewContext<Self>) {
1217 let prev_pane = {
1218 let panes = self.center.panes();
1219 let ix = panes
1220 .iter()
1221 .position(|pane| **pane == self.active_pane)
1222 .unwrap();
1223 let prev_ix = if ix == 0 { panes.len() - 1 } else { ix - 1 };
1224 panes[prev_ix].clone()
1225 };
1226 self.activate_pane(prev_pane, cx);
1227 }
1228
1229 fn activate_pane(&mut self, pane: ViewHandle<Pane>, cx: &mut ViewContext<Self>) {
1230 if self.active_pane != pane {
1231 self.active_pane = pane.clone();
1232 self.status_bar.update(cx, |status_bar, cx| {
1233 status_bar.set_active_pane(&self.active_pane, cx);
1234 });
1235 cx.focus(&self.active_pane);
1236 cx.notify();
1237 }
1238
1239 self.update_followers(
1240 proto::update_followers::Variant::UpdateActiveView(proto::UpdateActiveView {
1241 id: self.active_item(cx).map(|item| item.id() as u64),
1242 leader_id: self.leader_for_pane(&pane).map(|id| id.0),
1243 }),
1244 cx,
1245 );
1246 }
1247
1248 fn handle_pane_event(
1249 &mut self,
1250 pane_id: usize,
1251 event: &pane::Event,
1252 cx: &mut ViewContext<Self>,
1253 ) {
1254 if let Some(pane) = self.pane(pane_id) {
1255 match event {
1256 pane::Event::Split(direction) => {
1257 self.split_pane(pane, *direction, cx);
1258 }
1259 pane::Event::Remove => {
1260 self.remove_pane(pane, cx);
1261 }
1262 pane::Event::Activate => {
1263 self.activate_pane(pane, cx);
1264 }
1265 pane::Event::ActivateItem { local } => {
1266 if *local {
1267 self.unfollow(&pane, cx);
1268 }
1269 }
1270 }
1271 } else {
1272 error!("pane {} not found", pane_id);
1273 }
1274 }
1275
1276 pub fn split_pane(
1277 &mut self,
1278 pane: ViewHandle<Pane>,
1279 direction: SplitDirection,
1280 cx: &mut ViewContext<Self>,
1281 ) -> ViewHandle<Pane> {
1282 let new_pane = self.add_pane(cx);
1283 self.activate_pane(new_pane.clone(), cx);
1284 if let Some(item) = pane.read(cx).active_item() {
1285 if let Some(clone) = item.clone_on_split(cx.as_mut()) {
1286 Pane::add_item(self, new_pane.clone(), clone, true, true, cx);
1287 }
1288 }
1289 self.center.split(&pane, &new_pane, direction).unwrap();
1290 cx.notify();
1291 new_pane
1292 }
1293
1294 fn remove_pane(&mut self, pane: ViewHandle<Pane>, cx: &mut ViewContext<Self>) {
1295 if self.center.remove(&pane).unwrap() {
1296 self.panes.retain(|p| p != &pane);
1297 self.activate_pane(self.panes.last().unwrap().clone(), cx);
1298 self.unfollow(&pane, cx);
1299 self.last_leaders_by_pane.remove(&pane.downgrade());
1300 cx.notify();
1301 }
1302 }
1303
1304 pub fn panes(&self) -> &[ViewHandle<Pane>] {
1305 &self.panes
1306 }
1307
1308 fn pane(&self, pane_id: usize) -> Option<ViewHandle<Pane>> {
1309 self.panes.iter().find(|pane| pane.id() == pane_id).cloned()
1310 }
1311
1312 pub fn active_pane(&self) -> &ViewHandle<Pane> {
1313 &self.active_pane
1314 }
1315
1316 fn toggle_share(&mut self, _: &ToggleShare, cx: &mut ViewContext<Self>) {
1317 self.project.update(cx, |project, cx| {
1318 if project.is_local() {
1319 if project.is_shared() {
1320 project.unshare(cx);
1321 } else if project.can_share(cx) {
1322 project.share(cx).detach();
1323 }
1324 }
1325 });
1326 }
1327
1328 fn project_remote_id_changed(&mut self, remote_id: Option<u64>, cx: &mut ViewContext<Self>) {
1329 if let Some(remote_id) = remote_id {
1330 self.remote_entity_subscription =
1331 Some(self.client.add_view_for_remote_entity(remote_id, cx));
1332 } else {
1333 self.remote_entity_subscription.take();
1334 }
1335 }
1336
1337 fn collaborator_left(&mut self, peer_id: PeerId, cx: &mut ViewContext<Self>) {
1338 self.leader_state.followers.remove(&peer_id);
1339 if let Some(states_by_pane) = self.follower_states_by_leader.remove(&peer_id) {
1340 for state in states_by_pane.into_values() {
1341 for item in state.items_by_leader_view_id.into_values() {
1342 if let FollowerItem::Loaded(item) = item {
1343 item.set_leader_replica_id(None, cx);
1344 }
1345 }
1346 }
1347 }
1348 cx.notify();
1349 }
1350
1351 pub fn toggle_follow(
1352 &mut self,
1353 ToggleFollow(leader_id): &ToggleFollow,
1354 cx: &mut ViewContext<Self>,
1355 ) -> Option<Task<Result<()>>> {
1356 let leader_id = *leader_id;
1357 let pane = self.active_pane().clone();
1358
1359 if let Some(prev_leader_id) = self.unfollow(&pane, cx) {
1360 if leader_id == prev_leader_id {
1361 return None;
1362 }
1363 }
1364
1365 self.last_leaders_by_pane
1366 .insert(pane.downgrade(), leader_id);
1367 self.follower_states_by_leader
1368 .entry(leader_id)
1369 .or_default()
1370 .insert(pane.clone(), Default::default());
1371 cx.notify();
1372
1373 let project_id = self.project.read(cx).remote_id()?;
1374 let request = self.client.request(proto::Follow {
1375 project_id,
1376 leader_id: leader_id.0,
1377 });
1378 Some(cx.spawn_weak(|this, mut cx| async move {
1379 let response = request.await?;
1380 if let Some(this) = this.upgrade(&cx) {
1381 this.update(&mut cx, |this, _| {
1382 let state = this
1383 .follower_states_by_leader
1384 .get_mut(&leader_id)
1385 .and_then(|states_by_pane| states_by_pane.get_mut(&pane))
1386 .ok_or_else(|| anyhow!("following interrupted"))?;
1387 state.active_view_id = response.active_view_id;
1388 Ok::<_, anyhow::Error>(())
1389 })?;
1390 Self::add_views_from_leader(this, leader_id, vec![pane], response.views, &mut cx)
1391 .await?;
1392 }
1393 Ok(())
1394 }))
1395 }
1396
1397 pub fn follow_next_collaborator(
1398 &mut self,
1399 _: &FollowNextCollaborator,
1400 cx: &mut ViewContext<Self>,
1401 ) -> Option<Task<Result<()>>> {
1402 let collaborators = self.project.read(cx).collaborators();
1403 let next_leader_id = if let Some(leader_id) = self.leader_for_pane(&self.active_pane) {
1404 let mut collaborators = collaborators.keys().copied();
1405 while let Some(peer_id) = collaborators.next() {
1406 if peer_id == leader_id {
1407 break;
1408 }
1409 }
1410 collaborators.next()
1411 } else if let Some(last_leader_id) =
1412 self.last_leaders_by_pane.get(&self.active_pane.downgrade())
1413 {
1414 if collaborators.contains_key(last_leader_id) {
1415 Some(*last_leader_id)
1416 } else {
1417 None
1418 }
1419 } else {
1420 None
1421 };
1422
1423 next_leader_id
1424 .or_else(|| collaborators.keys().copied().next())
1425 .and_then(|leader_id| self.toggle_follow(&ToggleFollow(leader_id), cx))
1426 }
1427
1428 pub fn unfollow(
1429 &mut self,
1430 pane: &ViewHandle<Pane>,
1431 cx: &mut ViewContext<Self>,
1432 ) -> Option<PeerId> {
1433 for (leader_id, states_by_pane) in &mut self.follower_states_by_leader {
1434 let leader_id = *leader_id;
1435 if let Some(state) = states_by_pane.remove(&pane) {
1436 for (_, item) in state.items_by_leader_view_id {
1437 if let FollowerItem::Loaded(item) = item {
1438 item.set_leader_replica_id(None, cx);
1439 }
1440 }
1441
1442 if states_by_pane.is_empty() {
1443 self.follower_states_by_leader.remove(&leader_id);
1444 if let Some(project_id) = self.project.read(cx).remote_id() {
1445 self.client
1446 .send(proto::Unfollow {
1447 project_id,
1448 leader_id: leader_id.0,
1449 })
1450 .log_err();
1451 }
1452 }
1453
1454 cx.notify();
1455 return Some(leader_id);
1456 }
1457 }
1458 None
1459 }
1460
1461 fn render_connection_status(&self, cx: &mut RenderContext<Self>) -> Option<ElementBox> {
1462 let theme = &cx.global::<Settings>().theme;
1463 match &*self.client.status().borrow() {
1464 client::Status::ConnectionError
1465 | client::Status::ConnectionLost
1466 | client::Status::Reauthenticating
1467 | client::Status::Reconnecting { .. }
1468 | client::Status::ReconnectionError { .. } => Some(
1469 Container::new(
1470 Align::new(
1471 ConstrainedBox::new(
1472 Svg::new("icons/offline-14.svg")
1473 .with_color(theme.workspace.titlebar.offline_icon.color)
1474 .boxed(),
1475 )
1476 .with_width(theme.workspace.titlebar.offline_icon.width)
1477 .boxed(),
1478 )
1479 .boxed(),
1480 )
1481 .with_style(theme.workspace.titlebar.offline_icon.container)
1482 .boxed(),
1483 ),
1484 client::Status::UpgradeRequired => Some(
1485 Label::new(
1486 "Please update Zed to collaborate".to_string(),
1487 theme.workspace.titlebar.outdated_warning.text.clone(),
1488 )
1489 .contained()
1490 .with_style(theme.workspace.titlebar.outdated_warning.container)
1491 .aligned()
1492 .boxed(),
1493 ),
1494 _ => None,
1495 }
1496 }
1497
1498 fn render_titlebar(&self, theme: &Theme, cx: &mut RenderContext<Self>) -> ElementBox {
1499 let mut worktree_root_names = String::new();
1500 {
1501 let mut worktrees = self.project.read(cx).visible_worktrees(cx).peekable();
1502 while let Some(worktree) = worktrees.next() {
1503 worktree_root_names.push_str(worktree.read(cx).root_name());
1504 if worktrees.peek().is_some() {
1505 worktree_root_names.push_str(", ");
1506 }
1507 }
1508 }
1509
1510 ConstrainedBox::new(
1511 Container::new(
1512 Stack::new()
1513 .with_child(
1514 Label::new(worktree_root_names, theme.workspace.titlebar.title.clone())
1515 .aligned()
1516 .left()
1517 .boxed(),
1518 )
1519 .with_child(
1520 Align::new(
1521 Flex::row()
1522 .with_children(self.render_collaborators(theme, cx))
1523 .with_children(self.render_current_user(
1524 self.user_store.read(cx).current_user().as_ref(),
1525 self.project.read(cx).replica_id(),
1526 theme,
1527 cx,
1528 ))
1529 .with_children(self.render_connection_status(cx))
1530 .with_children(self.render_share_icon(theme, cx))
1531 .boxed(),
1532 )
1533 .right()
1534 .boxed(),
1535 )
1536 .boxed(),
1537 )
1538 .with_style(theme.workspace.titlebar.container)
1539 .boxed(),
1540 )
1541 .with_height(theme.workspace.titlebar.height)
1542 .named("titlebar")
1543 }
1544
1545 fn render_collaborators(&self, theme: &Theme, cx: &mut RenderContext<Self>) -> Vec<ElementBox> {
1546 let mut collaborators = self
1547 .project
1548 .read(cx)
1549 .collaborators()
1550 .values()
1551 .cloned()
1552 .collect::<Vec<_>>();
1553 collaborators.sort_unstable_by_key(|collaborator| collaborator.replica_id);
1554 collaborators
1555 .into_iter()
1556 .filter_map(|collaborator| {
1557 Some(self.render_avatar(
1558 collaborator.user.avatar.clone()?,
1559 collaborator.replica_id,
1560 Some(collaborator.peer_id),
1561 theme,
1562 cx,
1563 ))
1564 })
1565 .collect()
1566 }
1567
1568 fn render_current_user(
1569 &self,
1570 user: Option<&Arc<User>>,
1571 replica_id: ReplicaId,
1572 theme: &Theme,
1573 cx: &mut RenderContext<Self>,
1574 ) -> Option<ElementBox> {
1575 let status = *self.client.status().borrow();
1576 if let Some(avatar) = user.and_then(|user| user.avatar.clone()) {
1577 Some(self.render_avatar(avatar, replica_id, None, theme, cx))
1578 } else if matches!(status, client::Status::UpgradeRequired) {
1579 None
1580 } else {
1581 Some(
1582 MouseEventHandler::new::<Authenticate, _, _>(0, cx, |state, _| {
1583 let style = theme
1584 .workspace
1585 .titlebar
1586 .sign_in_prompt
1587 .style_for(state, false);
1588 Label::new("Sign in".to_string(), style.text.clone())
1589 .contained()
1590 .with_style(style.container)
1591 .boxed()
1592 })
1593 .on_click(|_, cx| cx.dispatch_action(Authenticate))
1594 .with_cursor_style(CursorStyle::PointingHand)
1595 .aligned()
1596 .boxed(),
1597 )
1598 }
1599 }
1600
1601 fn render_avatar(
1602 &self,
1603 avatar: Arc<ImageData>,
1604 replica_id: ReplicaId,
1605 peer_id: Option<PeerId>,
1606 theme: &Theme,
1607 cx: &mut RenderContext<Self>,
1608 ) -> ElementBox {
1609 let replica_color = theme.editor.replica_selection_style(replica_id).cursor;
1610 let is_followed = peer_id.map_or(false, |peer_id| {
1611 self.follower_states_by_leader.contains_key(&peer_id)
1612 });
1613 let mut avatar_style = theme.workspace.titlebar.avatar;
1614 if is_followed {
1615 avatar_style.border = Border::all(1.0, replica_color);
1616 }
1617 let content = Stack::new()
1618 .with_child(
1619 Image::new(avatar)
1620 .with_style(avatar_style)
1621 .constrained()
1622 .with_width(theme.workspace.titlebar.avatar_width)
1623 .aligned()
1624 .boxed(),
1625 )
1626 .with_child(
1627 AvatarRibbon::new(replica_color)
1628 .constrained()
1629 .with_width(theme.workspace.titlebar.avatar_ribbon.width)
1630 .with_height(theme.workspace.titlebar.avatar_ribbon.height)
1631 .aligned()
1632 .bottom()
1633 .boxed(),
1634 )
1635 .constrained()
1636 .with_width(theme.workspace.titlebar.avatar_width)
1637 .contained()
1638 .with_margin_left(theme.workspace.titlebar.avatar_margin)
1639 .boxed();
1640
1641 if let Some(peer_id) = peer_id {
1642 MouseEventHandler::new::<ToggleFollow, _, _>(replica_id.into(), cx, move |_, _| content)
1643 .with_cursor_style(CursorStyle::PointingHand)
1644 .on_click(move |_, cx| cx.dispatch_action(ToggleFollow(peer_id)))
1645 .boxed()
1646 } else {
1647 content
1648 }
1649 }
1650
1651 fn render_share_icon(&self, theme: &Theme, cx: &mut RenderContext<Self>) -> Option<ElementBox> {
1652 if self.project().read(cx).is_local()
1653 && self.client.user_id().is_some()
1654 && self.project().read(cx).can_share(cx)
1655 {
1656 Some(
1657 MouseEventHandler::new::<ToggleShare, _, _>(0, cx, |state, cx| {
1658 let style = &theme
1659 .workspace
1660 .titlebar
1661 .share_icon
1662 .style_for(state, self.project().read(cx).is_shared());
1663 Svg::new("icons/share.svg")
1664 .with_color(style.color)
1665 .constrained()
1666 .with_height(14.)
1667 .aligned()
1668 .contained()
1669 .with_style(style.container)
1670 .constrained()
1671 .with_width(24.)
1672 .aligned()
1673 .boxed()
1674 })
1675 .with_cursor_style(CursorStyle::PointingHand)
1676 .on_click(|_, cx| cx.dispatch_action(ToggleShare))
1677 .boxed(),
1678 )
1679 } else {
1680 None
1681 }
1682 }
1683
1684 fn render_disconnected_overlay(&self, cx: &AppContext) -> Option<ElementBox> {
1685 if self.project.read(cx).is_read_only() {
1686 let theme = &cx.global::<Settings>().theme;
1687 Some(
1688 EventHandler::new(
1689 Label::new(
1690 "Your connection to the remote project has been lost.".to_string(),
1691 theme.workspace.disconnected_overlay.text.clone(),
1692 )
1693 .aligned()
1694 .contained()
1695 .with_style(theme.workspace.disconnected_overlay.container)
1696 .boxed(),
1697 )
1698 .capture(|_, _, _| true)
1699 .boxed(),
1700 )
1701 } else {
1702 None
1703 }
1704 }
1705
1706 // RPC handlers
1707
1708 async fn handle_follow(
1709 this: ViewHandle<Self>,
1710 envelope: TypedEnvelope<proto::Follow>,
1711 _: Arc<Client>,
1712 mut cx: AsyncAppContext,
1713 ) -> Result<proto::FollowResponse> {
1714 this.update(&mut cx, |this, cx| {
1715 this.leader_state
1716 .followers
1717 .insert(envelope.original_sender_id()?);
1718
1719 let active_view_id = this
1720 .active_item(cx)
1721 .and_then(|i| i.to_followable_item_handle(cx))
1722 .map(|i| i.id() as u64);
1723 Ok(proto::FollowResponse {
1724 active_view_id,
1725 views: this
1726 .panes()
1727 .iter()
1728 .flat_map(|pane| {
1729 let leader_id = this.leader_for_pane(pane).map(|id| id.0);
1730 pane.read(cx).items().filter_map({
1731 let cx = &cx;
1732 move |item| {
1733 let id = item.id() as u64;
1734 let item = item.to_followable_item_handle(cx)?;
1735 let variant = item.to_state_proto(cx)?;
1736 Some(proto::View {
1737 id,
1738 leader_id,
1739 variant: Some(variant),
1740 })
1741 }
1742 })
1743 })
1744 .collect(),
1745 })
1746 })
1747 }
1748
1749 async fn handle_unfollow(
1750 this: ViewHandle<Self>,
1751 envelope: TypedEnvelope<proto::Unfollow>,
1752 _: Arc<Client>,
1753 mut cx: AsyncAppContext,
1754 ) -> Result<()> {
1755 this.update(&mut cx, |this, _| {
1756 this.leader_state
1757 .followers
1758 .remove(&envelope.original_sender_id()?);
1759 Ok(())
1760 })
1761 }
1762
1763 async fn handle_update_followers(
1764 this: ViewHandle<Self>,
1765 envelope: TypedEnvelope<proto::UpdateFollowers>,
1766 _: Arc<Client>,
1767 mut cx: AsyncAppContext,
1768 ) -> Result<()> {
1769 let leader_id = envelope.original_sender_id()?;
1770 match envelope
1771 .payload
1772 .variant
1773 .ok_or_else(|| anyhow!("invalid update"))?
1774 {
1775 proto::update_followers::Variant::UpdateActiveView(update_active_view) => {
1776 this.update(&mut cx, |this, cx| {
1777 this.update_leader_state(leader_id, cx, |state, _| {
1778 state.active_view_id = update_active_view.id;
1779 });
1780 Ok::<_, anyhow::Error>(())
1781 })
1782 }
1783 proto::update_followers::Variant::UpdateView(update_view) => {
1784 this.update(&mut cx, |this, cx| {
1785 let variant = update_view
1786 .variant
1787 .ok_or_else(|| anyhow!("missing update view variant"))?;
1788 this.update_leader_state(leader_id, cx, |state, cx| {
1789 let variant = variant.clone();
1790 match state
1791 .items_by_leader_view_id
1792 .entry(update_view.id)
1793 .or_insert(FollowerItem::Loading(Vec::new()))
1794 {
1795 FollowerItem::Loaded(item) => {
1796 item.apply_update_proto(variant, cx).log_err();
1797 }
1798 FollowerItem::Loading(updates) => updates.push(variant),
1799 }
1800 });
1801 Ok(())
1802 })
1803 }
1804 proto::update_followers::Variant::CreateView(view) => {
1805 let panes = this.read_with(&cx, |this, _| {
1806 this.follower_states_by_leader
1807 .get(&leader_id)
1808 .into_iter()
1809 .flat_map(|states_by_pane| states_by_pane.keys())
1810 .cloned()
1811 .collect()
1812 });
1813 Self::add_views_from_leader(this.clone(), leader_id, panes, vec![view], &mut cx)
1814 .await?;
1815 Ok(())
1816 }
1817 }
1818 .log_err();
1819
1820 Ok(())
1821 }
1822
1823 async fn add_views_from_leader(
1824 this: ViewHandle<Self>,
1825 leader_id: PeerId,
1826 panes: Vec<ViewHandle<Pane>>,
1827 views: Vec<proto::View>,
1828 cx: &mut AsyncAppContext,
1829 ) -> Result<()> {
1830 let project = this.read_with(cx, |this, _| this.project.clone());
1831 let replica_id = project
1832 .read_with(cx, |project, _| {
1833 project
1834 .collaborators()
1835 .get(&leader_id)
1836 .map(|c| c.replica_id)
1837 })
1838 .ok_or_else(|| anyhow!("no such collaborator {}", leader_id))?;
1839
1840 let item_builders = cx.update(|cx| {
1841 cx.default_global::<FollowableItemBuilders>()
1842 .values()
1843 .map(|b| b.0)
1844 .collect::<Vec<_>>()
1845 .clone()
1846 });
1847
1848 let mut item_tasks_by_pane = HashMap::default();
1849 for pane in panes {
1850 let mut item_tasks = Vec::new();
1851 let mut leader_view_ids = Vec::new();
1852 for view in &views {
1853 let mut variant = view.variant.clone();
1854 if variant.is_none() {
1855 Err(anyhow!("missing variant"))?;
1856 }
1857 for build_item in &item_builders {
1858 let task =
1859 cx.update(|cx| build_item(pane.clone(), project.clone(), &mut variant, cx));
1860 if let Some(task) = task {
1861 item_tasks.push(task);
1862 leader_view_ids.push(view.id);
1863 break;
1864 } else {
1865 assert!(variant.is_some());
1866 }
1867 }
1868 }
1869
1870 item_tasks_by_pane.insert(pane, (item_tasks, leader_view_ids));
1871 }
1872
1873 for (pane, (item_tasks, leader_view_ids)) in item_tasks_by_pane {
1874 let items = futures::future::try_join_all(item_tasks).await?;
1875 this.update(cx, |this, cx| {
1876 let state = this
1877 .follower_states_by_leader
1878 .get_mut(&leader_id)?
1879 .get_mut(&pane)?;
1880
1881 for (id, item) in leader_view_ids.into_iter().zip(items) {
1882 item.set_leader_replica_id(Some(replica_id), cx);
1883 match state.items_by_leader_view_id.entry(id) {
1884 hash_map::Entry::Occupied(e) => {
1885 let e = e.into_mut();
1886 if let FollowerItem::Loading(updates) = e {
1887 for update in updates.drain(..) {
1888 item.apply_update_proto(update, cx)
1889 .context("failed to apply view update")
1890 .log_err();
1891 }
1892 }
1893 *e = FollowerItem::Loaded(item);
1894 }
1895 hash_map::Entry::Vacant(e) => {
1896 e.insert(FollowerItem::Loaded(item));
1897 }
1898 }
1899 }
1900
1901 Some(())
1902 });
1903 }
1904 this.update(cx, |this, cx| this.leader_updated(leader_id, cx));
1905
1906 Ok(())
1907 }
1908
1909 fn update_followers(
1910 &self,
1911 update: proto::update_followers::Variant,
1912 cx: &AppContext,
1913 ) -> Option<()> {
1914 let project_id = self.project.read(cx).remote_id()?;
1915 if !self.leader_state.followers.is_empty() {
1916 self.client
1917 .send(proto::UpdateFollowers {
1918 project_id,
1919 follower_ids: self.leader_state.followers.iter().map(|f| f.0).collect(),
1920 variant: Some(update),
1921 })
1922 .log_err();
1923 }
1924 None
1925 }
1926
1927 pub fn leader_for_pane(&self, pane: &ViewHandle<Pane>) -> Option<PeerId> {
1928 self.follower_states_by_leader
1929 .iter()
1930 .find_map(|(leader_id, state)| {
1931 if state.contains_key(pane) {
1932 Some(*leader_id)
1933 } else {
1934 None
1935 }
1936 })
1937 }
1938
1939 fn update_leader_state(
1940 &mut self,
1941 leader_id: PeerId,
1942 cx: &mut ViewContext<Self>,
1943 mut update_fn: impl FnMut(&mut FollowerState, &mut ViewContext<Self>),
1944 ) {
1945 for (_, state) in self
1946 .follower_states_by_leader
1947 .get_mut(&leader_id)
1948 .into_iter()
1949 .flatten()
1950 {
1951 update_fn(state, cx);
1952 }
1953 self.leader_updated(leader_id, cx);
1954 }
1955
1956 fn leader_updated(&mut self, leader_id: PeerId, cx: &mut ViewContext<Self>) -> Option<()> {
1957 let mut items_to_add = Vec::new();
1958 for (pane, state) in self.follower_states_by_leader.get(&leader_id)? {
1959 if let Some(active_item) = state
1960 .active_view_id
1961 .and_then(|id| state.items_by_leader_view_id.get(&id))
1962 {
1963 if let FollowerItem::Loaded(item) = active_item {
1964 items_to_add.push((pane.clone(), item.boxed_clone()));
1965 }
1966 }
1967 }
1968
1969 for (pane, item) in items_to_add {
1970 Pane::add_item(self, pane.clone(), item.boxed_clone(), false, false, cx);
1971 if pane == self.active_pane {
1972 pane.update(cx, |pane, cx| pane.focus_active_item(cx));
1973 }
1974 cx.notify();
1975 }
1976 None
1977 }
1978}
1979
1980impl Entity for Workspace {
1981 type Event = Event;
1982}
1983
1984impl View for Workspace {
1985 fn ui_name() -> &'static str {
1986 "Workspace"
1987 }
1988
1989 fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
1990 let theme = cx.global::<Settings>().theme.clone();
1991 Stack::new()
1992 .with_child(
1993 Flex::column()
1994 .with_child(self.render_titlebar(&theme, cx))
1995 .with_child(
1996 Stack::new()
1997 .with_child({
1998 Flex::row()
1999 .with_children(
2000 if self.left_sidebar.read(cx).active_item().is_some() {
2001 Some(
2002 ChildView::new(&self.left_sidebar)
2003 .flex(0.8, false)
2004 .boxed(),
2005 )
2006 } else {
2007 None
2008 },
2009 )
2010 .with_child(
2011 FlexItem::new(self.center.render(
2012 &theme,
2013 &self.follower_states_by_leader,
2014 self.project.read(cx).collaborators(),
2015 ))
2016 .flex(1., true)
2017 .boxed(),
2018 )
2019 .with_children(
2020 if self.right_sidebar.read(cx).active_item().is_some() {
2021 Some(
2022 ChildView::new(&self.right_sidebar)
2023 .flex(0.8, false)
2024 .boxed(),
2025 )
2026 } else {
2027 None
2028 },
2029 )
2030 .boxed()
2031 })
2032 .with_children(self.modal.as_ref().map(|m| {
2033 ChildView::new(m)
2034 .contained()
2035 .with_style(theme.workspace.modal)
2036 .aligned()
2037 .top()
2038 .boxed()
2039 }))
2040 .flex(1.0, true)
2041 .boxed(),
2042 )
2043 .with_child(ChildView::new(&self.status_bar).boxed())
2044 .contained()
2045 .with_background_color(theme.workspace.background)
2046 .boxed(),
2047 )
2048 .with_children(self.render_disconnected_overlay(cx))
2049 .named("workspace")
2050 }
2051
2052 fn on_focus(&mut self, cx: &mut ViewContext<Self>) {
2053 cx.focus(&self.active_pane);
2054 }
2055}
2056
2057pub trait WorkspaceHandle {
2058 fn file_project_paths(&self, cx: &AppContext) -> Vec<ProjectPath>;
2059}
2060
2061impl WorkspaceHandle for ViewHandle<Workspace> {
2062 fn file_project_paths(&self, cx: &AppContext) -> Vec<ProjectPath> {
2063 self.read(cx)
2064 .worktrees(cx)
2065 .flat_map(|worktree| {
2066 let worktree_id = worktree.read(cx).id();
2067 worktree.read(cx).files(true, 0).map(move |f| ProjectPath {
2068 worktree_id,
2069 path: f.path.clone(),
2070 })
2071 })
2072 .collect::<Vec<_>>()
2073 }
2074}
2075
2076pub struct AvatarRibbon {
2077 color: Color,
2078}
2079
2080impl AvatarRibbon {
2081 pub fn new(color: Color) -> AvatarRibbon {
2082 AvatarRibbon { color }
2083 }
2084}
2085
2086impl Element for AvatarRibbon {
2087 type LayoutState = ();
2088
2089 type PaintState = ();
2090
2091 fn layout(
2092 &mut self,
2093 constraint: gpui::SizeConstraint,
2094 _: &mut gpui::LayoutContext,
2095 ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
2096 (constraint.max, ())
2097 }
2098
2099 fn paint(
2100 &mut self,
2101 bounds: gpui::geometry::rect::RectF,
2102 _: gpui::geometry::rect::RectF,
2103 _: &mut Self::LayoutState,
2104 cx: &mut gpui::PaintContext,
2105 ) -> Self::PaintState {
2106 let mut path = PathBuilder::new();
2107 path.reset(bounds.lower_left());
2108 path.curve_to(
2109 bounds.origin() + vec2f(bounds.height(), 0.),
2110 bounds.origin(),
2111 );
2112 path.line_to(bounds.upper_right() - vec2f(bounds.height(), 0.));
2113 path.curve_to(bounds.lower_right(), bounds.upper_right());
2114 path.line_to(bounds.lower_left());
2115 cx.scene.push_path(path.build(self.color, None));
2116 }
2117
2118 fn dispatch_event(
2119 &mut self,
2120 _: &gpui::Event,
2121 _: RectF,
2122 _: RectF,
2123 _: &mut Self::LayoutState,
2124 _: &mut Self::PaintState,
2125 _: &mut gpui::EventContext,
2126 ) -> bool {
2127 false
2128 }
2129
2130 fn debug(
2131 &self,
2132 bounds: gpui::geometry::rect::RectF,
2133 _: &Self::LayoutState,
2134 _: &Self::PaintState,
2135 _: &gpui::DebugContext,
2136 ) -> gpui::json::Value {
2137 json::json!({
2138 "type": "AvatarRibbon",
2139 "bounds": bounds.to_json(),
2140 "color": self.color.to_json(),
2141 })
2142 }
2143}
2144
2145impl std::fmt::Debug for OpenPaths {
2146 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2147 f.debug_struct("OpenPaths")
2148 .field("paths", &self.paths)
2149 .finish()
2150 }
2151}
2152
2153fn open(action: &Open, cx: &mut MutableAppContext) {
2154 let app_state = action.0.clone();
2155 let mut paths = cx.prompt_for_paths(PathPromptOptions {
2156 files: true,
2157 directories: true,
2158 multiple: true,
2159 });
2160 cx.spawn(|mut cx| async move {
2161 if let Some(paths) = paths.recv().await.flatten() {
2162 cx.update(|cx| cx.dispatch_global_action(OpenPaths { paths, app_state }));
2163 }
2164 })
2165 .detach();
2166}
2167
2168pub struct WorkspaceCreated(WeakViewHandle<Workspace>);
2169
2170pub fn open_paths(
2171 abs_paths: &[PathBuf],
2172 app_state: &Arc<AppState>,
2173 cx: &mut MutableAppContext,
2174) -> Task<(
2175 ViewHandle<Workspace>,
2176 Vec<Option<Result<Box<dyn ItemHandle>, Arc<anyhow::Error>>>>,
2177)> {
2178 log::info!("open paths {:?}", abs_paths);
2179
2180 // Open paths in existing workspace if possible
2181 let mut existing = None;
2182 for window_id in cx.window_ids().collect::<Vec<_>>() {
2183 if let Some(workspace_handle) = cx.root_view::<Workspace>(window_id) {
2184 if workspace_handle.update(cx, |workspace, cx| {
2185 if workspace.contains_paths(abs_paths, cx.as_ref()) {
2186 cx.activate_window(window_id);
2187 existing = Some(workspace_handle.clone());
2188 true
2189 } else {
2190 false
2191 }
2192 }) {
2193 break;
2194 }
2195 }
2196 }
2197
2198 let app_state = app_state.clone();
2199 let abs_paths = abs_paths.to_vec();
2200 cx.spawn(|mut cx| async move {
2201 let workspace = if let Some(existing) = existing {
2202 existing
2203 } else {
2204 let contains_directory =
2205 futures::future::join_all(abs_paths.iter().map(|path| app_state.fs.is_file(path)))
2206 .await
2207 .contains(&false);
2208
2209 cx.add_window((app_state.build_window_options)(), |cx| {
2210 let project = Project::local(
2211 app_state.client.clone(),
2212 app_state.user_store.clone(),
2213 app_state.languages.clone(),
2214 app_state.fs.clone(),
2215 cx,
2216 );
2217 let mut workspace = (app_state.build_workspace)(project, &app_state, cx);
2218 if contains_directory {
2219 workspace.toggle_sidebar_item(
2220 &ToggleSidebarItem {
2221 side: Side::Left,
2222 item_index: 0,
2223 },
2224 cx,
2225 );
2226 }
2227 workspace
2228 })
2229 .1
2230 };
2231
2232 let items = workspace
2233 .update(&mut cx, |workspace, cx| workspace.open_paths(abs_paths, cx))
2234 .await;
2235 (workspace, items)
2236 })
2237}
2238
2239pub fn join_project(
2240 project_id: u64,
2241 app_state: &Arc<AppState>,
2242 cx: &mut MutableAppContext,
2243) -> Task<Result<ViewHandle<Workspace>>> {
2244 for window_id in cx.window_ids().collect::<Vec<_>>() {
2245 if let Some(workspace) = cx.root_view::<Workspace>(window_id) {
2246 if workspace.read(cx).project().read(cx).remote_id() == Some(project_id) {
2247 return Task::ready(Ok(workspace));
2248 }
2249 }
2250 }
2251
2252 let app_state = app_state.clone();
2253 cx.spawn(|mut cx| async move {
2254 let project = Project::remote(
2255 project_id,
2256 app_state.client.clone(),
2257 app_state.user_store.clone(),
2258 app_state.languages.clone(),
2259 app_state.fs.clone(),
2260 &mut cx,
2261 )
2262 .await?;
2263 Ok(cx.update(|cx| {
2264 cx.add_window((app_state.build_window_options)(), |cx| {
2265 (app_state.build_workspace)(project, &app_state, cx)
2266 })
2267 .1
2268 }))
2269 })
2270}
2271
2272fn open_new(app_state: &Arc<AppState>, cx: &mut MutableAppContext) {
2273 let (window_id, workspace) = cx.add_window((app_state.build_window_options)(), |cx| {
2274 let project = Project::local(
2275 app_state.client.clone(),
2276 app_state.user_store.clone(),
2277 app_state.languages.clone(),
2278 app_state.fs.clone(),
2279 cx,
2280 );
2281 (app_state.build_workspace)(project, &app_state, cx)
2282 });
2283 cx.dispatch_action(window_id, vec![workspace.id()], &OpenNew(app_state.clone()));
2284}