1mod channel_modal;
2mod contact_finder;
3
4use self::channel_modal::ChannelModal;
5use crate::{
6 channel_view::ChannelView, chat_panel::ChatPanel, face_pile::FacePile,
7 CollaborationPanelSettings,
8};
9use call::ActiveCall;
10use channel::{Channel, ChannelEvent, ChannelStore};
11use client::{ChannelId, Client, Contact, ProjectId, User, UserStore};
12use contact_finder::ContactFinder;
13use db::kvp::KEY_VALUE_STORE;
14use editor::{Editor, EditorElement, EditorStyle};
15use fuzzy::{match_strings, StringMatchCandidate};
16use gpui::{
17 actions, anchored, canvas, deferred, div, fill, list, point, prelude::*, px, AnyElement,
18 AppContext, AsyncWindowContext, Bounds, ClickEvent, ClipboardItem, DismissEvent, Div,
19 EventEmitter, FocusHandle, FocusableView, FontStyle, InteractiveElement, IntoElement,
20 ListOffset, ListState, Model, MouseDownEvent, ParentElement, Pixels, Point, PromptLevel,
21 Render, SharedString, Styled, Subscription, Task, TextStyle, View, ViewContext, VisualContext,
22 WeakView, WhiteSpace,
23};
24use menu::{Cancel, Confirm, SecondaryConfirm, SelectNext, SelectPrev};
25use project::{Fs, Project};
26use rpc::{
27 proto::{self, ChannelVisibility, PeerId},
28 ErrorCode, ErrorExt,
29};
30use serde_derive::{Deserialize, Serialize};
31use settings::Settings;
32use smallvec::SmallVec;
33use std::{mem, sync::Arc};
34use theme::{ActiveTheme, ThemeSettings};
35use ui::{
36 prelude::*, tooltip_container, Avatar, AvatarAvailabilityIndicator, Button, Color, ContextMenu,
37 Icon, IconButton, IconName, IconSize, Indicator, Label, ListHeader, ListItem, Tooltip,
38};
39use util::{maybe, ResultExt, TryFutureExt};
40use workspace::{
41 dock::{DockPosition, Panel, PanelEvent},
42 notifications::{DetachAndPromptErr, NotifyResultExt, NotifyTaskExt},
43 OpenChannelNotes, Workspace,
44};
45
46actions!(
47 collab_panel,
48 [
49 ToggleFocus,
50 Remove,
51 Secondary,
52 CollapseSelectedChannel,
53 ExpandSelectedChannel,
54 StartMoveChannel,
55 MoveSelected,
56 InsertSpace,
57 ]
58);
59
60#[derive(Debug, Copy, Clone, PartialEq, Eq)]
61struct ChannelMoveClipboard {
62 channel_id: ChannelId,
63}
64
65const COLLABORATION_PANEL_KEY: &str = "CollaborationPanel";
66
67pub fn init(cx: &mut AppContext) {
68 cx.observe_new_views(|workspace: &mut Workspace, _| {
69 workspace.register_action(|workspace, _: &ToggleFocus, cx| {
70 workspace.toggle_panel_focus::<CollabPanel>(cx);
71 });
72 workspace.register_action(|_, _: &OpenChannelNotes, cx| {
73 let channel_id = ActiveCall::global(cx)
74 .read(cx)
75 .room()
76 .and_then(|room| room.read(cx).channel_id());
77
78 if let Some(channel_id) = channel_id {
79 let workspace = cx.view().clone();
80 cx.window_context().defer(move |cx| {
81 ChannelView::open(channel_id, None, workspace, cx).detach_and_log_err(cx)
82 });
83 }
84 });
85 })
86 .detach();
87}
88
89#[derive(Debug)]
90pub enum ChannelEditingState {
91 Create {
92 location: Option<ChannelId>,
93 pending_name: Option<String>,
94 },
95 Rename {
96 location: ChannelId,
97 pending_name: Option<String>,
98 },
99}
100
101impl ChannelEditingState {
102 fn pending_name(&self) -> Option<String> {
103 match self {
104 ChannelEditingState::Create { pending_name, .. } => pending_name.clone(),
105 ChannelEditingState::Rename { pending_name, .. } => pending_name.clone(),
106 }
107 }
108}
109
110pub struct CollabPanel {
111 width: Option<Pixels>,
112 fs: Arc<dyn Fs>,
113 focus_handle: FocusHandle,
114 channel_clipboard: Option<ChannelMoveClipboard>,
115 pending_serialization: Task<Option<()>>,
116 context_menu: Option<(View<ContextMenu>, Point<Pixels>, Subscription)>,
117 list_state: ListState,
118 filter_editor: View<Editor>,
119 channel_name_editor: View<Editor>,
120 channel_editing_state: Option<ChannelEditingState>,
121 entries: Vec<ListEntry>,
122 selection: Option<usize>,
123 channel_store: Model<ChannelStore>,
124 user_store: Model<UserStore>,
125 client: Arc<Client>,
126 project: Model<Project>,
127 match_candidates: Vec<StringMatchCandidate>,
128 subscriptions: Vec<Subscription>,
129 collapsed_sections: Vec<Section>,
130 collapsed_channels: Vec<ChannelId>,
131 workspace: WeakView<Workspace>,
132}
133
134#[derive(Serialize, Deserialize)]
135struct SerializedCollabPanel {
136 width: Option<Pixels>,
137 collapsed_channels: Option<Vec<u64>>,
138}
139
140#[derive(Clone, Copy, PartialEq, Eq, Debug, PartialOrd, Ord)]
141enum Section {
142 ActiveCall,
143 Channels,
144 ChannelInvites,
145 ContactRequests,
146 Contacts,
147 Online,
148 Offline,
149}
150
151#[derive(Clone, Debug)]
152enum ListEntry {
153 Header(Section),
154 CallParticipant {
155 user: Arc<User>,
156 peer_id: Option<PeerId>,
157 is_pending: bool,
158 role: proto::ChannelRole,
159 },
160 ParticipantProject {
161 project_id: u64,
162 worktree_root_names: Vec<String>,
163 host_user_id: u64,
164 is_last: bool,
165 },
166 ParticipantScreen {
167 peer_id: Option<PeerId>,
168 is_last: bool,
169 },
170 IncomingRequest(Arc<User>),
171 OutgoingRequest(Arc<User>),
172 ChannelInvite(Arc<Channel>),
173 Channel {
174 channel: Arc<Channel>,
175 depth: usize,
176 has_children: bool,
177 },
178 ChannelNotes {
179 channel_id: ChannelId,
180 },
181 ChannelChat {
182 channel_id: ChannelId,
183 },
184 ChannelEditor {
185 depth: usize,
186 },
187 HostedProject {
188 id: ProjectId,
189 name: SharedString,
190 },
191 Contact {
192 contact: Arc<Contact>,
193 calling: bool,
194 },
195 ContactPlaceholder,
196}
197
198impl CollabPanel {
199 pub fn new(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) -> View<Self> {
200 cx.new_view(|cx| {
201 let filter_editor = cx.new_view(|cx| {
202 let mut editor = Editor::single_line(cx);
203 editor.set_placeholder_text("Filter...", cx);
204 editor
205 });
206
207 cx.subscribe(&filter_editor, |this: &mut Self, _, event, cx| {
208 if let editor::EditorEvent::BufferEdited = event {
209 let query = this.filter_editor.read(cx).text(cx);
210 if !query.is_empty() {
211 this.selection.take();
212 }
213 this.update_entries(true, cx);
214 if !query.is_empty() {
215 this.selection = this
216 .entries
217 .iter()
218 .position(|entry| !matches!(entry, ListEntry::Header(_)));
219 }
220 }
221 })
222 .detach();
223
224 let channel_name_editor = cx.new_view(|cx| Editor::single_line(cx));
225
226 cx.subscribe(&channel_name_editor, |this: &mut Self, _, event, cx| {
227 if let editor::EditorEvent::Blurred = event {
228 if let Some(state) = &this.channel_editing_state {
229 if state.pending_name().is_some() {
230 return;
231 }
232 }
233 this.take_editing_state(cx);
234 this.update_entries(false, cx);
235 cx.notify();
236 }
237 })
238 .detach();
239
240 let view = cx.view().downgrade();
241 let list_state =
242 ListState::new(0, gpui::ListAlignment::Top, px(1000.), move |ix, cx| {
243 if let Some(view) = view.upgrade() {
244 view.update(cx, |view, cx| view.render_list_entry(ix, cx))
245 } else {
246 div().into_any()
247 }
248 });
249
250 let mut this = Self {
251 width: None,
252 focus_handle: cx.focus_handle(),
253 channel_clipboard: None,
254 fs: workspace.app_state().fs.clone(),
255 pending_serialization: Task::ready(None),
256 context_menu: None,
257 list_state,
258 channel_name_editor,
259 filter_editor,
260 entries: Vec::default(),
261 channel_editing_state: None,
262 selection: None,
263 channel_store: ChannelStore::global(cx),
264 user_store: workspace.user_store().clone(),
265 project: workspace.project().clone(),
266 subscriptions: Vec::default(),
267 match_candidates: Vec::default(),
268 collapsed_sections: vec![Section::Offline],
269 collapsed_channels: Vec::default(),
270 workspace: workspace.weak_handle(),
271 client: workspace.app_state().client.clone(),
272 };
273
274 this.update_entries(false, cx);
275
276 let active_call = ActiveCall::global(cx);
277 this.subscriptions
278 .push(cx.observe(&this.user_store, |this, _, cx| {
279 this.update_entries(true, cx)
280 }));
281 this.subscriptions
282 .push(cx.observe(&this.channel_store, move |this, _, cx| {
283 this.update_entries(true, cx)
284 }));
285 this.subscriptions
286 .push(cx.observe(&active_call, |this, _, cx| this.update_entries(true, cx)));
287 this.subscriptions.push(cx.subscribe(
288 &this.channel_store,
289 |this, _channel_store, e, cx| match e {
290 ChannelEvent::ChannelCreated(channel_id)
291 | ChannelEvent::ChannelRenamed(channel_id) => {
292 if this.take_editing_state(cx) {
293 this.update_entries(false, cx);
294 this.selection = this.entries.iter().position(|entry| {
295 if let ListEntry::Channel { channel, .. } = entry {
296 channel.id == *channel_id
297 } else {
298 false
299 }
300 });
301 }
302 }
303 },
304 ));
305
306 this
307 })
308 }
309
310 pub async fn load(
311 workspace: WeakView<Workspace>,
312 mut cx: AsyncWindowContext,
313 ) -> anyhow::Result<View<Self>> {
314 let serialized_panel = cx
315 .background_executor()
316 .spawn(async move { KEY_VALUE_STORE.read_kvp(COLLABORATION_PANEL_KEY) })
317 .await
318 .map_err(|_| anyhow::anyhow!("Failed to read collaboration panel from key value store"))
319 .log_err()
320 .flatten()
321 .map(|panel| serde_json::from_str::<SerializedCollabPanel>(&panel))
322 .transpose()
323 .log_err()
324 .flatten();
325
326 workspace.update(&mut cx, |workspace, cx| {
327 let panel = CollabPanel::new(workspace, cx);
328 if let Some(serialized_panel) = serialized_panel {
329 panel.update(cx, |panel, cx| {
330 panel.width = serialized_panel.width.map(|w| w.round());
331 panel.collapsed_channels = serialized_panel
332 .collapsed_channels
333 .unwrap_or_else(|| Vec::new())
334 .iter()
335 .map(|cid| ChannelId(*cid))
336 .collect();
337 cx.notify();
338 });
339 }
340 panel
341 })
342 }
343
344 fn serialize(&mut self, cx: &mut ViewContext<Self>) {
345 let width = self.width;
346 let collapsed_channels = self.collapsed_channels.clone();
347 self.pending_serialization = cx.background_executor().spawn(
348 async move {
349 KEY_VALUE_STORE
350 .write_kvp(
351 COLLABORATION_PANEL_KEY.into(),
352 serde_json::to_string(&SerializedCollabPanel {
353 width,
354 collapsed_channels: Some(
355 collapsed_channels.iter().map(|cid| cid.0).collect(),
356 ),
357 })?,
358 )
359 .await?;
360 anyhow::Ok(())
361 }
362 .log_err(),
363 );
364 }
365
366 fn scroll_to_item(&mut self, ix: usize) {
367 self.list_state.scroll_to_reveal_item(ix)
368 }
369
370 fn update_entries(&mut self, select_same_item: bool, cx: &mut ViewContext<Self>) {
371 let channel_store = self.channel_store.read(cx);
372 let user_store = self.user_store.read(cx);
373 let query = self.filter_editor.read(cx).text(cx);
374 let executor = cx.background_executor().clone();
375
376 let prev_selected_entry = self.selection.and_then(|ix| self.entries.get(ix).cloned());
377 let old_entries = mem::take(&mut self.entries);
378 let mut scroll_to_top = false;
379
380 if let Some(room) = ActiveCall::global(cx).read(cx).room() {
381 self.entries.push(ListEntry::Header(Section::ActiveCall));
382 if !old_entries
383 .iter()
384 .any(|entry| matches!(entry, ListEntry::Header(Section::ActiveCall)))
385 {
386 scroll_to_top = true;
387 }
388
389 if !self.collapsed_sections.contains(&Section::ActiveCall) {
390 let room = room.read(cx);
391
392 if query.is_empty() {
393 if let Some(channel_id) = room.channel_id() {
394 self.entries.push(ListEntry::ChannelNotes { channel_id });
395 self.entries.push(ListEntry::ChannelChat { channel_id });
396 }
397 }
398
399 // Populate the active user.
400 if let Some(user) = user_store.current_user() {
401 self.match_candidates.clear();
402 self.match_candidates.push(StringMatchCandidate {
403 id: 0,
404 string: user.github_login.clone(),
405 char_bag: user.github_login.chars().collect(),
406 });
407 let matches = executor.block(match_strings(
408 &self.match_candidates,
409 &query,
410 true,
411 usize::MAX,
412 &Default::default(),
413 executor.clone(),
414 ));
415 if !matches.is_empty() {
416 let user_id = user.id;
417 self.entries.push(ListEntry::CallParticipant {
418 user,
419 peer_id: None,
420 is_pending: false,
421 role: room.local_participant().role,
422 });
423 let mut projects = room.local_participant().projects.iter().peekable();
424 while let Some(project) = projects.next() {
425 self.entries.push(ListEntry::ParticipantProject {
426 project_id: project.id,
427 worktree_root_names: project.worktree_root_names.clone(),
428 host_user_id: user_id,
429 is_last: projects.peek().is_none() && !room.is_screen_sharing(),
430 });
431 }
432 if room.is_screen_sharing() {
433 self.entries.push(ListEntry::ParticipantScreen {
434 peer_id: None,
435 is_last: true,
436 });
437 }
438 }
439 }
440
441 // Populate remote participants.
442 self.match_candidates.clear();
443 self.match_candidates
444 .extend(room.remote_participants().values().map(|participant| {
445 StringMatchCandidate {
446 id: participant.user.id as usize,
447 string: participant.user.github_login.clone(),
448 char_bag: participant.user.github_login.chars().collect(),
449 }
450 }));
451 let mut matches = executor.block(match_strings(
452 &self.match_candidates,
453 &query,
454 true,
455 usize::MAX,
456 &Default::default(),
457 executor.clone(),
458 ));
459 matches.sort_by(|a, b| {
460 let a_is_guest = room.role_for_user(a.candidate_id as u64)
461 == Some(proto::ChannelRole::Guest);
462 let b_is_guest = room.role_for_user(b.candidate_id as u64)
463 == Some(proto::ChannelRole::Guest);
464 a_is_guest
465 .cmp(&b_is_guest)
466 .then_with(|| a.string.cmp(&b.string))
467 });
468 for mat in matches {
469 let user_id = mat.candidate_id as u64;
470 let participant = &room.remote_participants()[&user_id];
471 self.entries.push(ListEntry::CallParticipant {
472 user: participant.user.clone(),
473 peer_id: Some(participant.peer_id),
474 is_pending: false,
475 role: participant.role,
476 });
477 let mut projects = participant.projects.iter().peekable();
478 while let Some(project) = projects.next() {
479 self.entries.push(ListEntry::ParticipantProject {
480 project_id: project.id,
481 worktree_root_names: project.worktree_root_names.clone(),
482 host_user_id: participant.user.id,
483 is_last: projects.peek().is_none()
484 && participant.video_tracks.is_empty(),
485 });
486 }
487 if !participant.video_tracks.is_empty() {
488 self.entries.push(ListEntry::ParticipantScreen {
489 peer_id: Some(participant.peer_id),
490 is_last: true,
491 });
492 }
493 }
494
495 // Populate pending participants.
496 self.match_candidates.clear();
497 self.match_candidates
498 .extend(room.pending_participants().iter().enumerate().map(
499 |(id, participant)| StringMatchCandidate {
500 id,
501 string: participant.github_login.clone(),
502 char_bag: participant.github_login.chars().collect(),
503 },
504 ));
505 let matches = executor.block(match_strings(
506 &self.match_candidates,
507 &query,
508 true,
509 usize::MAX,
510 &Default::default(),
511 executor.clone(),
512 ));
513 self.entries
514 .extend(matches.iter().map(|mat| ListEntry::CallParticipant {
515 user: room.pending_participants()[mat.candidate_id].clone(),
516 peer_id: None,
517 is_pending: true,
518 role: proto::ChannelRole::Member,
519 }));
520 }
521 }
522
523 let mut request_entries = Vec::new();
524
525 self.entries.push(ListEntry::Header(Section::Channels));
526
527 if channel_store.channel_count() > 0 || self.channel_editing_state.is_some() {
528 self.match_candidates.clear();
529 self.match_candidates
530 .extend(
531 channel_store
532 .ordered_channels()
533 .enumerate()
534 .map(|(ix, (_, channel))| StringMatchCandidate {
535 id: ix,
536 string: channel.name.clone().into(),
537 char_bag: channel.name.chars().collect(),
538 }),
539 );
540 let matches = executor.block(match_strings(
541 &self.match_candidates,
542 &query,
543 true,
544 usize::MAX,
545 &Default::default(),
546 executor.clone(),
547 ));
548 if let Some(state) = &self.channel_editing_state {
549 if matches!(state, ChannelEditingState::Create { location: None, .. }) {
550 self.entries.push(ListEntry::ChannelEditor { depth: 0 });
551 }
552 }
553 let mut collapse_depth = None;
554 for mat in matches {
555 let channel = channel_store.channel_at_index(mat.candidate_id).unwrap();
556 let depth = channel.parent_path.len();
557
558 if collapse_depth.is_none() && self.is_channel_collapsed(channel.id) {
559 collapse_depth = Some(depth);
560 } else if let Some(collapsed_depth) = collapse_depth {
561 if depth > collapsed_depth {
562 continue;
563 }
564 if self.is_channel_collapsed(channel.id) {
565 collapse_depth = Some(depth);
566 } else {
567 collapse_depth = None;
568 }
569 }
570
571 let hosted_projects = channel_store.projects_for_id(channel.id);
572 let has_children = channel_store
573 .channel_at_index(mat.candidate_id + 1)
574 .map_or(false, |next_channel| {
575 next_channel.parent_path.ends_with(&[channel.id])
576 });
577
578 match &self.channel_editing_state {
579 Some(ChannelEditingState::Create {
580 location: parent_id,
581 ..
582 }) if *parent_id == Some(channel.id) => {
583 self.entries.push(ListEntry::Channel {
584 channel: channel.clone(),
585 depth,
586 has_children: false,
587 });
588 self.entries
589 .push(ListEntry::ChannelEditor { depth: depth + 1 });
590 }
591 Some(ChannelEditingState::Rename {
592 location: parent_id,
593 ..
594 }) if parent_id == &channel.id => {
595 self.entries.push(ListEntry::ChannelEditor { depth });
596 }
597 _ => {
598 self.entries.push(ListEntry::Channel {
599 channel: channel.clone(),
600 depth,
601 has_children,
602 });
603 }
604 }
605
606 for (name, id) in hosted_projects {
607 self.entries.push(ListEntry::HostedProject { id, name });
608 }
609 }
610 }
611
612 let channel_invites = channel_store.channel_invitations();
613 if !channel_invites.is_empty() {
614 self.match_candidates.clear();
615 self.match_candidates
616 .extend(channel_invites.iter().enumerate().map(|(ix, channel)| {
617 StringMatchCandidate {
618 id: ix,
619 string: channel.name.clone().into(),
620 char_bag: channel.name.chars().collect(),
621 }
622 }));
623 let matches = executor.block(match_strings(
624 &self.match_candidates,
625 &query,
626 true,
627 usize::MAX,
628 &Default::default(),
629 executor.clone(),
630 ));
631 request_entries.extend(
632 matches
633 .iter()
634 .map(|mat| ListEntry::ChannelInvite(channel_invites[mat.candidate_id].clone())),
635 );
636
637 if !request_entries.is_empty() {
638 self.entries
639 .push(ListEntry::Header(Section::ChannelInvites));
640 if !self.collapsed_sections.contains(&Section::ChannelInvites) {
641 self.entries.append(&mut request_entries);
642 }
643 }
644 }
645
646 self.entries.push(ListEntry::Header(Section::Contacts));
647
648 request_entries.clear();
649 let incoming = user_store.incoming_contact_requests();
650 if !incoming.is_empty() {
651 self.match_candidates.clear();
652 self.match_candidates
653 .extend(
654 incoming
655 .iter()
656 .enumerate()
657 .map(|(ix, user)| StringMatchCandidate {
658 id: ix,
659 string: user.github_login.clone(),
660 char_bag: user.github_login.chars().collect(),
661 }),
662 );
663 let matches = executor.block(match_strings(
664 &self.match_candidates,
665 &query,
666 true,
667 usize::MAX,
668 &Default::default(),
669 executor.clone(),
670 ));
671 request_entries.extend(
672 matches
673 .iter()
674 .map(|mat| ListEntry::IncomingRequest(incoming[mat.candidate_id].clone())),
675 );
676 }
677
678 let outgoing = user_store.outgoing_contact_requests();
679 if !outgoing.is_empty() {
680 self.match_candidates.clear();
681 self.match_candidates
682 .extend(
683 outgoing
684 .iter()
685 .enumerate()
686 .map(|(ix, user)| StringMatchCandidate {
687 id: ix,
688 string: user.github_login.clone(),
689 char_bag: user.github_login.chars().collect(),
690 }),
691 );
692 let matches = executor.block(match_strings(
693 &self.match_candidates,
694 &query,
695 true,
696 usize::MAX,
697 &Default::default(),
698 executor.clone(),
699 ));
700 request_entries.extend(
701 matches
702 .iter()
703 .map(|mat| ListEntry::OutgoingRequest(outgoing[mat.candidate_id].clone())),
704 );
705 }
706
707 if !request_entries.is_empty() {
708 self.entries
709 .push(ListEntry::Header(Section::ContactRequests));
710 if !self.collapsed_sections.contains(&Section::ContactRequests) {
711 self.entries.append(&mut request_entries);
712 }
713 }
714
715 let contacts = user_store.contacts();
716 if !contacts.is_empty() {
717 self.match_candidates.clear();
718 self.match_candidates
719 .extend(
720 contacts
721 .iter()
722 .enumerate()
723 .map(|(ix, contact)| StringMatchCandidate {
724 id: ix,
725 string: contact.user.github_login.clone(),
726 char_bag: contact.user.github_login.chars().collect(),
727 }),
728 );
729
730 let matches = executor.block(match_strings(
731 &self.match_candidates,
732 &query,
733 true,
734 usize::MAX,
735 &Default::default(),
736 executor.clone(),
737 ));
738
739 let (online_contacts, offline_contacts) = matches
740 .iter()
741 .partition::<Vec<_>, _>(|mat| contacts[mat.candidate_id].online);
742
743 for (matches, section) in [
744 (online_contacts, Section::Online),
745 (offline_contacts, Section::Offline),
746 ] {
747 if !matches.is_empty() {
748 self.entries.push(ListEntry::Header(section));
749 if !self.collapsed_sections.contains(§ion) {
750 let active_call = &ActiveCall::global(cx).read(cx);
751 for mat in matches {
752 let contact = &contacts[mat.candidate_id];
753 self.entries.push(ListEntry::Contact {
754 contact: contact.clone(),
755 calling: active_call.pending_invites().contains(&contact.user.id),
756 });
757 }
758 }
759 }
760 }
761 }
762
763 if incoming.is_empty() && outgoing.is_empty() && contacts.is_empty() {
764 self.entries.push(ListEntry::ContactPlaceholder);
765 }
766
767 if select_same_item {
768 if let Some(prev_selected_entry) = prev_selected_entry {
769 self.selection.take();
770 for (ix, entry) in self.entries.iter().enumerate() {
771 if *entry == prev_selected_entry {
772 self.selection = Some(ix);
773 break;
774 }
775 }
776 }
777 } else {
778 self.selection = self.selection.and_then(|prev_selection| {
779 if self.entries.is_empty() {
780 None
781 } else {
782 Some(prev_selection.min(self.entries.len() - 1))
783 }
784 });
785 }
786
787 let old_scroll_top = self.list_state.logical_scroll_top();
788 self.list_state.reset(self.entries.len());
789
790 if scroll_to_top {
791 self.list_state.scroll_to(ListOffset::default());
792 } else {
793 // Attempt to maintain the same scroll position.
794 if let Some(old_top_entry) = old_entries.get(old_scroll_top.item_ix) {
795 let new_scroll_top = self
796 .entries
797 .iter()
798 .position(|entry| entry == old_top_entry)
799 .map(|item_ix| ListOffset {
800 item_ix,
801 offset_in_item: old_scroll_top.offset_in_item,
802 })
803 .or_else(|| {
804 let entry_after_old_top = old_entries.get(old_scroll_top.item_ix + 1)?;
805 let item_ix = self
806 .entries
807 .iter()
808 .position(|entry| entry == entry_after_old_top)?;
809 Some(ListOffset {
810 item_ix,
811 offset_in_item: Pixels::ZERO,
812 })
813 })
814 .or_else(|| {
815 let entry_before_old_top =
816 old_entries.get(old_scroll_top.item_ix.saturating_sub(1))?;
817 let item_ix = self
818 .entries
819 .iter()
820 .position(|entry| entry == entry_before_old_top)?;
821 Some(ListOffset {
822 item_ix,
823 offset_in_item: Pixels::ZERO,
824 })
825 });
826
827 self.list_state
828 .scroll_to(new_scroll_top.unwrap_or(old_scroll_top));
829 }
830 }
831
832 cx.notify();
833 }
834
835 fn render_call_participant(
836 &self,
837 user: &Arc<User>,
838 peer_id: Option<PeerId>,
839 is_pending: bool,
840 role: proto::ChannelRole,
841 is_selected: bool,
842 cx: &mut ViewContext<Self>,
843 ) -> ListItem {
844 let user_id = user.id;
845 let is_current_user =
846 self.user_store.read(cx).current_user().map(|user| user.id) == Some(user_id);
847 let tooltip = format!("Follow {}", user.github_login);
848
849 let is_call_admin = ActiveCall::global(cx).read(cx).room().is_some_and(|room| {
850 room.read(cx).local_participant().role == proto::ChannelRole::Admin
851 });
852
853 ListItem::new(SharedString::from(user.github_login.clone()))
854 .start_slot(Avatar::new(user.avatar_uri.clone()))
855 .child(Label::new(user.github_login.clone()))
856 .selected(is_selected)
857 .end_slot(if is_pending {
858 Label::new("Calling").color(Color::Muted).into_any_element()
859 } else if is_current_user {
860 IconButton::new("leave-call", IconName::Exit)
861 .style(ButtonStyle::Subtle)
862 .on_click(move |_, cx| Self::leave_call(cx))
863 .tooltip(|cx| Tooltip::text("Leave Call", cx))
864 .into_any_element()
865 } else if role == proto::ChannelRole::Guest {
866 Label::new("Guest").color(Color::Muted).into_any_element()
867 } else if role == proto::ChannelRole::Talker {
868 Label::new("Mic only")
869 .color(Color::Muted)
870 .into_any_element()
871 } else {
872 div().into_any_element()
873 })
874 .when_some(peer_id, |el, peer_id| {
875 if role == proto::ChannelRole::Guest {
876 return el;
877 }
878 el.tooltip(move |cx| Tooltip::text(tooltip.clone(), cx))
879 .on_click(cx.listener(move |this, _, cx| {
880 this.workspace
881 .update(cx, |workspace, cx| workspace.follow(peer_id, cx))
882 .ok();
883 }))
884 })
885 .when(is_call_admin, |el| {
886 el.on_secondary_mouse_down(cx.listener(move |this, event: &MouseDownEvent, cx| {
887 this.deploy_participant_context_menu(event.position, user_id, role, cx)
888 }))
889 })
890 }
891
892 fn render_participant_project(
893 &self,
894 project_id: u64,
895 worktree_root_names: &[String],
896 host_user_id: u64,
897 is_last: bool,
898 is_selected: bool,
899 cx: &mut ViewContext<Self>,
900 ) -> impl IntoElement {
901 let project_name: SharedString = if worktree_root_names.is_empty() {
902 "untitled".to_string()
903 } else {
904 worktree_root_names.join(", ")
905 }
906 .into();
907
908 ListItem::new(project_id as usize)
909 .selected(is_selected)
910 .on_click(cx.listener(move |this, _, cx| {
911 this.workspace
912 .update(cx, |workspace, cx| {
913 let app_state = workspace.app_state().clone();
914 workspace::join_in_room_project(project_id, host_user_id, app_state, cx)
915 .detach_and_prompt_err("Failed to join project", cx, |_, _| None);
916 })
917 .ok();
918 }))
919 .start_slot(
920 h_flex()
921 .gap_1()
922 .child(render_tree_branch(is_last, false, cx))
923 .child(IconButton::new(0, IconName::Folder)),
924 )
925 .child(Label::new(project_name.clone()))
926 .tooltip(move |cx| Tooltip::text(format!("Open {}", project_name), cx))
927 }
928
929 fn render_participant_screen(
930 &self,
931 peer_id: Option<PeerId>,
932 is_last: bool,
933 is_selected: bool,
934 cx: &mut ViewContext<Self>,
935 ) -> impl IntoElement {
936 let id = peer_id.map_or(usize::MAX, |id| id.as_u64() as usize);
937
938 ListItem::new(("screen", id))
939 .selected(is_selected)
940 .start_slot(
941 h_flex()
942 .gap_1()
943 .child(render_tree_branch(is_last, false, cx))
944 .child(IconButton::new(0, IconName::Screen)),
945 )
946 .child(Label::new("Screen"))
947 .when_some(peer_id, |this, _| {
948 this.on_click(cx.listener(move |this, _, cx| {
949 this.workspace
950 .update(cx, |workspace, cx| {
951 workspace.open_shared_screen(peer_id.unwrap(), cx)
952 })
953 .ok();
954 }))
955 .tooltip(move |cx| Tooltip::text("Open shared screen", cx))
956 })
957 }
958
959 fn take_editing_state(&mut self, cx: &mut ViewContext<Self>) -> bool {
960 if let Some(_) = self.channel_editing_state.take() {
961 self.channel_name_editor.update(cx, |editor, cx| {
962 editor.set_text("", cx);
963 });
964 true
965 } else {
966 false
967 }
968 }
969
970 fn render_channel_notes(
971 &self,
972 channel_id: ChannelId,
973 is_selected: bool,
974 cx: &mut ViewContext<Self>,
975 ) -> impl IntoElement {
976 let channel_store = self.channel_store.read(cx);
977 let has_channel_buffer_changed = channel_store.has_channel_buffer_changed(channel_id);
978 ListItem::new("channel-notes")
979 .selected(is_selected)
980 .on_click(cx.listener(move |this, _, cx| {
981 this.open_channel_notes(channel_id, cx);
982 }))
983 .start_slot(
984 h_flex()
985 .relative()
986 .gap_1()
987 .child(render_tree_branch(false, true, cx))
988 .child(IconButton::new(0, IconName::File))
989 .children(has_channel_buffer_changed.then(|| {
990 div()
991 .w_1p5()
992 .absolute()
993 .right(px(2.))
994 .top(px(2.))
995 .child(Indicator::dot().color(Color::Info))
996 })),
997 )
998 .child(Label::new("notes"))
999 .tooltip(move |cx| Tooltip::text("Open Channel Notes", cx))
1000 }
1001
1002 fn render_channel_chat(
1003 &self,
1004 channel_id: ChannelId,
1005 is_selected: bool,
1006 cx: &mut ViewContext<Self>,
1007 ) -> impl IntoElement {
1008 let channel_store = self.channel_store.read(cx);
1009 let has_messages_notification = channel_store.has_new_messages(channel_id);
1010 ListItem::new("channel-chat")
1011 .selected(is_selected)
1012 .on_click(cx.listener(move |this, _, cx| {
1013 this.join_channel_chat(channel_id, cx);
1014 }))
1015 .start_slot(
1016 h_flex()
1017 .relative()
1018 .gap_1()
1019 .child(render_tree_branch(false, false, cx))
1020 .child(IconButton::new(0, IconName::MessageBubbles))
1021 .children(has_messages_notification.then(|| {
1022 div()
1023 .w_1p5()
1024 .absolute()
1025 .right(px(2.))
1026 .top(px(4.))
1027 .child(Indicator::dot().color(Color::Info))
1028 })),
1029 )
1030 .child(Label::new("chat"))
1031 .tooltip(move |cx| Tooltip::text("Open Chat", cx))
1032 }
1033
1034 fn render_channel_project(
1035 &self,
1036 id: ProjectId,
1037 name: &SharedString,
1038 is_selected: bool,
1039 cx: &mut ViewContext<Self>,
1040 ) -> impl IntoElement {
1041 ListItem::new(ElementId::NamedInteger(
1042 "channel-project".into(),
1043 id.0 as usize,
1044 ))
1045 .indent_level(2)
1046 .indent_step_size(px(20.))
1047 .selected(is_selected)
1048 .on_click(cx.listener(move |this, _, cx| {
1049 if let Some(workspace) = this.workspace.upgrade() {
1050 let app_state = workspace.read(cx).app_state().clone();
1051 workspace::join_hosted_project(id, app_state, cx).detach_and_prompt_err(
1052 "Failed to open project",
1053 cx,
1054 |_, _| None,
1055 )
1056 }
1057 }))
1058 .start_slot(
1059 h_flex()
1060 .relative()
1061 .gap_1()
1062 .child(IconButton::new(0, IconName::FileTree)),
1063 )
1064 .child(Label::new(name.clone()))
1065 .tooltip(move |cx| Tooltip::text("Open Project", cx))
1066 }
1067
1068 fn has_subchannels(&self, ix: usize) -> bool {
1069 self.entries.get(ix).map_or(false, |entry| {
1070 if let ListEntry::Channel { has_children, .. } = entry {
1071 *has_children
1072 } else {
1073 false
1074 }
1075 })
1076 }
1077
1078 fn deploy_participant_context_menu(
1079 &mut self,
1080 position: Point<Pixels>,
1081 user_id: u64,
1082 role: proto::ChannelRole,
1083 cx: &mut ViewContext<Self>,
1084 ) {
1085 let this = cx.view().clone();
1086 if !(role == proto::ChannelRole::Guest
1087 || role == proto::ChannelRole::Talker
1088 || role == proto::ChannelRole::Member)
1089 {
1090 return;
1091 }
1092
1093 let context_menu = ContextMenu::build(cx, |mut context_menu, cx| {
1094 if role == proto::ChannelRole::Guest {
1095 context_menu = context_menu.entry(
1096 "Grant Mic Access",
1097 None,
1098 cx.handler_for(&this, move |_, cx| {
1099 ActiveCall::global(cx)
1100 .update(cx, |call, cx| {
1101 let Some(room) = call.room() else {
1102 return Task::ready(Ok(()));
1103 };
1104 room.update(cx, |room, cx| {
1105 room.set_participant_role(
1106 user_id,
1107 proto::ChannelRole::Talker,
1108 cx,
1109 )
1110 })
1111 })
1112 .detach_and_prompt_err("Failed to grant mic access", cx, |_, _| None)
1113 }),
1114 );
1115 }
1116 if role == proto::ChannelRole::Guest || role == proto::ChannelRole::Talker {
1117 context_menu = context_menu.entry(
1118 "Grant Write Access",
1119 None,
1120 cx.handler_for(&this, move |_, cx| {
1121 ActiveCall::global(cx)
1122 .update(cx, |call, cx| {
1123 let Some(room) = call.room() else {
1124 return Task::ready(Ok(()));
1125 };
1126 room.update(cx, |room, cx| {
1127 room.set_participant_role(
1128 user_id,
1129 proto::ChannelRole::Member,
1130 cx,
1131 )
1132 })
1133 })
1134 .detach_and_prompt_err("Failed to grant write access", cx, |e, _| {
1135 match e.error_code() {
1136 ErrorCode::NeedsCla => Some("This user has not yet signed the CLA at https://zed.dev/cla.".into()),
1137 _ => None,
1138 }
1139 })
1140 }),
1141 );
1142 }
1143 if role == proto::ChannelRole::Member || role == proto::ChannelRole::Talker {
1144 let label = if role == proto::ChannelRole::Talker {
1145 "Mute"
1146 } else {
1147 "Revoke Access"
1148 };
1149 context_menu = context_menu.entry(
1150 label,
1151 None,
1152 cx.handler_for(&this, move |_, cx| {
1153 ActiveCall::global(cx)
1154 .update(cx, |call, cx| {
1155 let Some(room) = call.room() else {
1156 return Task::ready(Ok(()));
1157 };
1158 room.update(cx, |room, cx| {
1159 room.set_participant_role(
1160 user_id,
1161 proto::ChannelRole::Guest,
1162 cx,
1163 )
1164 })
1165 })
1166 .detach_and_prompt_err("Failed to revoke access", cx, |_, _| None)
1167 }),
1168 );
1169 }
1170
1171 context_menu
1172 });
1173
1174 cx.focus_view(&context_menu);
1175 let subscription =
1176 cx.subscribe(&context_menu, |this, _, _: &DismissEvent, cx| {
1177 if this.context_menu.as_ref().is_some_and(|context_menu| {
1178 context_menu.0.focus_handle(cx).contains_focused(cx)
1179 }) {
1180 cx.focus_self();
1181 }
1182 this.context_menu.take();
1183 cx.notify();
1184 });
1185 self.context_menu = Some((context_menu, position, subscription));
1186 }
1187
1188 fn deploy_channel_context_menu(
1189 &mut self,
1190 position: Point<Pixels>,
1191 channel_id: ChannelId,
1192 ix: usize,
1193 cx: &mut ViewContext<Self>,
1194 ) {
1195 let clipboard_channel_name = self.channel_clipboard.as_ref().and_then(|clipboard| {
1196 self.channel_store
1197 .read(cx)
1198 .channel_for_id(clipboard.channel_id)
1199 .map(|channel| channel.name.clone())
1200 });
1201 let this = cx.view().clone();
1202
1203 let context_menu = ContextMenu::build(cx, |mut context_menu, cx| {
1204 if self.has_subchannels(ix) {
1205 let expand_action_name = if self.is_channel_collapsed(channel_id) {
1206 "Expand Subchannels"
1207 } else {
1208 "Collapse Subchannels"
1209 };
1210 context_menu = context_menu.entry(
1211 expand_action_name,
1212 None,
1213 cx.handler_for(&this, move |this, cx| {
1214 this.toggle_channel_collapsed(channel_id, cx)
1215 }),
1216 );
1217 }
1218
1219 context_menu = context_menu
1220 .entry(
1221 "Open Notes",
1222 None,
1223 cx.handler_for(&this, move |this, cx| {
1224 this.open_channel_notes(channel_id, cx)
1225 }),
1226 )
1227 .entry(
1228 "Open Chat",
1229 None,
1230 cx.handler_for(&this, move |this, cx| {
1231 this.join_channel_chat(channel_id, cx)
1232 }),
1233 )
1234 .entry(
1235 "Copy Channel Link",
1236 None,
1237 cx.handler_for(&this, move |this, cx| {
1238 this.copy_channel_link(channel_id, cx)
1239 }),
1240 );
1241
1242 let mut has_destructive_actions = false;
1243 if self.channel_store.read(cx).is_channel_admin(channel_id) {
1244 has_destructive_actions = true;
1245 context_menu = context_menu
1246 .separator()
1247 .entry(
1248 "New Subchannel",
1249 None,
1250 cx.handler_for(&this, move |this, cx| this.new_subchannel(channel_id, cx)),
1251 )
1252 .entry(
1253 "Rename",
1254 Some(Box::new(SecondaryConfirm)),
1255 cx.handler_for(&this, move |this, cx| this.rename_channel(channel_id, cx)),
1256 );
1257
1258 if let Some(channel_name) = clipboard_channel_name {
1259 context_menu = context_menu.separator().entry(
1260 format!("Move '#{}' here", channel_name),
1261 None,
1262 cx.handler_for(&this, move |this, cx| {
1263 this.move_channel_on_clipboard(channel_id, cx)
1264 }),
1265 );
1266 }
1267
1268 if self.channel_store.read(cx).is_root_channel(channel_id) {
1269 context_menu = context_menu.separator().entry(
1270 "Manage Members",
1271 None,
1272 cx.handler_for(&this, move |this, cx| this.manage_members(channel_id, cx)),
1273 )
1274 } else {
1275 context_menu = context_menu.entry(
1276 "Move this channel",
1277 None,
1278 cx.handler_for(&this, move |this, cx| {
1279 this.start_move_channel(channel_id, cx)
1280 }),
1281 );
1282 if self.channel_store.read(cx).is_public_channel(channel_id) {
1283 context_menu = context_menu.separator().entry(
1284 "Make Channel Private",
1285 None,
1286 cx.handler_for(&this, move |this, cx| {
1287 this.set_channel_visibility(
1288 channel_id,
1289 ChannelVisibility::Members,
1290 cx,
1291 )
1292 }),
1293 )
1294 } else {
1295 context_menu = context_menu.separator().entry(
1296 "Make Channel Public",
1297 None,
1298 cx.handler_for(&this, move |this, cx| {
1299 this.set_channel_visibility(
1300 channel_id,
1301 ChannelVisibility::Public,
1302 cx,
1303 )
1304 }),
1305 )
1306 }
1307 }
1308
1309 context_menu = context_menu.entry(
1310 "Delete",
1311 None,
1312 cx.handler_for(&this, move |this, cx| this.remove_channel(channel_id, cx)),
1313 );
1314 }
1315
1316 if self.channel_store.read(cx).is_root_channel(channel_id) {
1317 if !has_destructive_actions {
1318 context_menu = context_menu.separator()
1319 }
1320 context_menu = context_menu.entry(
1321 "Leave Channel",
1322 None,
1323 cx.handler_for(&this, move |this, cx| this.leave_channel(channel_id, cx)),
1324 );
1325 }
1326
1327 context_menu
1328 });
1329
1330 cx.focus_view(&context_menu);
1331 let subscription =
1332 cx.subscribe(&context_menu, |this, _, _: &DismissEvent, cx| {
1333 if this.context_menu.as_ref().is_some_and(|context_menu| {
1334 context_menu.0.focus_handle(cx).contains_focused(cx)
1335 }) {
1336 cx.focus_self();
1337 }
1338 this.context_menu.take();
1339 cx.notify();
1340 });
1341 self.context_menu = Some((context_menu, position, subscription));
1342
1343 cx.notify();
1344 }
1345
1346 fn deploy_contact_context_menu(
1347 &mut self,
1348 position: Point<Pixels>,
1349 contact: Arc<Contact>,
1350 cx: &mut ViewContext<Self>,
1351 ) {
1352 let this = cx.view().clone();
1353 let in_room = ActiveCall::global(cx).read(cx).room().is_some();
1354
1355 let context_menu = ContextMenu::build(cx, |mut context_menu, _| {
1356 let user_id = contact.user.id;
1357
1358 if contact.online && !contact.busy {
1359 let label = if in_room {
1360 format!("Invite {} to join", contact.user.github_login)
1361 } else {
1362 format!("Call {}", contact.user.github_login)
1363 };
1364 context_menu = context_menu.entry(label, None, {
1365 let this = this.clone();
1366 move |cx| {
1367 this.update(cx, |this, cx| {
1368 this.call(user_id, cx);
1369 });
1370 }
1371 });
1372 }
1373
1374 context_menu.entry("Remove Contact", None, {
1375 let this = this.clone();
1376 move |cx| {
1377 this.update(cx, |this, cx| {
1378 this.remove_contact(contact.user.id, &contact.user.github_login, cx);
1379 });
1380 }
1381 })
1382 });
1383
1384 cx.focus_view(&context_menu);
1385 let subscription =
1386 cx.subscribe(&context_menu, |this, _, _: &DismissEvent, cx| {
1387 if this.context_menu.as_ref().is_some_and(|context_menu| {
1388 context_menu.0.focus_handle(cx).contains_focused(cx)
1389 }) {
1390 cx.focus_self();
1391 }
1392 this.context_menu.take();
1393 cx.notify();
1394 });
1395 self.context_menu = Some((context_menu, position, subscription));
1396
1397 cx.notify();
1398 }
1399
1400 fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
1401 if self.take_editing_state(cx) {
1402 cx.focus_view(&self.filter_editor);
1403 } else {
1404 self.filter_editor.update(cx, |editor, cx| {
1405 if editor.buffer().read(cx).len(cx) > 0 {
1406 editor.set_text("", cx);
1407 }
1408 });
1409 }
1410
1411 if self.context_menu.is_some() {
1412 self.context_menu.take();
1413 cx.notify();
1414 }
1415
1416 self.update_entries(false, cx);
1417 }
1418
1419 fn select_next(&mut self, _: &SelectNext, cx: &mut ViewContext<Self>) {
1420 let ix = self.selection.map_or(0, |ix| ix + 1);
1421 if ix < self.entries.len() {
1422 self.selection = Some(ix);
1423 }
1424
1425 if let Some(ix) = self.selection {
1426 self.scroll_to_item(ix)
1427 }
1428 cx.notify();
1429 }
1430
1431 fn select_prev(&mut self, _: &SelectPrev, cx: &mut ViewContext<Self>) {
1432 let ix = self.selection.take().unwrap_or(0);
1433 if ix > 0 {
1434 self.selection = Some(ix - 1);
1435 }
1436
1437 if let Some(ix) = self.selection {
1438 self.scroll_to_item(ix)
1439 }
1440 cx.notify();
1441 }
1442
1443 fn confirm(&mut self, _: &Confirm, cx: &mut ViewContext<Self>) {
1444 if self.confirm_channel_edit(cx) {
1445 return;
1446 }
1447
1448 if let Some(selection) = self.selection {
1449 if let Some(entry) = self.entries.get(selection) {
1450 match entry {
1451 ListEntry::Header(section) => match section {
1452 Section::ActiveCall => Self::leave_call(cx),
1453 Section::Channels => self.new_root_channel(cx),
1454 Section::Contacts => self.toggle_contact_finder(cx),
1455 Section::ContactRequests
1456 | Section::Online
1457 | Section::Offline
1458 | Section::ChannelInvites => {
1459 self.toggle_section_expanded(*section, cx);
1460 }
1461 },
1462 ListEntry::Contact { contact, calling } => {
1463 if contact.online && !contact.busy && !calling {
1464 self.call(contact.user.id, cx);
1465 }
1466 }
1467 ListEntry::ParticipantProject {
1468 project_id,
1469 host_user_id,
1470 ..
1471 } => {
1472 if let Some(workspace) = self.workspace.upgrade() {
1473 let app_state = workspace.read(cx).app_state().clone();
1474 workspace::join_in_room_project(
1475 *project_id,
1476 *host_user_id,
1477 app_state,
1478 cx,
1479 )
1480 .detach_and_prompt_err(
1481 "Failed to join project",
1482 cx,
1483 |_, _| None,
1484 );
1485 }
1486 }
1487 ListEntry::ParticipantScreen { peer_id, .. } => {
1488 let Some(peer_id) = peer_id else {
1489 return;
1490 };
1491 if let Some(workspace) = self.workspace.upgrade() {
1492 workspace.update(cx, |workspace, cx| {
1493 workspace.open_shared_screen(*peer_id, cx)
1494 });
1495 }
1496 }
1497 ListEntry::Channel { channel, .. } => {
1498 let is_active = maybe!({
1499 let call_channel = ActiveCall::global(cx)
1500 .read(cx)
1501 .room()?
1502 .read(cx)
1503 .channel_id()?;
1504
1505 Some(call_channel == channel.id)
1506 })
1507 .unwrap_or(false);
1508 if is_active {
1509 self.open_channel_notes(channel.id, cx)
1510 } else {
1511 self.join_channel(channel.id, cx)
1512 }
1513 }
1514 ListEntry::ContactPlaceholder => self.toggle_contact_finder(cx),
1515 ListEntry::CallParticipant { user, peer_id, .. } => {
1516 if Some(user) == self.user_store.read(cx).current_user().as_ref() {
1517 Self::leave_call(cx);
1518 } else if let Some(peer_id) = peer_id {
1519 self.workspace
1520 .update(cx, |workspace, cx| workspace.follow(*peer_id, cx))
1521 .ok();
1522 }
1523 }
1524 ListEntry::IncomingRequest(user) => {
1525 self.respond_to_contact_request(user.id, true, cx)
1526 }
1527 ListEntry::ChannelInvite(channel) => {
1528 self.respond_to_channel_invite(channel.id, true, cx)
1529 }
1530 ListEntry::ChannelNotes { channel_id } => {
1531 self.open_channel_notes(*channel_id, cx)
1532 }
1533 ListEntry::ChannelChat { channel_id } => {
1534 self.join_channel_chat(*channel_id, cx)
1535 }
1536 ListEntry::HostedProject {
1537 id: _id,
1538 name: _name,
1539 } => {
1540 // todo()
1541 }
1542 ListEntry::OutgoingRequest(_) => {}
1543 ListEntry::ChannelEditor { .. } => {}
1544 }
1545 }
1546 }
1547 }
1548
1549 fn insert_space(&mut self, _: &InsertSpace, cx: &mut ViewContext<Self>) {
1550 if self.channel_editing_state.is_some() {
1551 self.channel_name_editor.update(cx, |editor, cx| {
1552 editor.insert(" ", cx);
1553 });
1554 }
1555 }
1556
1557 fn confirm_channel_edit(&mut self, cx: &mut ViewContext<CollabPanel>) -> bool {
1558 if let Some(editing_state) = &mut self.channel_editing_state {
1559 match editing_state {
1560 ChannelEditingState::Create {
1561 location,
1562 pending_name,
1563 ..
1564 } => {
1565 if pending_name.is_some() {
1566 return false;
1567 }
1568 let channel_name = self.channel_name_editor.read(cx).text(cx);
1569
1570 *pending_name = Some(channel_name.clone());
1571
1572 let create = self.channel_store.update(cx, |channel_store, cx| {
1573 channel_store.create_channel(&channel_name, *location, cx)
1574 });
1575 if location.is_none() {
1576 cx.spawn(|this, mut cx| async move {
1577 let channel_id = create.await?;
1578 this.update(&mut cx, |this, cx| {
1579 this.show_channel_modal(
1580 channel_id,
1581 channel_modal::Mode::InviteMembers,
1582 cx,
1583 )
1584 })
1585 })
1586 .detach_and_prompt_err(
1587 "Failed to create channel",
1588 cx,
1589 |_, _| None,
1590 );
1591 } else {
1592 create.detach_and_prompt_err("Failed to create channel", cx, |_, _| None);
1593 }
1594 cx.notify();
1595 }
1596 ChannelEditingState::Rename {
1597 location,
1598 pending_name,
1599 } => {
1600 if pending_name.is_some() {
1601 return false;
1602 }
1603 let channel_name = self.channel_name_editor.read(cx).text(cx);
1604 *pending_name = Some(channel_name.clone());
1605
1606 self.channel_store
1607 .update(cx, |channel_store, cx| {
1608 channel_store.rename(*location, &channel_name, cx)
1609 })
1610 .detach();
1611 cx.notify();
1612 }
1613 }
1614 cx.focus_self();
1615 true
1616 } else {
1617 false
1618 }
1619 }
1620
1621 fn toggle_section_expanded(&mut self, section: Section, cx: &mut ViewContext<Self>) {
1622 if let Some(ix) = self.collapsed_sections.iter().position(|s| *s == section) {
1623 self.collapsed_sections.remove(ix);
1624 } else {
1625 self.collapsed_sections.push(section);
1626 }
1627 self.update_entries(false, cx);
1628 }
1629
1630 fn collapse_selected_channel(
1631 &mut self,
1632 _: &CollapseSelectedChannel,
1633 cx: &mut ViewContext<Self>,
1634 ) {
1635 let Some(channel_id) = self.selected_channel().map(|channel| channel.id) else {
1636 return;
1637 };
1638
1639 if self.is_channel_collapsed(channel_id) {
1640 return;
1641 }
1642
1643 self.toggle_channel_collapsed(channel_id, cx);
1644 }
1645
1646 fn expand_selected_channel(&mut self, _: &ExpandSelectedChannel, cx: &mut ViewContext<Self>) {
1647 let Some(id) = self.selected_channel().map(|channel| channel.id) else {
1648 return;
1649 };
1650
1651 if !self.is_channel_collapsed(id) {
1652 return;
1653 }
1654
1655 self.toggle_channel_collapsed(id, cx)
1656 }
1657
1658 fn toggle_channel_collapsed(&mut self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
1659 match self.collapsed_channels.binary_search(&channel_id) {
1660 Ok(ix) => {
1661 self.collapsed_channels.remove(ix);
1662 }
1663 Err(ix) => {
1664 self.collapsed_channels.insert(ix, channel_id);
1665 }
1666 };
1667 self.serialize(cx);
1668 self.update_entries(true, cx);
1669 cx.notify();
1670 cx.focus_self();
1671 }
1672
1673 fn is_channel_collapsed(&self, channel_id: ChannelId) -> bool {
1674 self.collapsed_channels.binary_search(&channel_id).is_ok()
1675 }
1676
1677 fn leave_call(cx: &mut WindowContext) {
1678 ActiveCall::global(cx)
1679 .update(cx, |call, cx| call.hang_up(cx))
1680 .detach_and_prompt_err("Failed to hang up", cx, |_, _| None);
1681 }
1682
1683 fn toggle_contact_finder(&mut self, cx: &mut ViewContext<Self>) {
1684 if let Some(workspace) = self.workspace.upgrade() {
1685 workspace.update(cx, |workspace, cx| {
1686 workspace.toggle_modal(cx, |cx| {
1687 let mut finder = ContactFinder::new(self.user_store.clone(), cx);
1688 finder.set_query(self.filter_editor.read(cx).text(cx), cx);
1689 finder
1690 });
1691 });
1692 }
1693 }
1694
1695 fn new_root_channel(&mut self, cx: &mut ViewContext<Self>) {
1696 self.channel_editing_state = Some(ChannelEditingState::Create {
1697 location: None,
1698 pending_name: None,
1699 });
1700 self.update_entries(false, cx);
1701 self.select_channel_editor();
1702 cx.focus_view(&self.channel_name_editor);
1703 cx.notify();
1704 }
1705
1706 fn select_channel_editor(&mut self) {
1707 self.selection = self.entries.iter().position(|entry| match entry {
1708 ListEntry::ChannelEditor { .. } => true,
1709 _ => false,
1710 });
1711 }
1712
1713 fn new_subchannel(&mut self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
1714 self.collapsed_channels
1715 .retain(|channel| *channel != channel_id);
1716 self.channel_editing_state = Some(ChannelEditingState::Create {
1717 location: Some(channel_id),
1718 pending_name: None,
1719 });
1720 self.update_entries(false, cx);
1721 self.select_channel_editor();
1722 cx.focus_view(&self.channel_name_editor);
1723 cx.notify();
1724 }
1725
1726 fn manage_members(&mut self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
1727 self.show_channel_modal(channel_id, channel_modal::Mode::ManageMembers, cx);
1728 }
1729
1730 fn remove_selected_channel(&mut self, _: &Remove, cx: &mut ViewContext<Self>) {
1731 if let Some(channel) = self.selected_channel() {
1732 self.remove_channel(channel.id, cx)
1733 }
1734 }
1735
1736 fn rename_selected_channel(&mut self, _: &SecondaryConfirm, cx: &mut ViewContext<Self>) {
1737 if let Some(channel) = self.selected_channel() {
1738 self.rename_channel(channel.id, cx);
1739 }
1740 }
1741
1742 fn rename_channel(&mut self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
1743 let channel_store = self.channel_store.read(cx);
1744 if !channel_store.is_channel_admin(channel_id) {
1745 return;
1746 }
1747 if let Some(channel) = channel_store.channel_for_id(channel_id).cloned() {
1748 self.channel_editing_state = Some(ChannelEditingState::Rename {
1749 location: channel_id,
1750 pending_name: None,
1751 });
1752 self.channel_name_editor.update(cx, |editor, cx| {
1753 editor.set_text(channel.name.clone(), cx);
1754 editor.select_all(&Default::default(), cx);
1755 });
1756 cx.focus_view(&self.channel_name_editor);
1757 self.update_entries(false, cx);
1758 self.select_channel_editor();
1759 }
1760 }
1761
1762 fn set_channel_visibility(
1763 &mut self,
1764 channel_id: ChannelId,
1765 visibility: ChannelVisibility,
1766 cx: &mut ViewContext<Self>,
1767 ) {
1768 self.channel_store
1769 .update(cx, |channel_store, cx| {
1770 channel_store.set_channel_visibility(channel_id, visibility, cx)
1771 })
1772 .detach_and_prompt_err("Failed to set channel visibility", cx, |e, _| match e.error_code() {
1773 ErrorCode::BadPublicNesting =>
1774 if e.error_tag("direction") == Some("parent") {
1775 Some("To make a channel public, its parent channel must be public.".to_string())
1776 } else {
1777 Some("To make a channel private, all of its subchannels must be private.".to_string())
1778 },
1779 _ => None
1780 });
1781 }
1782
1783 fn start_move_channel(&mut self, channel_id: ChannelId, _cx: &mut ViewContext<Self>) {
1784 self.channel_clipboard = Some(ChannelMoveClipboard { channel_id });
1785 }
1786
1787 fn start_move_selected_channel(&mut self, _: &StartMoveChannel, cx: &mut ViewContext<Self>) {
1788 if let Some(channel) = self.selected_channel() {
1789 self.start_move_channel(channel.id, cx);
1790 }
1791 }
1792
1793 fn move_channel_on_clipboard(
1794 &mut self,
1795 to_channel_id: ChannelId,
1796 cx: &mut ViewContext<CollabPanel>,
1797 ) {
1798 if let Some(clipboard) = self.channel_clipboard.take() {
1799 self.move_channel(clipboard.channel_id, to_channel_id, cx)
1800 }
1801 }
1802
1803 fn move_channel(&self, channel_id: ChannelId, to: ChannelId, cx: &mut ViewContext<Self>) {
1804 self.channel_store
1805 .update(cx, |channel_store, cx| {
1806 channel_store.move_channel(channel_id, to, cx)
1807 })
1808 .detach_and_prompt_err("Failed to move channel", cx, |e, _| match e.error_code() {
1809 ErrorCode::BadPublicNesting => {
1810 Some("Public channels must have public parents".into())
1811 }
1812 ErrorCode::CircularNesting => Some("You cannot move a channel into itself".into()),
1813 ErrorCode::WrongMoveTarget => {
1814 Some("You cannot move a channel into a different root channel".into())
1815 }
1816 _ => None,
1817 })
1818 }
1819
1820 fn open_channel_notes(&mut self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
1821 if let Some(workspace) = self.workspace.upgrade() {
1822 ChannelView::open(channel_id, None, workspace, cx).detach();
1823 }
1824 }
1825
1826 fn show_inline_context_menu(&mut self, _: &menu::SecondaryConfirm, cx: &mut ViewContext<Self>) {
1827 let Some(bounds) = self
1828 .selection
1829 .and_then(|ix| self.list_state.bounds_for_item(ix))
1830 else {
1831 return;
1832 };
1833
1834 if let Some(channel) = self.selected_channel() {
1835 self.deploy_channel_context_menu(
1836 bounds.center(),
1837 channel.id,
1838 self.selection.unwrap(),
1839 cx,
1840 );
1841 cx.stop_propagation();
1842 return;
1843 };
1844
1845 if let Some(contact) = self.selected_contact() {
1846 self.deploy_contact_context_menu(bounds.center(), contact, cx);
1847 cx.stop_propagation();
1848 return;
1849 };
1850 }
1851
1852 fn selected_channel(&self) -> Option<&Arc<Channel>> {
1853 self.selection
1854 .and_then(|ix| self.entries.get(ix))
1855 .and_then(|entry| match entry {
1856 ListEntry::Channel { channel, .. } => Some(channel),
1857 _ => None,
1858 })
1859 }
1860
1861 fn selected_contact(&self) -> Option<Arc<Contact>> {
1862 self.selection
1863 .and_then(|ix| self.entries.get(ix))
1864 .and_then(|entry| match entry {
1865 ListEntry::Contact { contact, .. } => Some(contact.clone()),
1866 _ => None,
1867 })
1868 }
1869
1870 fn show_channel_modal(
1871 &mut self,
1872 channel_id: ChannelId,
1873 mode: channel_modal::Mode,
1874 cx: &mut ViewContext<Self>,
1875 ) {
1876 let workspace = self.workspace.clone();
1877 let user_store = self.user_store.clone();
1878 let channel_store = self.channel_store.clone();
1879
1880 cx.spawn(|_, mut cx| async move {
1881 workspace.update(&mut cx, |workspace, cx| {
1882 workspace.toggle_modal(cx, |cx| {
1883 ChannelModal::new(
1884 user_store.clone(),
1885 channel_store.clone(),
1886 channel_id,
1887 mode,
1888 cx,
1889 )
1890 });
1891 })
1892 })
1893 .detach();
1894 }
1895
1896 fn leave_channel(&self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
1897 let Some(user_id) = self.user_store.read(cx).current_user().map(|u| u.id) else {
1898 return;
1899 };
1900 let Some(channel) = self.channel_store.read(cx).channel_for_id(channel_id) else {
1901 return;
1902 };
1903 let prompt_message = format!("Are you sure you want to leave \"#{}\"?", channel.name);
1904 let answer = cx.prompt(
1905 PromptLevel::Warning,
1906 &prompt_message,
1907 None,
1908 &["Leave", "Cancel"],
1909 );
1910 cx.spawn(|this, mut cx| async move {
1911 if answer.await? != 0 {
1912 return Ok(());
1913 }
1914 this.update(&mut cx, |this, cx| {
1915 this.channel_store.update(cx, |channel_store, cx| {
1916 channel_store.remove_member(channel_id, user_id, cx)
1917 })
1918 })?
1919 .await
1920 })
1921 .detach_and_prompt_err("Failed to leave channel", cx, |_, _| None)
1922 }
1923
1924 fn remove_channel(&mut self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
1925 let channel_store = self.channel_store.clone();
1926 if let Some(channel) = channel_store.read(cx).channel_for_id(channel_id) {
1927 let prompt_message = format!(
1928 "Are you sure you want to remove the channel \"{}\"?",
1929 channel.name
1930 );
1931 let answer = cx.prompt(
1932 PromptLevel::Warning,
1933 &prompt_message,
1934 None,
1935 &["Remove", "Cancel"],
1936 );
1937 cx.spawn(|this, mut cx| async move {
1938 if answer.await? == 0 {
1939 channel_store
1940 .update(&mut cx, |channels, _| channels.remove_channel(channel_id))?
1941 .await
1942 .notify_async_err(&mut cx);
1943 this.update(&mut cx, |_, cx| cx.focus_self()).ok();
1944 }
1945 anyhow::Ok(())
1946 })
1947 .detach();
1948 }
1949 }
1950
1951 fn remove_contact(&mut self, user_id: u64, github_login: &str, cx: &mut ViewContext<Self>) {
1952 let user_store = self.user_store.clone();
1953 let prompt_message = format!(
1954 "Are you sure you want to remove \"{}\" from your contacts?",
1955 github_login
1956 );
1957 let answer = cx.prompt(
1958 PromptLevel::Warning,
1959 &prompt_message,
1960 None,
1961 &["Remove", "Cancel"],
1962 );
1963 cx.spawn(|_, mut cx| async move {
1964 if answer.await? == 0 {
1965 user_store
1966 .update(&mut cx, |store, cx| store.remove_contact(user_id, cx))?
1967 .await
1968 .notify_async_err(&mut cx);
1969 }
1970 anyhow::Ok(())
1971 })
1972 .detach_and_prompt_err("Failed to remove contact", cx, |_, _| None);
1973 }
1974
1975 fn respond_to_contact_request(
1976 &mut self,
1977 user_id: u64,
1978 accept: bool,
1979 cx: &mut ViewContext<Self>,
1980 ) {
1981 self.user_store
1982 .update(cx, |store, cx| {
1983 store.respond_to_contact_request(user_id, accept, cx)
1984 })
1985 .detach_and_prompt_err("Failed to respond to contact request", cx, |_, _| None);
1986 }
1987
1988 fn respond_to_channel_invite(
1989 &mut self,
1990 channel_id: ChannelId,
1991 accept: bool,
1992 cx: &mut ViewContext<Self>,
1993 ) {
1994 self.channel_store
1995 .update(cx, |store, cx| {
1996 store.respond_to_channel_invite(channel_id, accept, cx)
1997 })
1998 .detach();
1999 }
2000
2001 fn call(&mut self, recipient_user_id: u64, cx: &mut ViewContext<Self>) {
2002 ActiveCall::global(cx)
2003 .update(cx, |call, cx| {
2004 call.invite(recipient_user_id, Some(self.project.clone()), cx)
2005 })
2006 .detach_and_prompt_err("Call failed", cx, |_, _| None);
2007 }
2008
2009 fn join_channel(&self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
2010 let Some(workspace) = self.workspace.upgrade() else {
2011 return;
2012 };
2013 let Some(handle) = cx.window_handle().downcast::<Workspace>() else {
2014 return;
2015 };
2016 workspace::join_channel(
2017 channel_id,
2018 workspace.read(cx).app_state().clone(),
2019 Some(handle),
2020 cx,
2021 )
2022 .detach_and_prompt_err("Failed to join channel", cx, |_, _| None)
2023 }
2024
2025 fn join_channel_chat(&mut self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
2026 let Some(workspace) = self.workspace.upgrade() else {
2027 return;
2028 };
2029 cx.window_context().defer(move |cx| {
2030 workspace.update(cx, |workspace, cx| {
2031 if let Some(panel) = workspace.focus_panel::<ChatPanel>(cx) {
2032 panel.update(cx, |panel, cx| {
2033 panel
2034 .select_channel(channel_id, None, cx)
2035 .detach_and_notify_err(cx);
2036 });
2037 }
2038 });
2039 });
2040 }
2041
2042 fn copy_channel_link(&mut self, channel_id: ChannelId, cx: &mut ViewContext<Self>) {
2043 let channel_store = self.channel_store.read(cx);
2044 let Some(channel) = channel_store.channel_for_id(channel_id) else {
2045 return;
2046 };
2047 let item = ClipboardItem::new(channel.link(cx));
2048 cx.write_to_clipboard(item)
2049 }
2050
2051 fn render_signed_out(&mut self, cx: &mut ViewContext<Self>) -> Div {
2052 let collab_blurb = "Work with your team in realtime with collaborative editing, voice, shared notes and more.";
2053
2054 v_flex()
2055 .gap_6()
2056 .p_4()
2057 .child(Label::new(collab_blurb))
2058 .child(
2059 v_flex()
2060 .gap_2()
2061 .child(
2062 Button::new("sign_in", "Sign in")
2063 .icon_color(Color::Muted)
2064 .icon(IconName::Github)
2065 .icon_position(IconPosition::Start)
2066 .style(ButtonStyle::Filled)
2067 .full_width()
2068 .on_click(cx.listener(|this, _, cx| {
2069 let client = this.client.clone();
2070 cx.spawn(|_, mut cx| async move {
2071 client
2072 .authenticate_and_connect(true, &cx)
2073 .await
2074 .notify_async_err(&mut cx);
2075 })
2076 .detach()
2077 })),
2078 )
2079 .child(
2080 div().flex().w_full().items_center().child(
2081 Label::new("Sign in to enable collaboration.")
2082 .color(Color::Muted)
2083 .size(LabelSize::Small),
2084 ),
2085 ),
2086 )
2087 }
2088
2089 fn render_list_entry(&mut self, ix: usize, cx: &mut ViewContext<Self>) -> AnyElement {
2090 let entry = &self.entries[ix];
2091
2092 let is_selected = self.selection == Some(ix);
2093 match entry {
2094 ListEntry::Header(section) => {
2095 let is_collapsed = self.collapsed_sections.contains(section);
2096 self.render_header(*section, is_selected, is_collapsed, cx)
2097 .into_any_element()
2098 }
2099 ListEntry::Contact { contact, calling } => self
2100 .render_contact(contact, *calling, is_selected, cx)
2101 .into_any_element(),
2102 ListEntry::ContactPlaceholder => self
2103 .render_contact_placeholder(is_selected, cx)
2104 .into_any_element(),
2105 ListEntry::IncomingRequest(user) => self
2106 .render_contact_request(user, true, is_selected, cx)
2107 .into_any_element(),
2108 ListEntry::OutgoingRequest(user) => self
2109 .render_contact_request(user, false, is_selected, cx)
2110 .into_any_element(),
2111 ListEntry::Channel {
2112 channel,
2113 depth,
2114 has_children,
2115 } => self
2116 .render_channel(channel, *depth, *has_children, is_selected, ix, cx)
2117 .into_any_element(),
2118 ListEntry::ChannelEditor { depth } => {
2119 self.render_channel_editor(*depth, cx).into_any_element()
2120 }
2121 ListEntry::ChannelInvite(channel) => self
2122 .render_channel_invite(channel, is_selected, cx)
2123 .into_any_element(),
2124 ListEntry::CallParticipant {
2125 user,
2126 peer_id,
2127 is_pending,
2128 role,
2129 } => self
2130 .render_call_participant(user, *peer_id, *is_pending, *role, is_selected, cx)
2131 .into_any_element(),
2132 ListEntry::ParticipantProject {
2133 project_id,
2134 worktree_root_names,
2135 host_user_id,
2136 is_last,
2137 } => self
2138 .render_participant_project(
2139 *project_id,
2140 &worktree_root_names,
2141 *host_user_id,
2142 *is_last,
2143 is_selected,
2144 cx,
2145 )
2146 .into_any_element(),
2147 ListEntry::ParticipantScreen { peer_id, is_last } => self
2148 .render_participant_screen(*peer_id, *is_last, is_selected, cx)
2149 .into_any_element(),
2150 ListEntry::ChannelNotes { channel_id } => self
2151 .render_channel_notes(*channel_id, is_selected, cx)
2152 .into_any_element(),
2153 ListEntry::ChannelChat { channel_id } => self
2154 .render_channel_chat(*channel_id, is_selected, cx)
2155 .into_any_element(),
2156
2157 ListEntry::HostedProject { id, name } => self
2158 .render_channel_project(*id, name, is_selected, cx)
2159 .into_any_element(),
2160 }
2161 }
2162
2163 fn render_signed_in(&mut self, cx: &mut ViewContext<Self>) -> Div {
2164 v_flex()
2165 .size_full()
2166 .child(list(self.list_state.clone()).size_full())
2167 .child(
2168 v_flex()
2169 .child(div().mx_2().border_primary(cx).border_t_1())
2170 .child(
2171 v_flex()
2172 .p_2()
2173 .child(self.render_filter_input(&self.filter_editor, cx)),
2174 ),
2175 )
2176 }
2177
2178 fn render_filter_input(
2179 &self,
2180 editor: &View<Editor>,
2181 cx: &mut ViewContext<Self>,
2182 ) -> impl IntoElement {
2183 let settings = ThemeSettings::get_global(cx);
2184 let text_style = TextStyle {
2185 color: if editor.read(cx).read_only(cx) {
2186 cx.theme().colors().text_disabled
2187 } else {
2188 cx.theme().colors().text
2189 },
2190 font_family: settings.ui_font.family.clone(),
2191 font_features: settings.ui_font.features.clone(),
2192 font_size: rems(0.875).into(),
2193 font_weight: settings.ui_font.weight,
2194 font_style: FontStyle::Normal,
2195 line_height: relative(1.3),
2196 background_color: None,
2197 underline: None,
2198 strikethrough: None,
2199 white_space: WhiteSpace::Normal,
2200 };
2201
2202 EditorElement::new(
2203 editor,
2204 EditorStyle {
2205 local_player: cx.theme().players().local(),
2206 text: text_style,
2207 ..Default::default()
2208 },
2209 )
2210 }
2211
2212 fn render_header(
2213 &self,
2214 section: Section,
2215 is_selected: bool,
2216 is_collapsed: bool,
2217 cx: &ViewContext<Self>,
2218 ) -> impl IntoElement {
2219 let mut channel_link = None;
2220 let mut channel_tooltip_text = None;
2221 let mut channel_icon = None;
2222
2223 let text = match section {
2224 Section::ActiveCall => {
2225 let channel_name = maybe!({
2226 let channel_id = ActiveCall::global(cx).read(cx).channel_id(cx)?;
2227
2228 let channel = self.channel_store.read(cx).channel_for_id(channel_id)?;
2229
2230 channel_link = Some(channel.link(cx));
2231 (channel_icon, channel_tooltip_text) = match channel.visibility {
2232 proto::ChannelVisibility::Public => {
2233 (Some("icons/public.svg"), Some("Copy public channel link."))
2234 }
2235 proto::ChannelVisibility::Members => {
2236 (Some("icons/hash.svg"), Some("Copy private channel link."))
2237 }
2238 };
2239
2240 Some(channel.name.as_ref())
2241 });
2242
2243 if let Some(name) = channel_name {
2244 SharedString::from(name.to_string())
2245 } else {
2246 SharedString::from("Current Call")
2247 }
2248 }
2249 Section::ContactRequests => SharedString::from("Requests"),
2250 Section::Contacts => SharedString::from("Contacts"),
2251 Section::Channels => SharedString::from("Channels"),
2252 Section::ChannelInvites => SharedString::from("Invites"),
2253 Section::Online => SharedString::from("Online"),
2254 Section::Offline => SharedString::from("Offline"),
2255 };
2256
2257 let button = match section {
2258 Section::ActiveCall => channel_link.map(|channel_link| {
2259 let channel_link_copy = channel_link.clone();
2260 IconButton::new("channel-link", IconName::Copy)
2261 .icon_size(IconSize::Small)
2262 .size(ButtonSize::None)
2263 .visible_on_hover("section-header")
2264 .on_click(move |_, cx| {
2265 let item = ClipboardItem::new(channel_link_copy.clone());
2266 cx.write_to_clipboard(item)
2267 })
2268 .tooltip(|cx| Tooltip::text("Copy channel link", cx))
2269 .into_any_element()
2270 }),
2271 Section::Contacts => Some(
2272 IconButton::new("add-contact", IconName::Plus)
2273 .on_click(cx.listener(|this, _, cx| this.toggle_contact_finder(cx)))
2274 .tooltip(|cx| Tooltip::text("Search for new contact", cx))
2275 .into_any_element(),
2276 ),
2277 Section::Channels => Some(
2278 IconButton::new("add-channel", IconName::Plus)
2279 .on_click(cx.listener(|this, _, cx| this.new_root_channel(cx)))
2280 .tooltip(|cx| Tooltip::text("Create a channel", cx))
2281 .into_any_element(),
2282 ),
2283 _ => None,
2284 };
2285
2286 let can_collapse = match section {
2287 Section::ActiveCall | Section::Channels | Section::Contacts => false,
2288 Section::ChannelInvites
2289 | Section::ContactRequests
2290 | Section::Online
2291 | Section::Offline => true,
2292 };
2293
2294 h_flex().w_full().group("section-header").child(
2295 ListHeader::new(text)
2296 .when(can_collapse, |header| {
2297 header
2298 .toggle(Some(!is_collapsed))
2299 .on_toggle(cx.listener(move |this, _, cx| {
2300 this.toggle_section_expanded(section, cx);
2301 }))
2302 })
2303 .inset(true)
2304 .end_slot::<AnyElement>(button)
2305 .selected(is_selected),
2306 )
2307 }
2308
2309 fn render_contact(
2310 &self,
2311 contact: &Arc<Contact>,
2312 calling: bool,
2313 is_selected: bool,
2314 cx: &mut ViewContext<Self>,
2315 ) -> impl IntoElement {
2316 let online = contact.online;
2317 let busy = contact.busy || calling;
2318 let github_login = SharedString::from(contact.user.github_login.clone());
2319 let item = ListItem::new(github_login.clone())
2320 .indent_level(1)
2321 .indent_step_size(px(20.))
2322 .selected(is_selected)
2323 .child(
2324 h_flex()
2325 .w_full()
2326 .justify_between()
2327 .child(Label::new(github_login.clone()))
2328 .when(calling, |el| {
2329 el.child(Label::new("Calling").color(Color::Muted))
2330 })
2331 .when(!calling, |el| {
2332 el.child(
2333 IconButton::new("contact context menu", IconName::Ellipsis)
2334 .icon_color(Color::Muted)
2335 .visible_on_hover("")
2336 .on_click(cx.listener({
2337 let contact = contact.clone();
2338 move |this, event: &ClickEvent, cx| {
2339 this.deploy_contact_context_menu(
2340 event.down.position,
2341 contact.clone(),
2342 cx,
2343 );
2344 }
2345 })),
2346 )
2347 }),
2348 )
2349 .on_secondary_mouse_down(cx.listener({
2350 let contact = contact.clone();
2351 move |this, event: &MouseDownEvent, cx| {
2352 this.deploy_contact_context_menu(event.position, contact.clone(), cx);
2353 }
2354 }))
2355 .start_slot(
2356 // todo handle contacts with no avatar
2357 Avatar::new(contact.user.avatar_uri.clone())
2358 .indicator::<AvatarAvailabilityIndicator>(if online {
2359 Some(AvatarAvailabilityIndicator::new(match busy {
2360 true => ui::Availability::Busy,
2361 false => ui::Availability::Free,
2362 }))
2363 } else {
2364 None
2365 }),
2366 );
2367
2368 div()
2369 .id(github_login.clone())
2370 .group("")
2371 .child(item)
2372 .tooltip(move |cx| {
2373 let text = if !online {
2374 format!(" {} is offline", &github_login)
2375 } else if busy {
2376 format!(" {} is on a call", &github_login)
2377 } else {
2378 let room = ActiveCall::global(cx).read(cx).room();
2379 if room.is_some() {
2380 format!("Invite {} to join call", &github_login)
2381 } else {
2382 format!("Call {}", &github_login)
2383 }
2384 };
2385 Tooltip::text(text, cx)
2386 })
2387 }
2388
2389 fn render_contact_request(
2390 &self,
2391 user: &Arc<User>,
2392 is_incoming: bool,
2393 is_selected: bool,
2394 cx: &mut ViewContext<Self>,
2395 ) -> impl IntoElement {
2396 let github_login = SharedString::from(user.github_login.clone());
2397 let user_id = user.id;
2398 let is_response_pending = self.user_store.read(cx).is_contact_request_pending(&user);
2399 let color = if is_response_pending {
2400 Color::Muted
2401 } else {
2402 Color::Default
2403 };
2404
2405 let controls = if is_incoming {
2406 vec![
2407 IconButton::new("decline-contact", IconName::Close)
2408 .on_click(cx.listener(move |this, _, cx| {
2409 this.respond_to_contact_request(user_id, false, cx);
2410 }))
2411 .icon_color(color)
2412 .tooltip(|cx| Tooltip::text("Decline invite", cx)),
2413 IconButton::new("accept-contact", IconName::Check)
2414 .on_click(cx.listener(move |this, _, cx| {
2415 this.respond_to_contact_request(user_id, true, cx);
2416 }))
2417 .icon_color(color)
2418 .tooltip(|cx| Tooltip::text("Accept invite", cx)),
2419 ]
2420 } else {
2421 let github_login = github_login.clone();
2422 vec![IconButton::new("remove_contact", IconName::Close)
2423 .on_click(cx.listener(move |this, _, cx| {
2424 this.remove_contact(user_id, &github_login, cx);
2425 }))
2426 .icon_color(color)
2427 .tooltip(|cx| Tooltip::text("Cancel invite", cx))]
2428 };
2429
2430 ListItem::new(github_login.clone())
2431 .indent_level(1)
2432 .indent_step_size(px(20.))
2433 .selected(is_selected)
2434 .child(
2435 h_flex()
2436 .w_full()
2437 .justify_between()
2438 .child(Label::new(github_login.clone()))
2439 .child(h_flex().children(controls)),
2440 )
2441 .start_slot(Avatar::new(user.avatar_uri.clone()))
2442 }
2443
2444 fn render_channel_invite(
2445 &self,
2446 channel: &Arc<Channel>,
2447 is_selected: bool,
2448 cx: &mut ViewContext<Self>,
2449 ) -> ListItem {
2450 let channel_id = channel.id;
2451 let response_is_pending = self
2452 .channel_store
2453 .read(cx)
2454 .has_pending_channel_invite_response(&channel);
2455 let color = if response_is_pending {
2456 Color::Muted
2457 } else {
2458 Color::Default
2459 };
2460
2461 let controls = [
2462 IconButton::new("reject-invite", IconName::Close)
2463 .on_click(cx.listener(move |this, _, cx| {
2464 this.respond_to_channel_invite(channel_id, false, cx);
2465 }))
2466 .icon_color(color)
2467 .tooltip(|cx| Tooltip::text("Decline invite", cx)),
2468 IconButton::new("accept-invite", IconName::Check)
2469 .on_click(cx.listener(move |this, _, cx| {
2470 this.respond_to_channel_invite(channel_id, true, cx);
2471 }))
2472 .icon_color(color)
2473 .tooltip(|cx| Tooltip::text("Accept invite", cx)),
2474 ];
2475
2476 ListItem::new(("channel-invite", channel.id.0 as usize))
2477 .selected(is_selected)
2478 .child(
2479 h_flex()
2480 .w_full()
2481 .justify_between()
2482 .child(Label::new(channel.name.clone()))
2483 .child(h_flex().children(controls)),
2484 )
2485 .start_slot(
2486 Icon::new(IconName::Hash)
2487 .size(IconSize::Small)
2488 .color(Color::Muted),
2489 )
2490 }
2491
2492 fn render_contact_placeholder(
2493 &self,
2494 is_selected: bool,
2495 cx: &mut ViewContext<Self>,
2496 ) -> ListItem {
2497 ListItem::new("contact-placeholder")
2498 .child(Icon::new(IconName::Plus))
2499 .child(Label::new("Add a Contact"))
2500 .selected(is_selected)
2501 .on_click(cx.listener(|this, _, cx| this.toggle_contact_finder(cx)))
2502 }
2503
2504 fn render_channel(
2505 &self,
2506 channel: &Channel,
2507 depth: usize,
2508 has_children: bool,
2509 is_selected: bool,
2510 ix: usize,
2511 cx: &mut ViewContext<Self>,
2512 ) -> impl IntoElement {
2513 let channel_id = channel.id;
2514
2515 let is_active = maybe!({
2516 let call_channel = ActiveCall::global(cx)
2517 .read(cx)
2518 .room()?
2519 .read(cx)
2520 .channel_id()?;
2521 Some(call_channel == channel_id)
2522 })
2523 .unwrap_or(false);
2524 let channel_store = self.channel_store.read(cx);
2525 let is_public = channel_store
2526 .channel_for_id(channel_id)
2527 .map(|channel| channel.visibility)
2528 == Some(proto::ChannelVisibility::Public);
2529 let disclosed =
2530 has_children.then(|| self.collapsed_channels.binary_search(&channel.id).is_err());
2531
2532 let has_messages_notification = channel_store.has_new_messages(channel_id);
2533 let has_notes_notification = channel_store.has_channel_buffer_changed(channel_id);
2534
2535 const FACEPILE_LIMIT: usize = 3;
2536 let participants = self.channel_store.read(cx).channel_participants(channel_id);
2537
2538 let face_pile = if participants.is_empty() {
2539 None
2540 } else {
2541 let extra_count = participants.len().saturating_sub(FACEPILE_LIMIT);
2542 let result = FacePile::new(
2543 participants
2544 .iter()
2545 .map(|user| Avatar::new(user.avatar_uri.clone()).into_any_element())
2546 .take(FACEPILE_LIMIT)
2547 .chain(if extra_count > 0 {
2548 Some(
2549 div()
2550 .ml_2()
2551 .child(Label::new(format!("+{extra_count}")))
2552 .into_any_element(),
2553 )
2554 } else {
2555 None
2556 })
2557 .collect::<SmallVec<_>>(),
2558 );
2559
2560 Some(result)
2561 };
2562
2563 let width = self.width.unwrap_or(px(240.));
2564 let root_id = channel.root_id();
2565
2566 div()
2567 .h_6()
2568 .id(channel_id.0 as usize)
2569 .group("")
2570 .flex()
2571 .w_full()
2572 .when(!channel.is_root_channel(), |el| {
2573 el.on_drag(channel.clone(), move |channel, cx| {
2574 cx.new_view(|_| DraggedChannelView {
2575 channel: channel.clone(),
2576 width,
2577 })
2578 })
2579 })
2580 .drag_over::<Channel>({
2581 move |style, dragged_channel: &Channel, cx| {
2582 if dragged_channel.root_id() == root_id {
2583 style.bg(cx.theme().colors().ghost_element_hover)
2584 } else {
2585 style
2586 }
2587 }
2588 })
2589 .on_drop(cx.listener(move |this, dragged_channel: &Channel, cx| {
2590 if dragged_channel.root_id() != root_id {
2591 return;
2592 }
2593 this.move_channel(dragged_channel.id, channel_id, cx);
2594 }))
2595 .child(
2596 ListItem::new(channel_id.0 as usize)
2597 // Add one level of depth for the disclosure arrow.
2598 .indent_level(depth + 1)
2599 .indent_step_size(px(20.))
2600 .selected(is_selected || is_active)
2601 .toggle(disclosed)
2602 .on_toggle(
2603 cx.listener(move |this, _, cx| {
2604 this.toggle_channel_collapsed(channel_id, cx)
2605 }),
2606 )
2607 .on_click(cx.listener(move |this, _, cx| {
2608 if is_active {
2609 this.open_channel_notes(channel_id, cx)
2610 } else {
2611 this.join_channel(channel_id, cx)
2612 }
2613 }))
2614 .on_secondary_mouse_down(cx.listener(
2615 move |this, event: &MouseDownEvent, cx| {
2616 this.deploy_channel_context_menu(event.position, channel_id, ix, cx)
2617 },
2618 ))
2619 .start_slot(
2620 div()
2621 .relative()
2622 .child(
2623 Icon::new(if is_public {
2624 IconName::Public
2625 } else {
2626 IconName::Hash
2627 })
2628 .size(IconSize::Small)
2629 .color(Color::Muted),
2630 )
2631 .children(has_notes_notification.then(|| {
2632 div()
2633 .w_1p5()
2634 .absolute()
2635 .right(px(-1.))
2636 .top(px(-1.))
2637 .child(Indicator::dot().color(Color::Info))
2638 })),
2639 )
2640 .child(
2641 h_flex()
2642 .id(channel_id.0 as usize)
2643 .child(Label::new(channel.name.clone()))
2644 .children(face_pile.map(|face_pile| face_pile.p_1())),
2645 ),
2646 )
2647 .child(
2648 h_flex().absolute().right(rems(0.)).h_full().child(
2649 h_flex()
2650 .h_full()
2651 .gap_1()
2652 .px_1()
2653 .child(
2654 IconButton::new("channel_chat", IconName::MessageBubbles)
2655 .style(ButtonStyle::Filled)
2656 .shape(ui::IconButtonShape::Square)
2657 .icon_size(IconSize::Small)
2658 .icon_color(if has_messages_notification {
2659 Color::Default
2660 } else {
2661 Color::Muted
2662 })
2663 .on_click(cx.listener(move |this, _, cx| {
2664 this.join_channel_chat(channel_id, cx)
2665 }))
2666 .tooltip(|cx| Tooltip::text("Open channel chat", cx))
2667 .visible_on_hover(""),
2668 )
2669 .child(
2670 IconButton::new("channel_notes", IconName::File)
2671 .style(ButtonStyle::Filled)
2672 .shape(ui::IconButtonShape::Square)
2673 .icon_size(IconSize::Small)
2674 .icon_color(if has_notes_notification {
2675 Color::Default
2676 } else {
2677 Color::Muted
2678 })
2679 .on_click(cx.listener(move |this, _, cx| {
2680 this.open_channel_notes(channel_id, cx)
2681 }))
2682 .tooltip(|cx| Tooltip::text("Open channel notes", cx))
2683 .visible_on_hover(""),
2684 ),
2685 ),
2686 )
2687 .tooltip({
2688 let channel_store = self.channel_store.clone();
2689 move |cx| {
2690 cx.new_view(|_| JoinChannelTooltip {
2691 channel_store: channel_store.clone(),
2692 channel_id,
2693 has_notes_notification,
2694 })
2695 .into()
2696 }
2697 })
2698 }
2699
2700 fn render_channel_editor(&self, depth: usize, _cx: &mut ViewContext<Self>) -> impl IntoElement {
2701 let item = ListItem::new("channel-editor")
2702 .inset(false)
2703 // Add one level of depth for the disclosure arrow.
2704 .indent_level(depth + 1)
2705 .indent_step_size(px(20.))
2706 .start_slot(
2707 Icon::new(IconName::Hash)
2708 .size(IconSize::Small)
2709 .color(Color::Muted),
2710 );
2711
2712 if let Some(pending_name) = self
2713 .channel_editing_state
2714 .as_ref()
2715 .and_then(|state| state.pending_name())
2716 {
2717 item.child(Label::new(pending_name))
2718 } else {
2719 item.child(self.channel_name_editor.clone())
2720 }
2721 }
2722}
2723
2724fn render_tree_branch(is_last: bool, overdraw: bool, cx: &mut WindowContext) -> impl IntoElement {
2725 let rem_size = cx.rem_size();
2726 let line_height = cx.text_style().line_height_in_pixels(rem_size);
2727 let width = rem_size * 1.5;
2728 let thickness = px(1.);
2729 let color = cx.theme().colors().text;
2730
2731 canvas(
2732 |_, _| {},
2733 move |bounds, _, cx| {
2734 let start_x = (bounds.left() + bounds.right() - thickness) / 2.;
2735 let start_y = (bounds.top() + bounds.bottom() - thickness) / 2.;
2736 let right = bounds.right();
2737 let top = bounds.top();
2738
2739 cx.paint_quad(fill(
2740 Bounds::from_corners(
2741 point(start_x, top),
2742 point(
2743 start_x + thickness,
2744 if is_last {
2745 start_y
2746 } else {
2747 bounds.bottom() + if overdraw { px(1.) } else { px(0.) }
2748 },
2749 ),
2750 ),
2751 color,
2752 ));
2753 cx.paint_quad(fill(
2754 Bounds::from_corners(point(start_x, start_y), point(right, start_y + thickness)),
2755 color,
2756 ));
2757 },
2758 )
2759 .w(width)
2760 .h(line_height)
2761}
2762
2763impl Render for CollabPanel {
2764 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
2765 v_flex()
2766 .key_context("CollabPanel")
2767 .on_action(cx.listener(CollabPanel::cancel))
2768 .on_action(cx.listener(CollabPanel::select_next))
2769 .on_action(cx.listener(CollabPanel::select_prev))
2770 .on_action(cx.listener(CollabPanel::confirm))
2771 .on_action(cx.listener(CollabPanel::insert_space))
2772 .on_action(cx.listener(CollabPanel::remove_selected_channel))
2773 .on_action(cx.listener(CollabPanel::show_inline_context_menu))
2774 .on_action(cx.listener(CollabPanel::rename_selected_channel))
2775 .on_action(cx.listener(CollabPanel::collapse_selected_channel))
2776 .on_action(cx.listener(CollabPanel::expand_selected_channel))
2777 .on_action(cx.listener(CollabPanel::start_move_selected_channel))
2778 .track_focus(&self.focus_handle)
2779 .size_full()
2780 .child(if self.user_store.read(cx).current_user().is_none() {
2781 self.render_signed_out(cx)
2782 } else {
2783 self.render_signed_in(cx)
2784 })
2785 .children(self.context_menu.as_ref().map(|(menu, position, _)| {
2786 deferred(
2787 anchored()
2788 .position(*position)
2789 .anchor(gpui::AnchorCorner::TopLeft)
2790 .child(menu.clone()),
2791 )
2792 .with_priority(1)
2793 }))
2794 }
2795}
2796
2797impl EventEmitter<PanelEvent> for CollabPanel {}
2798
2799impl Panel for CollabPanel {
2800 fn position(&self, cx: &gpui::WindowContext) -> DockPosition {
2801 CollaborationPanelSettings::get_global(cx).dock
2802 }
2803
2804 fn position_is_valid(&self, position: DockPosition) -> bool {
2805 matches!(position, DockPosition::Left | DockPosition::Right)
2806 }
2807
2808 fn set_position(&mut self, position: DockPosition, cx: &mut ViewContext<Self>) {
2809 settings::update_settings_file::<CollaborationPanelSettings>(
2810 self.fs.clone(),
2811 cx,
2812 move |settings| settings.dock = Some(position),
2813 );
2814 }
2815
2816 fn size(&self, cx: &gpui::WindowContext) -> Pixels {
2817 self.width
2818 .unwrap_or_else(|| CollaborationPanelSettings::get_global(cx).default_width)
2819 }
2820
2821 fn set_size(&mut self, size: Option<Pixels>, cx: &mut ViewContext<Self>) {
2822 self.width = size;
2823 self.serialize(cx);
2824 cx.notify();
2825 }
2826
2827 fn icon(&self, cx: &gpui::WindowContext) -> Option<ui::IconName> {
2828 CollaborationPanelSettings::get_global(cx)
2829 .button
2830 .then(|| ui::IconName::Collab)
2831 }
2832
2833 fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
2834 Some("Collab Panel")
2835 }
2836
2837 fn toggle_action(&self) -> Box<dyn gpui::Action> {
2838 Box::new(ToggleFocus)
2839 }
2840
2841 fn persistent_name() -> &'static str {
2842 "CollabPanel"
2843 }
2844}
2845
2846impl FocusableView for CollabPanel {
2847 fn focus_handle(&self, cx: &AppContext) -> gpui::FocusHandle {
2848 self.filter_editor.focus_handle(cx).clone()
2849 }
2850}
2851
2852impl PartialEq for ListEntry {
2853 fn eq(&self, other: &Self) -> bool {
2854 match self {
2855 ListEntry::Header(section_1) => {
2856 if let ListEntry::Header(section_2) = other {
2857 return section_1 == section_2;
2858 }
2859 }
2860 ListEntry::CallParticipant { user: user_1, .. } => {
2861 if let ListEntry::CallParticipant { user: user_2, .. } = other {
2862 return user_1.id == user_2.id;
2863 }
2864 }
2865 ListEntry::ParticipantProject {
2866 project_id: project_id_1,
2867 ..
2868 } => {
2869 if let ListEntry::ParticipantProject {
2870 project_id: project_id_2,
2871 ..
2872 } = other
2873 {
2874 return project_id_1 == project_id_2;
2875 }
2876 }
2877 ListEntry::ParticipantScreen {
2878 peer_id: peer_id_1, ..
2879 } => {
2880 if let ListEntry::ParticipantScreen {
2881 peer_id: peer_id_2, ..
2882 } = other
2883 {
2884 return peer_id_1 == peer_id_2;
2885 }
2886 }
2887 ListEntry::Channel {
2888 channel: channel_1, ..
2889 } => {
2890 if let ListEntry::Channel {
2891 channel: channel_2, ..
2892 } = other
2893 {
2894 return channel_1.id == channel_2.id;
2895 }
2896 }
2897 ListEntry::HostedProject { id, .. } => {
2898 if let ListEntry::HostedProject { id: other_id, .. } = other {
2899 return id == other_id;
2900 }
2901 }
2902 ListEntry::ChannelNotes { channel_id } => {
2903 if let ListEntry::ChannelNotes {
2904 channel_id: other_id,
2905 } = other
2906 {
2907 return channel_id == other_id;
2908 }
2909 }
2910 ListEntry::ChannelChat { channel_id } => {
2911 if let ListEntry::ChannelChat {
2912 channel_id: other_id,
2913 } = other
2914 {
2915 return channel_id == other_id;
2916 }
2917 }
2918 ListEntry::ChannelInvite(channel_1) => {
2919 if let ListEntry::ChannelInvite(channel_2) = other {
2920 return channel_1.id == channel_2.id;
2921 }
2922 }
2923 ListEntry::IncomingRequest(user_1) => {
2924 if let ListEntry::IncomingRequest(user_2) = other {
2925 return user_1.id == user_2.id;
2926 }
2927 }
2928 ListEntry::OutgoingRequest(user_1) => {
2929 if let ListEntry::OutgoingRequest(user_2) = other {
2930 return user_1.id == user_2.id;
2931 }
2932 }
2933 ListEntry::Contact {
2934 contact: contact_1, ..
2935 } => {
2936 if let ListEntry::Contact {
2937 contact: contact_2, ..
2938 } = other
2939 {
2940 return contact_1.user.id == contact_2.user.id;
2941 }
2942 }
2943 ListEntry::ChannelEditor { depth } => {
2944 if let ListEntry::ChannelEditor { depth: other_depth } = other {
2945 return depth == other_depth;
2946 }
2947 }
2948 ListEntry::ContactPlaceholder => {
2949 if let ListEntry::ContactPlaceholder = other {
2950 return true;
2951 }
2952 }
2953 }
2954 false
2955 }
2956}
2957
2958struct DraggedChannelView {
2959 channel: Channel,
2960 width: Pixels,
2961}
2962
2963impl Render for DraggedChannelView {
2964 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
2965 let ui_font = ThemeSettings::get_global(cx).ui_font.family.clone();
2966 h_flex()
2967 .font_family(ui_font)
2968 .bg(cx.theme().colors().background)
2969 .w(self.width)
2970 .p_1()
2971 .gap_1()
2972 .child(
2973 Icon::new(
2974 if self.channel.visibility == proto::ChannelVisibility::Public {
2975 IconName::Public
2976 } else {
2977 IconName::Hash
2978 },
2979 )
2980 .size(IconSize::Small)
2981 .color(Color::Muted),
2982 )
2983 .child(Label::new(self.channel.name.clone()))
2984 }
2985}
2986
2987struct JoinChannelTooltip {
2988 channel_store: Model<ChannelStore>,
2989 channel_id: ChannelId,
2990 #[allow(unused)]
2991 has_notes_notification: bool,
2992}
2993
2994impl Render for JoinChannelTooltip {
2995 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
2996 tooltip_container(cx, |container, cx| {
2997 let participants = self
2998 .channel_store
2999 .read(cx)
3000 .channel_participants(self.channel_id);
3001
3002 container
3003 .child(Label::new("Join channel"))
3004 .children(participants.iter().map(|participant| {
3005 h_flex()
3006 .gap_2()
3007 .child(Avatar::new(participant.avatar_uri.clone()))
3008 .child(Label::new(participant.github_login.clone()))
3009 }))
3010 })
3011 }
3012}