1use channel::{ChannelMembership, ChannelStore};
2use client::{
3 ChannelId, User, UserId, UserStore,
4 proto::{self, ChannelRole, ChannelVisibility},
5};
6use fuzzy::{StringMatchCandidate, match_strings};
7use gpui::{
8 App, ClipboardItem, Context, DismissEvent, Entity, EventEmitter, Focusable, ParentElement,
9 Render, Styled, Subscription, Task, WeakEntity, Window, actions, anchored, deferred, div,
10};
11use picker::{Picker, PickerDelegate};
12use std::sync::Arc;
13use ui::{Avatar, CheckboxWithLabel, ContextMenu, ListItem, ListItemSpacing, prelude::*};
14use util::TryFutureExt;
15use workspace::{ModalView, notifications::DetachAndPromptErr};
16
17actions!(
18 channel_modal,
19 [
20 SelectNextControl,
21 ToggleMode,
22 ToggleMemberAdmin,
23 RemoveMember
24 ]
25);
26
27pub struct ChannelModal {
28 picker: Entity<Picker<ChannelModalDelegate>>,
29 channel_store: Entity<ChannelStore>,
30 channel_id: ChannelId,
31}
32
33impl ChannelModal {
34 pub fn new(
35 user_store: Entity<UserStore>,
36 channel_store: Entity<ChannelStore>,
37 channel_id: ChannelId,
38 mode: Mode,
39 window: &mut Window,
40 cx: &mut Context<Self>,
41 ) -> Self {
42 cx.observe(&channel_store, |_, _, cx| cx.notify()).detach();
43 let channel_modal = cx.entity().downgrade();
44 let picker = cx.new(|cx| {
45 Picker::uniform_list(
46 ChannelModalDelegate {
47 channel_modal,
48 matching_users: Vec::new(),
49 matching_member_indices: Vec::new(),
50 selected_index: 0,
51 user_store: user_store.clone(),
52 channel_store: channel_store.clone(),
53 channel_id,
54 match_candidates: Vec::new(),
55 context_menu: None,
56 members: Vec::new(),
57 has_all_members: false,
58 mode,
59 },
60 window,
61 cx,
62 )
63 .modal(false)
64 });
65
66 Self {
67 picker,
68 channel_store,
69 channel_id,
70 }
71 }
72
73 fn toggle_mode(&mut self, _: &ToggleMode, window: &mut Window, cx: &mut Context<Self>) {
74 let mode = match self.picker.read(cx).delegate.mode {
75 Mode::ManageMembers => Mode::InviteMembers,
76 Mode::InviteMembers => Mode::ManageMembers,
77 };
78 self.set_mode(mode, window, cx);
79 }
80
81 fn set_mode(&mut self, mode: Mode, window: &mut Window, cx: &mut Context<Self>) {
82 self.picker.update(cx, |picker, cx| {
83 let delegate = &mut picker.delegate;
84 delegate.mode = mode;
85 delegate.selected_index = 0;
86 picker.set_query("", window, cx);
87 picker.update_matches(picker.query(cx), window, cx);
88 cx.notify()
89 });
90 cx.notify()
91 }
92
93 fn set_channel_visibility(
94 &mut self,
95 selection: &ToggleState,
96 _: &mut Window,
97 cx: &mut Context<Self>,
98 ) {
99 self.channel_store.update(cx, |channel_store, cx| {
100 channel_store
101 .set_channel_visibility(
102 self.channel_id,
103 match selection {
104 ToggleState::Unselected => ChannelVisibility::Members,
105 ToggleState::Selected => ChannelVisibility::Public,
106 ToggleState::Indeterminate => return,
107 },
108 cx,
109 )
110 .detach_and_log_err(cx)
111 });
112 }
113
114 fn dismiss(&mut self, _: &menu::Cancel, _: &mut Window, cx: &mut Context<Self>) {
115 cx.emit(DismissEvent);
116 }
117}
118
119impl EventEmitter<DismissEvent> for ChannelModal {}
120impl ModalView for ChannelModal {}
121
122impl Focusable for ChannelModal {
123 fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
124 self.picker.focus_handle(cx)
125 }
126}
127
128impl Render for ChannelModal {
129 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
130 let channel_store = self.channel_store.read(cx);
131 let Some(channel) = channel_store.channel_for_id(self.channel_id) else {
132 return div();
133 };
134 let channel_name = channel.name.clone();
135 let channel_id = channel.id;
136 let visibility = channel.visibility;
137 let mode = self.picker.read(cx).delegate.mode;
138
139 v_flex()
140 .key_context("ChannelModal")
141 .on_action(cx.listener(Self::toggle_mode))
142 .on_action(cx.listener(Self::dismiss))
143 .elevation_3(cx)
144 .w(rems(34.))
145 .child(
146 v_flex()
147 .px_2()
148 .py_1()
149 .gap_2()
150 .child(
151 h_flex()
152 .w_px()
153 .flex_1()
154 .gap_1()
155 .child(Icon::new(IconName::Hash).size(IconSize::Medium))
156 .child(Label::new(channel_name)),
157 )
158 .child(
159 h_flex()
160 .w_full()
161 .h(rems_from_px(22.))
162 .justify_between()
163 .line_height(rems(1.25))
164 .child(CheckboxWithLabel::new(
165 "is-public",
166 Label::new("Public").size(LabelSize::Small),
167 if visibility == ChannelVisibility::Public {
168 ui::ToggleState::Selected
169 } else {
170 ui::ToggleState::Unselected
171 },
172 cx.listener(Self::set_channel_visibility),
173 ))
174 .children(
175 Some(
176 Button::new("copy-link", "Copy Link")
177 .label_size(LabelSize::Small)
178 .on_click(cx.listener(move |this, _, _, cx| {
179 if let Some(channel) = this
180 .channel_store
181 .read(cx)
182 .channel_for_id(channel_id)
183 {
184 let item =
185 ClipboardItem::new_string(channel.link(cx));
186 cx.write_to_clipboard(item);
187 }
188 })),
189 )
190 .filter(|_| visibility == ChannelVisibility::Public),
191 ),
192 )
193 .child(
194 h_flex()
195 .child(
196 div()
197 .id("manage-members")
198 .px_2()
199 .py_1()
200 .cursor_pointer()
201 .border_b_2()
202 .when(mode == Mode::ManageMembers, |this| {
203 this.border_color(cx.theme().colors().border)
204 })
205 .child(Label::new("Manage Members"))
206 .on_click(cx.listener(|this, _, window, cx| {
207 this.set_mode(Mode::ManageMembers, window, cx);
208 })),
209 )
210 .child(
211 div()
212 .id("invite-members")
213 .px_2()
214 .py_1()
215 .cursor_pointer()
216 .border_b_2()
217 .when(mode == Mode::InviteMembers, |this| {
218 this.border_color(cx.theme().colors().border)
219 })
220 .child(Label::new("Invite Members"))
221 .on_click(cx.listener(|this, _, window, cx| {
222 this.set_mode(Mode::InviteMembers, window, cx);
223 })),
224 ),
225 ),
226 )
227 .child(self.picker.clone())
228 }
229}
230
231#[derive(Copy, Clone, PartialEq)]
232pub enum Mode {
233 ManageMembers,
234 InviteMembers,
235}
236
237pub struct ChannelModalDelegate {
238 channel_modal: WeakEntity<ChannelModal>,
239 matching_users: Vec<Arc<User>>,
240 matching_member_indices: Vec<usize>,
241 user_store: Entity<UserStore>,
242 channel_store: Entity<ChannelStore>,
243 channel_id: ChannelId,
244 selected_index: usize,
245 mode: Mode,
246 match_candidates: Vec<StringMatchCandidate>,
247 members: Vec<ChannelMembership>,
248 has_all_members: bool,
249 context_menu: Option<(Entity<ContextMenu>, Subscription)>,
250}
251
252impl PickerDelegate for ChannelModalDelegate {
253 type ListItem = ListItem;
254
255 fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
256 "Search collaborator by username...".into()
257 }
258
259 fn match_count(&self) -> usize {
260 match self.mode {
261 Mode::ManageMembers => self.matching_member_indices.len(),
262 Mode::InviteMembers => self.matching_users.len(),
263 }
264 }
265
266 fn selected_index(&self) -> usize {
267 self.selected_index
268 }
269
270 fn set_selected_index(
271 &mut self,
272 ix: usize,
273 _window: &mut Window,
274 _: &mut Context<Picker<Self>>,
275 ) {
276 self.selected_index = ix;
277 }
278
279 fn update_matches(
280 &mut self,
281 query: String,
282 window: &mut Window,
283 cx: &mut Context<Picker<Self>>,
284 ) -> Task<()> {
285 match self.mode {
286 Mode::ManageMembers => {
287 if self.has_all_members {
288 self.match_candidates.clear();
289 self.match_candidates
290 .extend(self.members.iter().enumerate().map(|(id, member)| {
291 StringMatchCandidate::new(id, &member.user.github_login)
292 }));
293
294 let matches = cx.background_executor().block(match_strings(
295 &self.match_candidates,
296 &query,
297 true,
298 usize::MAX,
299 &Default::default(),
300 cx.background_executor().clone(),
301 ));
302
303 cx.spawn_in(window, async move |picker, cx| {
304 picker
305 .update(cx, |picker, cx| {
306 let delegate = &mut picker.delegate;
307 delegate.matching_member_indices.clear();
308 delegate
309 .matching_member_indices
310 .extend(matches.into_iter().map(|m| m.candidate_id));
311 cx.notify();
312 })
313 .ok();
314 })
315 } else {
316 let search_members = self.channel_store.update(cx, |store, cx| {
317 store.fuzzy_search_members(self.channel_id, query.clone(), 100, cx)
318 });
319 cx.spawn_in(window, async move |picker, cx| {
320 async {
321 let members = search_members.await?;
322 picker.update(cx, |picker, cx| {
323 picker.delegate.has_all_members =
324 query.is_empty() && members.len() < 100;
325 picker.delegate.matching_member_indices =
326 (0..members.len()).collect();
327 picker.delegate.members = members;
328 cx.notify();
329 })?;
330 anyhow::Ok(())
331 }
332 .log_err()
333 .await;
334 })
335 }
336 }
337 Mode::InviteMembers => {
338 let search_users = self
339 .user_store
340 .update(cx, |store, cx| store.fuzzy_search_users(query, cx));
341 cx.spawn_in(window, async move |picker, cx| {
342 async {
343 let users = search_users.await?;
344 picker.update(cx, |picker, cx| {
345 picker.delegate.matching_users = users;
346 cx.notify();
347 })?;
348 anyhow::Ok(())
349 }
350 .log_err()
351 .await;
352 })
353 }
354 }
355 }
356
357 fn confirm(&mut self, _: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
358 if let Some(selected_user) = self.user_at_index(self.selected_index) {
359 if Some(selected_user.id) == self.user_store.read(cx).current_user().map(|user| user.id)
360 {
361 return;
362 }
363 match self.mode {
364 Mode::ManageMembers => self.show_context_menu(self.selected_index, window, cx),
365 Mode::InviteMembers => match self.member_status(selected_user.id, cx) {
366 Some(proto::channel_member::Kind::Invitee) => {
367 self.remove_member(selected_user.id, window, cx);
368 }
369 Some(proto::channel_member::Kind::Member) => {}
370 None => self.invite_member(selected_user, window, cx),
371 },
372 }
373 }
374 }
375
376 fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
377 if self.context_menu.is_none() {
378 self.channel_modal
379 .update(cx, |_, cx| {
380 cx.emit(DismissEvent);
381 })
382 .ok();
383 }
384 }
385
386 fn render_match(
387 &self,
388 ix: usize,
389 selected: bool,
390 _: &mut Window,
391 cx: &mut Context<Picker<Self>>,
392 ) -> Option<Self::ListItem> {
393 let user = self.user_at_index(ix)?;
394 let membership = self.member_at_index(ix);
395 let request_status = self.member_status(user.id, cx);
396 let is_me = self.user_store.read(cx).current_user().map(|user| user.id) == Some(user.id);
397
398 Some(
399 ListItem::new(ix)
400 .inset(true)
401 .spacing(ListItemSpacing::Sparse)
402 .toggle_state(selected)
403 .start_slot(Avatar::new(user.avatar_uri.clone()))
404 .child(Label::new(user.github_login.clone()))
405 .end_slot(h_flex().gap_2().map(|slot| {
406 match self.mode {
407 Mode::ManageMembers => slot
408 .children(
409 if request_status == Some(proto::channel_member::Kind::Invitee) {
410 Some(Label::new("Invited"))
411 } else {
412 None
413 },
414 )
415 .children(match membership.map(|m| m.role) {
416 Some(ChannelRole::Admin) => Some(Label::new("Admin")),
417 Some(ChannelRole::Guest) => Some(Label::new("Guest")),
418 _ => None,
419 })
420 .when(!is_me, |el| {
421 el.child(IconButton::new("ellipsis", IconName::Ellipsis))
422 })
423 .when(is_me, |el| el.child(Label::new("You").color(Color::Muted)))
424 .children(
425 if let (Some((menu, _)), true) = (&self.context_menu, selected) {
426 Some(
427 deferred(
428 anchored()
429 .anchor(gpui::Corner::TopRight)
430 .child(menu.clone()),
431 )
432 .with_priority(1),
433 )
434 } else {
435 None
436 },
437 ),
438 Mode::InviteMembers => match request_status {
439 Some(proto::channel_member::Kind::Invitee) => {
440 slot.children(Some(Label::new("Invited")))
441 }
442 Some(proto::channel_member::Kind::Member) => {
443 slot.children(Some(Label::new("Member")))
444 }
445 _ => slot,
446 },
447 }
448 })),
449 )
450 }
451}
452
453impl ChannelModalDelegate {
454 fn member_status(&self, user_id: UserId, cx: &App) -> Option<proto::channel_member::Kind> {
455 self.members
456 .iter()
457 .find_map(|membership| (membership.user.id == user_id).then_some(membership.kind))
458 .or_else(|| {
459 self.channel_store
460 .read(cx)
461 .has_pending_channel_invite(self.channel_id, user_id)
462 .then_some(proto::channel_member::Kind::Invitee)
463 })
464 }
465
466 fn member_at_index(&self, ix: usize) -> Option<&ChannelMembership> {
467 self.matching_member_indices
468 .get(ix)
469 .and_then(|ix| self.members.get(*ix))
470 }
471
472 fn user_at_index(&self, ix: usize) -> Option<Arc<User>> {
473 match self.mode {
474 Mode::ManageMembers => self.matching_member_indices.get(ix).and_then(|ix| {
475 let channel_membership = self.members.get(*ix)?;
476 Some(channel_membership.user.clone())
477 }),
478 Mode::InviteMembers => self.matching_users.get(ix).cloned(),
479 }
480 }
481
482 fn set_user_role(
483 &mut self,
484 user_id: UserId,
485 new_role: ChannelRole,
486 window: &mut Window,
487 cx: &mut Context<Picker<Self>>,
488 ) -> Option<()> {
489 let update = self.channel_store.update(cx, |store, cx| {
490 store.set_member_role(self.channel_id, user_id, new_role, cx)
491 });
492 cx.spawn_in(window, async move |picker, cx| {
493 update.await?;
494 picker.update_in(cx, |picker, window, cx| {
495 let this = &mut picker.delegate;
496 if let Some(member) = this.members.iter_mut().find(|m| m.user.id == user_id) {
497 member.role = new_role;
498 }
499 cx.focus_self(window);
500 cx.notify();
501 })
502 })
503 .detach_and_prompt_err("Failed to update role", window, cx, |_, _, _| None);
504 Some(())
505 }
506
507 fn remove_member(
508 &mut self,
509 user_id: UserId,
510 window: &mut Window,
511 cx: &mut Context<Picker<Self>>,
512 ) -> Option<()> {
513 let update = self.channel_store.update(cx, |store, cx| {
514 store.remove_member(self.channel_id, user_id, cx)
515 });
516 cx.spawn_in(window, async move |picker, cx| {
517 update.await?;
518 picker.update_in(cx, |picker, window, cx| {
519 let this = &mut picker.delegate;
520 if let Some(ix) = this.members.iter_mut().position(|m| m.user.id == user_id) {
521 this.members.remove(ix);
522 this.matching_member_indices.retain_mut(|member_ix| {
523 if *member_ix == ix {
524 return false;
525 } else if *member_ix > ix {
526 *member_ix -= 1;
527 }
528 true
529 })
530 }
531
532 this.selected_index = this
533 .selected_index
534 .min(this.matching_member_indices.len().saturating_sub(1));
535
536 picker.focus(window, cx);
537 cx.notify();
538 })
539 })
540 .detach_and_prompt_err("Failed to remove member", window, cx, |_, _, _| None);
541 Some(())
542 }
543
544 fn invite_member(
545 &mut self,
546 user: Arc<User>,
547 window: &mut Window,
548 cx: &mut Context<Picker<Self>>,
549 ) {
550 let invite_member = self.channel_store.update(cx, |store, cx| {
551 store.invite_member(self.channel_id, user.id, ChannelRole::Member, cx)
552 });
553
554 cx.spawn_in(window, async move |this, cx| {
555 invite_member.await?;
556
557 this.update(cx, |this, cx| {
558 let new_member = ChannelMembership {
559 user,
560 kind: proto::channel_member::Kind::Invitee,
561 role: ChannelRole::Member,
562 };
563 let members = &mut this.delegate.members;
564 match members.binary_search_by_key(&new_member.sort_key(), |k| k.sort_key()) {
565 Ok(ix) | Err(ix) => members.insert(ix, new_member),
566 }
567
568 cx.notify();
569 })
570 })
571 .detach_and_prompt_err("Failed to invite member", window, cx, |_, _, _| None);
572 }
573
574 fn show_context_menu(
575 &mut self,
576 ix: usize,
577 window: &mut Window,
578 cx: &mut Context<Picker<Self>>,
579 ) {
580 let Some(membership) = self.member_at_index(ix) else {
581 return;
582 };
583 let user_id = membership.user.id;
584 let picker = cx.entity().clone();
585 let context_menu = ContextMenu::build(window, cx, |mut menu, _window, _cx| {
586 let role = membership.role;
587
588 if role == ChannelRole::Admin || role == ChannelRole::Member {
589 let picker = picker.clone();
590 menu = menu.entry("Demote to Guest", None, move |window, cx| {
591 picker.update(cx, |picker, cx| {
592 picker
593 .delegate
594 .set_user_role(user_id, ChannelRole::Guest, window, cx);
595 })
596 });
597 }
598
599 if role == ChannelRole::Admin || role == ChannelRole::Guest {
600 let picker = picker.clone();
601 let label = if role == ChannelRole::Guest {
602 "Promote to Member"
603 } else {
604 "Demote to Member"
605 };
606
607 menu = menu.entry(label, None, move |window, cx| {
608 picker.update(cx, |picker, cx| {
609 picker
610 .delegate
611 .set_user_role(user_id, ChannelRole::Member, window, cx);
612 })
613 });
614 }
615
616 if role == ChannelRole::Member || role == ChannelRole::Guest {
617 let picker = picker.clone();
618 menu = menu.entry("Promote to Admin", None, move |window, cx| {
619 picker.update(cx, |picker, cx| {
620 picker
621 .delegate
622 .set_user_role(user_id, ChannelRole::Admin, window, cx);
623 })
624 });
625 };
626
627 menu = menu.separator();
628 menu = menu.entry("Remove from Channel", None, {
629 let picker = picker.clone();
630 move |window, cx| {
631 picker.update(cx, |picker, cx| {
632 picker.delegate.remove_member(user_id, window, cx);
633 })
634 }
635 });
636 menu
637 });
638 window.focus(&context_menu.focus_handle(cx));
639 let subscription = cx.subscribe_in(
640 &context_menu,
641 window,
642 |picker, _, _: &DismissEvent, window, cx| {
643 picker.delegate.context_menu = None;
644 picker.focus(window, cx);
645 cx.notify();
646 },
647 );
648 self.context_menu = Some((context_menu, subscription));
649 }
650}