1use gpui::{
2 AnyElement, App, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription,
3 Task, WeakEntity,
4};
5use picker::{Picker, PickerDelegate};
6use project::{
7 git::{GitStore, Repository},
8 Project,
9};
10use std::sync::Arc;
11use ui::{prelude::*, ListItem, ListItemSpacing};
12
13pub struct RepositorySelector {
14 picker: Entity<Picker<RepositorySelectorDelegate>>,
15 /// The task used to update the picker's matches when there is a change to
16 /// the repository list.
17 update_matches_task: Option<Task<()>>,
18 _subscriptions: Vec<Subscription>,
19}
20
21impl RepositorySelector {
22 pub fn new(project: Entity<Project>, window: &mut Window, cx: &mut Context<Self>) -> Self {
23 let git_store = project.read(cx).git_store().clone();
24 let all_repositories = git_store.read(cx).all_repositories();
25 let filtered_repositories = all_repositories.clone();
26 let delegate = RepositorySelectorDelegate {
27 project: project.downgrade(),
28 repository_selector: cx.entity().downgrade(),
29 repository_entries: all_repositories,
30 filtered_repositories,
31 selected_index: 0,
32 };
33
34 let picker = cx.new(|cx| {
35 Picker::nonsearchable_uniform_list(delegate, window, cx)
36 .max_height(Some(rems(20.).into()))
37 .width(rems(15.))
38 });
39
40 let _subscriptions =
41 vec![cx.subscribe_in(&git_store, window, Self::handle_project_git_event)];
42
43 RepositorySelector {
44 picker,
45 update_matches_task: None,
46 _subscriptions,
47 }
48 }
49
50 fn handle_project_git_event(
51 &mut self,
52 git_store: &Entity<GitStore>,
53 _event: &project::git::GitEvent,
54 window: &mut Window,
55 cx: &mut Context<Self>,
56 ) {
57 // TODO handle events individually
58 let task = self.picker.update(cx, |this, cx| {
59 let query = this.query(cx);
60 this.delegate.repository_entries = git_store.read(cx).all_repositories();
61 this.delegate.update_matches(query, window, cx)
62 });
63 self.update_matches_task = Some(task);
64 }
65}
66
67impl EventEmitter<DismissEvent> for RepositorySelector {}
68
69impl Focusable for RepositorySelector {
70 fn focus_handle(&self, cx: &App) -> FocusHandle {
71 self.picker.focus_handle(cx)
72 }
73}
74
75impl Render for RepositorySelector {
76 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
77 self.picker.clone()
78 }
79}
80
81pub struct RepositorySelectorDelegate {
82 project: WeakEntity<Project>,
83 repository_selector: WeakEntity<RepositorySelector>,
84 repository_entries: Vec<Entity<Repository>>,
85 filtered_repositories: Vec<Entity<Repository>>,
86 selected_index: usize,
87}
88
89impl RepositorySelectorDelegate {
90 pub fn update_repository_entries(&mut self, all_repositories: Vec<Entity<Repository>>) {
91 self.repository_entries = all_repositories.clone();
92 self.filtered_repositories = all_repositories;
93 self.selected_index = 0;
94 }
95}
96
97impl PickerDelegate for RepositorySelectorDelegate {
98 type ListItem = ListItem;
99
100 fn match_count(&self) -> usize {
101 self.filtered_repositories.len()
102 }
103
104 fn selected_index(&self) -> usize {
105 self.selected_index
106 }
107
108 fn set_selected_index(
109 &mut self,
110 ix: usize,
111 _window: &mut Window,
112 cx: &mut Context<Picker<Self>>,
113 ) {
114 self.selected_index = ix.min(self.filtered_repositories.len().saturating_sub(1));
115 cx.notify();
116 }
117
118 fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
119 "Select a repository...".into()
120 }
121
122 fn update_matches(
123 &mut self,
124 query: String,
125 window: &mut Window,
126 cx: &mut Context<Picker<Self>>,
127 ) -> Task<()> {
128 let all_repositories = self.repository_entries.clone();
129
130 cx.spawn_in(window, |this, mut cx| async move {
131 let filtered_repositories = cx
132 .background_spawn(async move {
133 if query.is_empty() {
134 all_repositories
135 } else {
136 all_repositories
137 .into_iter()
138 .filter(|_repo_info| {
139 // TODO: Implement repository filtering logic
140 true
141 })
142 .collect()
143 }
144 })
145 .await;
146
147 this.update_in(&mut cx, |this, window, cx| {
148 this.delegate.filtered_repositories = filtered_repositories;
149 this.delegate.set_selected_index(0, window, cx);
150 cx.notify();
151 })
152 .ok();
153 })
154 }
155
156 fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
157 let Some(selected_repo) = self.filtered_repositories.get(self.selected_index) else {
158 return;
159 };
160 selected_repo.update(cx, |selected_repo, cx| selected_repo.activate(cx));
161 self.dismissed(window, cx);
162 }
163
164 fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
165 self.repository_selector
166 .update(cx, |_this, cx| cx.emit(DismissEvent))
167 .ok();
168 }
169
170 fn render_header(
171 &self,
172 _window: &mut Window,
173 _cx: &mut Context<Picker<Self>>,
174 ) -> Option<AnyElement> {
175 // TODO: Implement header rendering if needed
176 None
177 }
178
179 fn render_match(
180 &self,
181 ix: usize,
182 selected: bool,
183 _window: &mut Window,
184 cx: &mut Context<Picker<Self>>,
185 ) -> Option<Self::ListItem> {
186 let project = self.project.upgrade()?;
187 let repo_info = self.filtered_repositories.get(ix)?;
188 let display_name = repo_info.read(cx).display_name(project.read(cx), cx);
189 // TODO: Implement repository item rendering
190 Some(
191 ListItem::new(ix)
192 .inset(true)
193 .spacing(ListItemSpacing::Sparse)
194 .toggle_state(selected)
195 .child(Label::new(display_name)),
196 )
197 }
198}