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