1use auto_update::{AutoUpdateStatus, AutoUpdater, DismissErrorMessage};
2use editor::Editor;
3use futures::StreamExt;
4use gpui::{
5 actions, svg, AppContext, CursorStyle, EventEmitter, InteractiveElement as _, Model,
6 ParentElement as _, Render, SharedString, StatefulInteractiveElement, Styled, View,
7 ViewContext, VisualContext as _,
8};
9use language::{LanguageRegistry, LanguageServerBinaryStatus, LanguageServerName};
10use project::{LanguageServerProgress, Project};
11use smallvec::SmallVec;
12use std::{cmp::Reverse, fmt::Write, sync::Arc};
13use ui::prelude::*;
14use util::ResultExt;
15use workspace::{item::ItemHandle, StatusItemView, Workspace};
16
17actions!(activity_indicator, [ShowErrorMessage]);
18
19const DOWNLOAD_ICON: &str = "icons/download.svg";
20const WARNING_ICON: &str = "icons/warning.svg";
21
22pub enum Event {
23 ShowError { lsp_name: Arc<str>, error: String },
24}
25
26pub struct ActivityIndicator {
27 statuses: Vec<LspStatus>,
28 project: Model<Project>,
29 auto_updater: Option<Model<AutoUpdater>>,
30}
31
32struct LspStatus {
33 name: LanguageServerName,
34 status: LanguageServerBinaryStatus,
35}
36
37struct PendingWork<'a> {
38 language_server_name: &'a str,
39 progress_token: &'a str,
40 progress: &'a LanguageServerProgress,
41}
42
43#[derive(Default)]
44struct Content {
45 icon: Option<&'static str>,
46 message: String,
47 on_click: Option<Arc<dyn Fn(&mut ActivityIndicator, &mut ViewContext<ActivityIndicator>)>>,
48}
49
50impl ActivityIndicator {
51 pub fn new(
52 workspace: &mut Workspace,
53 languages: Arc<LanguageRegistry>,
54 cx: &mut ViewContext<Workspace>,
55 ) -> View<ActivityIndicator> {
56 let project = workspace.project().clone();
57 let auto_updater = AutoUpdater::get(cx);
58 let this = cx.new_view(|cx: &mut ViewContext<Self>| {
59 let mut status_events = languages.language_server_binary_statuses();
60 cx.spawn(|this, mut cx| async move {
61 while let Some((name, status)) = status_events.next().await {
62 this.update(&mut cx, |this, cx| {
63 this.statuses.retain(|s| s.name != name);
64 this.statuses.push(LspStatus { name, status });
65 cx.notify();
66 })?;
67 }
68 anyhow::Ok(())
69 })
70 .detach();
71 cx.observe(&project, |_, _, cx| cx.notify()).detach();
72
73 if let Some(auto_updater) = auto_updater.as_ref() {
74 cx.observe(auto_updater, |_, _, cx| cx.notify()).detach();
75 }
76
77 Self {
78 statuses: Default::default(),
79 project: project.clone(),
80 auto_updater,
81 }
82 });
83
84 cx.subscribe(&this, move |workspace, _, event, cx| match event {
85 Event::ShowError { lsp_name, error } => {
86 if let Some(buffer) = project
87 .update(cx, |project, cx| project.create_buffer(error, None, cx))
88 .log_err()
89 {
90 buffer.update(cx, |buffer, cx| {
91 buffer.edit(
92 [(0..0, format!("Language server error: {}\n\n", lsp_name))],
93 None,
94 cx,
95 );
96 });
97 workspace.add_item_to_active_pane(
98 Box::new(
99 cx.new_view(|cx| Editor::for_buffer(buffer, Some(project.clone()), cx)),
100 ),
101 cx,
102 );
103 }
104 }
105 })
106 .detach();
107 this
108 }
109
110 fn show_error_message(&mut self, _: &ShowErrorMessage, cx: &mut ViewContext<Self>) {
111 self.statuses.retain(|status| {
112 if let LanguageServerBinaryStatus::Failed { error } = &status.status {
113 cx.emit(Event::ShowError {
114 lsp_name: status.name.0.clone(),
115 error: error.clone(),
116 });
117 false
118 } else {
119 true
120 }
121 });
122
123 cx.notify();
124 }
125
126 fn dismiss_error_message(&mut self, _: &DismissErrorMessage, cx: &mut ViewContext<Self>) {
127 if let Some(updater) = &self.auto_updater {
128 updater.update(cx, |updater, cx| {
129 updater.dismiss_error(cx);
130 });
131 }
132 cx.notify();
133 }
134
135 fn pending_language_server_work<'a>(
136 &self,
137 cx: &'a AppContext,
138 ) -> impl Iterator<Item = PendingWork<'a>> {
139 self.project
140 .read(cx)
141 .language_server_statuses()
142 .rev()
143 .filter_map(|status| {
144 if status.pending_work.is_empty() {
145 None
146 } else {
147 let mut pending_work = status
148 .pending_work
149 .iter()
150 .map(|(token, progress)| PendingWork {
151 language_server_name: status.name.as_str(),
152 progress_token: token.as_str(),
153 progress,
154 })
155 .collect::<SmallVec<[_; 4]>>();
156 pending_work.sort_by_key(|work| Reverse(work.progress.last_update_at));
157 Some(pending_work)
158 }
159 })
160 .flatten()
161 }
162
163 fn content_to_render(&mut self, cx: &mut ViewContext<Self>) -> Content {
164 // Show any language server has pending activity.
165 let mut pending_work = self.pending_language_server_work(cx);
166 if let Some(PendingWork {
167 language_server_name,
168 progress_token,
169 progress,
170 }) = pending_work.next()
171 {
172 let mut message = language_server_name.to_string();
173
174 message.push_str(": ");
175 if let Some(progress_message) = progress.message.as_ref() {
176 message.push_str(progress_message);
177 } else {
178 message.push_str(progress_token);
179 }
180
181 if let Some(percentage) = progress.percentage {
182 write!(&mut message, " ({}%)", percentage).unwrap();
183 }
184
185 let additional_work_count = pending_work.count();
186 if additional_work_count > 0 {
187 write!(&mut message, " + {} more", additional_work_count).unwrap();
188 }
189
190 return Content {
191 icon: None,
192 message,
193 on_click: None,
194 };
195 }
196
197 // Show any language server installation info.
198 let mut downloading = SmallVec::<[_; 3]>::new();
199 let mut checking_for_update = SmallVec::<[_; 3]>::new();
200 let mut failed = SmallVec::<[_; 3]>::new();
201 for status in &self.statuses {
202 match status.status {
203 LanguageServerBinaryStatus::CheckingForUpdate => {
204 checking_for_update.push(status.name.0.as_ref())
205 }
206 LanguageServerBinaryStatus::Downloading => downloading.push(status.name.0.as_ref()),
207 LanguageServerBinaryStatus::Failed { .. } => failed.push(status.name.0.as_ref()),
208 LanguageServerBinaryStatus::Downloaded | LanguageServerBinaryStatus::Cached => {}
209 }
210 }
211
212 if !downloading.is_empty() {
213 return Content {
214 icon: Some(DOWNLOAD_ICON),
215 message: format!("Downloading {}...", downloading.join(", "),),
216 on_click: None,
217 };
218 }
219
220 if !checking_for_update.is_empty() {
221 return Content {
222 icon: Some(DOWNLOAD_ICON),
223 message: format!(
224 "Checking for updates to {}...",
225 checking_for_update.join(", "),
226 ),
227 on_click: None,
228 };
229 }
230
231 if !failed.is_empty() {
232 return Content {
233 icon: Some(WARNING_ICON),
234 message: format!(
235 "Failed to download {}. Click to show error.",
236 failed.join(", "),
237 ),
238 on_click: Some(Arc::new(|this, cx| {
239 this.show_error_message(&Default::default(), cx)
240 })),
241 };
242 }
243
244 // Show any application auto-update info.
245 if let Some(updater) = &self.auto_updater {
246 return match &updater.read(cx).status() {
247 AutoUpdateStatus::Checking => Content {
248 icon: Some(DOWNLOAD_ICON),
249 message: "Checking for Zed updates…".to_string(),
250 on_click: None,
251 },
252 AutoUpdateStatus::Downloading => Content {
253 icon: Some(DOWNLOAD_ICON),
254 message: "Downloading Zed update…".to_string(),
255 on_click: None,
256 },
257 AutoUpdateStatus::Installing => Content {
258 icon: Some(DOWNLOAD_ICON),
259 message: "Installing Zed update…".to_string(),
260 on_click: None,
261 },
262 AutoUpdateStatus::Updated => Content {
263 icon: None,
264 message: "Click to restart and update Zed".to_string(),
265 on_click: Some(Arc::new(|_, cx| {
266 workspace::restart(&Default::default(), cx)
267 })),
268 },
269 AutoUpdateStatus::Errored => Content {
270 icon: Some(WARNING_ICON),
271 message: "Auto update failed".to_string(),
272 on_click: Some(Arc::new(|this, cx| {
273 this.dismiss_error_message(&Default::default(), cx)
274 })),
275 },
276 AutoUpdateStatus::Idle => Default::default(),
277 };
278 }
279
280 Default::default()
281 }
282}
283
284impl EventEmitter<Event> for ActivityIndicator {}
285
286impl Render for ActivityIndicator {
287 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
288 let content = self.content_to_render(cx);
289
290 let mut result = h_flex()
291 .id("activity-indicator")
292 .on_action(cx.listener(Self::show_error_message))
293 .on_action(cx.listener(Self::dismiss_error_message));
294
295 if let Some(on_click) = content.on_click {
296 result = result
297 .cursor(CursorStyle::PointingHand)
298 .on_click(cx.listener(move |this, _, cx| {
299 on_click(this, cx);
300 }))
301 }
302
303 result
304 .children(content.icon.map(|icon| svg().path(icon)))
305 .child(Label::new(SharedString::from(content.message)).size(LabelSize::Small))
306 }
307}
308
309impl StatusItemView for ActivityIndicator {
310 fn set_active_pane_item(&mut self, _: Option<&dyn ItemHandle>, _: &mut ViewContext<Self>) {}
311}