1use collections::HashMap;
2use editor::Editor;
3use futures::{channel::mpsc, StreamExt};
4use gpui::{
5 actions,
6 elements::{
7 AnchorCorner, ChildView, Empty, Flex, Label, MouseEventHandler, Overlay, OverlayFitMode,
8 ParentElement, Stack,
9 },
10 platform::{CursorStyle, MouseButton},
11 AnyElement, AppContext, Element, Entity, ModelContext, ModelHandle, View, ViewContext,
12 ViewHandle, WeakModelHandle,
13};
14use language::{Buffer, LanguageServerId, LanguageServerName};
15use lsp::IoKind;
16use project::{search::SearchQuery, Project};
17use std::{borrow::Cow, sync::Arc};
18use theme::{ui, Theme};
19use workspace::{
20 item::{Item, ItemHandle},
21 searchable::{SearchableItem, SearchableItemHandle},
22 ToolbarItemLocation, ToolbarItemView, Workspace, WorkspaceCreated,
23};
24
25const SEND_LINE: &str = "// Send:\n";
26const RECEIVE_LINE: &str = "// Receive:\n";
27
28pub struct LogStore {
29 projects: HashMap<WeakModelHandle<Project>, ProjectState>,
30 io_tx: mpsc::UnboundedSender<(WeakModelHandle<Project>, LanguageServerId, IoKind, String)>,
31}
32
33struct ProjectState {
34 servers: HashMap<LanguageServerId, LanguageServerState>,
35 _subscriptions: [gpui::Subscription; 2],
36}
37
38struct LanguageServerState {
39 log_buffer: ModelHandle<Buffer>,
40 rpc_state: Option<LanguageServerRpcState>,
41 _io_logs_subscription: Option<lsp::Subscription>,
42 _lsp_logs_subscription: Option<lsp::Subscription>,
43}
44
45struct LanguageServerRpcState {
46 buffer: ModelHandle<Buffer>,
47 last_message_kind: Option<MessageKind>,
48}
49
50pub struct LspLogView {
51 pub(crate) editor: ViewHandle<Editor>,
52 log_store: ModelHandle<LogStore>,
53 current_server_id: Option<LanguageServerId>,
54 is_showing_rpc_trace: bool,
55 project: ModelHandle<Project>,
56}
57
58pub struct LspLogToolbarItemView {
59 log_view: Option<ViewHandle<LspLogView>>,
60 menu_open: bool,
61}
62
63#[derive(Copy, Clone, PartialEq, Eq)]
64enum MessageKind {
65 Send,
66 Receive,
67}
68
69#[derive(Clone, Debug, PartialEq)]
70pub(crate) struct LogMenuItem {
71 pub server_id: LanguageServerId,
72 pub server_name: LanguageServerName,
73 pub worktree_root_name: String,
74 pub rpc_trace_enabled: bool,
75 pub rpc_trace_selected: bool,
76 pub logs_selected: bool,
77}
78
79actions!(debug, [OpenLanguageServerLogs]);
80
81pub fn init(cx: &mut AppContext) {
82 let log_store = cx.add_model(|cx| LogStore::new(cx));
83
84 cx.subscribe_global::<WorkspaceCreated, _>({
85 let log_store = log_store.clone();
86 move |event, cx| {
87 let workspace = &event.0;
88 if let Some(workspace) = workspace.upgrade(cx) {
89 let project = workspace.read(cx).project().clone();
90 if project.read(cx).is_local() {
91 log_store.update(cx, |store, cx| {
92 store.add_project(&project, cx);
93 });
94 }
95 }
96 }
97 })
98 .detach();
99
100 cx.add_action(
101 move |workspace: &mut Workspace, _: &OpenLanguageServerLogs, cx: _| {
102 let project = workspace.project().read(cx);
103 if project.is_local() {
104 workspace.add_item(
105 Box::new(cx.add_view(|cx| {
106 LspLogView::new(workspace.project().clone(), log_store.clone(), cx)
107 })),
108 cx,
109 );
110 }
111 },
112 );
113}
114
115impl LogStore {
116 pub fn new(cx: &mut ModelContext<Self>) -> Self {
117 let (io_tx, mut io_rx) = mpsc::unbounded();
118 let this = Self {
119 projects: HashMap::default(),
120 io_tx,
121 };
122 cx.spawn_weak(|this, mut cx| async move {
123 while let Some((project, server_id, io_kind, mut message)) = io_rx.next().await {
124 if let Some(this) = this.upgrade(&cx) {
125 this.update(&mut cx, |this, cx| {
126 message.push('\n');
127 this.on_io(project, server_id, io_kind, &message, cx);
128 });
129 }
130 }
131 anyhow::Ok(())
132 })
133 .detach();
134 this
135 }
136
137 pub fn add_project(&mut self, project: &ModelHandle<Project>, cx: &mut ModelContext<Self>) {
138 let weak_project = project.downgrade();
139 self.projects.insert(
140 weak_project,
141 ProjectState {
142 servers: HashMap::default(),
143 _subscriptions: [
144 cx.observe_release(&project, move |this, _, _| {
145 this.projects.remove(&weak_project);
146 }),
147 cx.subscribe(project, |this, project, event, cx| match event {
148 project::Event::LanguageServerAdded(id) => {
149 this.add_language_server(&project, *id, cx);
150 }
151 project::Event::LanguageServerRemoved(id) => {
152 this.remove_language_server(&project, *id, cx);
153 }
154 project::Event::LanguageServerLog(id, message) => {
155 this.add_language_server_log(&project, *id, message, cx);
156 }
157 _ => {}
158 }),
159 ],
160 },
161 );
162 }
163
164 fn add_language_server(
165 &mut self,
166 project: &ModelHandle<Project>,
167 id: LanguageServerId,
168 cx: &mut ModelContext<Self>,
169 ) -> Option<ModelHandle<Buffer>> {
170 let project_state = self.projects.get_mut(&project.downgrade())?;
171 let server_state = project_state.servers.entry(id).or_insert_with(|| {
172 cx.notify();
173 LanguageServerState {
174 rpc_state: None,
175 log_buffer: cx
176 .add_model(|cx| Buffer::new(0, cx.model_id() as u64, ""))
177 .clone(),
178 _io_logs_subscription: None,
179 _lsp_logs_subscription: None,
180 }
181 });
182
183 let server = project.read(cx).language_server_for_id(id);
184 let weak_project = project.downgrade();
185 let io_tx = self.io_tx.clone();
186 server_state._io_logs_subscription = server.as_ref().map(|server| {
187 server.on_io(move |io_kind, message| {
188 io_tx
189 .unbounded_send((weak_project, id, io_kind, message.to_string()))
190 .ok();
191 })
192 });
193 let weak_project = project.downgrade();
194 server_state._lsp_logs_subscription = server.map(|server| {
195 let server_id = server.server_id();
196 server.on_notification::<lsp::notification::LogMessage, _>({
197 move |params, mut cx| {
198 if let Some(project) = weak_project.upgrade(&cx) {
199 project.update(&mut cx, |_, cx| {
200 cx.emit(project::Event::LanguageServerLog(server_id, params.message))
201 });
202 }
203 }
204 })
205 });
206 Some(server_state.log_buffer.clone())
207 }
208
209 fn add_language_server_log(
210 &mut self,
211 project: &ModelHandle<Project>,
212 id: LanguageServerId,
213 message: &str,
214 cx: &mut ModelContext<Self>,
215 ) -> Option<()> {
216 let buffer = match self
217 .projects
218 .get_mut(&project.downgrade())?
219 .servers
220 .get(&id)
221 .map(|state| state.log_buffer.clone())
222 {
223 Some(existing_buffer) => existing_buffer,
224 None => self.add_language_server(&project, id, cx)?,
225 };
226 buffer.update(cx, |buffer, cx| {
227 let len = buffer.len();
228 let has_newline = message.ends_with("\n");
229 buffer.edit([(len..len, message)], None, cx);
230 if !has_newline {
231 let len = buffer.len();
232 buffer.edit([(len..len, "\n")], None, cx);
233 }
234 });
235 cx.notify();
236 Some(())
237 }
238
239 fn remove_language_server(
240 &mut self,
241 project: &ModelHandle<Project>,
242 id: LanguageServerId,
243 cx: &mut ModelContext<Self>,
244 ) -> Option<()> {
245 let project_state = self.projects.get_mut(&project.downgrade())?;
246 project_state.servers.remove(&id);
247 cx.notify();
248 Some(())
249 }
250
251 pub fn log_buffer_for_server(
252 &self,
253 project: &ModelHandle<Project>,
254 server_id: LanguageServerId,
255 ) -> Option<ModelHandle<Buffer>> {
256 let weak_project = project.downgrade();
257 let project_state = self.projects.get(&weak_project)?;
258 let server_state = project_state.servers.get(&server_id)?;
259 Some(server_state.log_buffer.clone())
260 }
261
262 fn enable_rpc_trace_for_language_server(
263 &mut self,
264 project: &ModelHandle<Project>,
265 server_id: LanguageServerId,
266 cx: &mut ModelContext<Self>,
267 ) -> Option<ModelHandle<Buffer>> {
268 let weak_project = project.downgrade();
269 let project_state = self.projects.get_mut(&weak_project)?;
270 let server_state = project_state.servers.get_mut(&server_id)?;
271 let rpc_state = server_state.rpc_state.get_or_insert_with(|| {
272 let language = project.read(cx).languages().language_for_name("JSON");
273 let buffer = cx.add_model(|cx| Buffer::new(0, cx.model_id() as u64, ""));
274 cx.spawn_weak({
275 let buffer = buffer.clone();
276 |_, mut cx| async move {
277 let language = language.await.ok();
278 buffer.update(&mut cx, |buffer, cx| {
279 buffer.set_language(language, cx);
280 });
281 }
282 })
283 .detach();
284
285 LanguageServerRpcState {
286 buffer,
287 last_message_kind: None,
288 }
289 });
290 Some(rpc_state.buffer.clone())
291 }
292
293 pub fn disable_rpc_trace_for_language_server(
294 &mut self,
295 project: &ModelHandle<Project>,
296 server_id: LanguageServerId,
297 _: &mut ModelContext<Self>,
298 ) -> Option<()> {
299 let project = project.downgrade();
300 let project_state = self.projects.get_mut(&project)?;
301 let server_state = project_state.servers.get_mut(&server_id)?;
302 server_state.rpc_state.take();
303 Some(())
304 }
305
306 fn on_io(
307 &mut self,
308 project: WeakModelHandle<Project>,
309 language_server_id: LanguageServerId,
310 io_kind: IoKind,
311 message: &str,
312 cx: &mut AppContext,
313 ) -> Option<()> {
314 let is_received = match io_kind {
315 IoKind::StdOut => true,
316 IoKind::StdIn => false,
317 IoKind::StdErr => {
318 let project = project.upgrade(cx)?;
319 project.update(cx, |_, cx| {
320 cx.emit(project::Event::LanguageServerLog(
321 language_server_id,
322 format!("stderr: {}\n", message.trim()),
323 ))
324 });
325 return Some(());
326 }
327 };
328
329 let state = self
330 .projects
331 .get_mut(&project)?
332 .servers
333 .get_mut(&language_server_id)?
334 .rpc_state
335 .as_mut()?;
336 state.buffer.update(cx, |buffer, cx| {
337 let kind = if is_received {
338 MessageKind::Receive
339 } else {
340 MessageKind::Send
341 };
342 if state.last_message_kind != Some(kind) {
343 let len = buffer.len();
344 let line = match kind {
345 MessageKind::Send => SEND_LINE,
346 MessageKind::Receive => RECEIVE_LINE,
347 };
348 buffer.edit([(len..len, line)], None, cx);
349 state.last_message_kind = Some(kind);
350 }
351 let len = buffer.len();
352 buffer.edit([(len..len, message)], None, cx);
353 });
354 Some(())
355 }
356}
357
358impl LspLogView {
359 pub fn new(
360 project: ModelHandle<Project>,
361 log_store: ModelHandle<LogStore>,
362 cx: &mut ViewContext<Self>,
363 ) -> Self {
364 let server_id = log_store
365 .read(cx)
366 .projects
367 .get(&project.downgrade())
368 .and_then(|project| project.servers.keys().copied().next());
369 let buffer = cx.add_model(|cx| Buffer::new(0, cx.model_id() as u64, ""));
370 let mut this = Self {
371 editor: Self::editor_for_buffer(project.clone(), buffer, cx),
372 project,
373 log_store,
374 current_server_id: None,
375 is_showing_rpc_trace: false,
376 };
377 if let Some(server_id) = server_id {
378 this.show_logs_for_server(server_id, cx);
379 }
380 this
381 }
382
383 fn editor_for_buffer(
384 project: ModelHandle<Project>,
385 buffer: ModelHandle<Buffer>,
386 cx: &mut ViewContext<Self>,
387 ) -> ViewHandle<Editor> {
388 let editor = cx.add_view(|cx| {
389 let mut editor = Editor::for_buffer(buffer, Some(project), cx);
390 editor.set_read_only(true);
391 editor.move_to_end(&Default::default(), cx);
392 editor
393 });
394 cx.subscribe(&editor, |_, _, event, cx| cx.emit(event.clone()))
395 .detach();
396 editor
397 }
398
399 pub(crate) fn menu_items<'a>(&'a self, cx: &'a AppContext) -> Option<Vec<LogMenuItem>> {
400 let log_store = self.log_store.read(cx);
401 let state = log_store.projects.get(&self.project.downgrade())?;
402 let mut rows = self
403 .project
404 .read(cx)
405 .language_servers()
406 .filter_map(|(server_id, language_server_name, worktree_id)| {
407 let worktree = self.project.read(cx).worktree_for_id(worktree_id, cx)?;
408 let state = state.servers.get(&server_id)?;
409 Some(LogMenuItem {
410 server_id,
411 server_name: language_server_name,
412 worktree_root_name: worktree.read(cx).root_name().to_string(),
413 rpc_trace_enabled: state.rpc_state.is_some(),
414 rpc_trace_selected: self.is_showing_rpc_trace
415 && self.current_server_id == Some(server_id),
416 logs_selected: !self.is_showing_rpc_trace
417 && self.current_server_id == Some(server_id),
418 })
419 })
420 .chain(
421 self.project
422 .read(cx)
423 .supplementary_language_servers()
424 .filter_map(|(&server_id, (name, _))| {
425 let state = state.servers.get(&server_id)?;
426 Some(LogMenuItem {
427 server_id,
428 server_name: name.clone(),
429 worktree_root_name: "supplementary".to_string(),
430 rpc_trace_enabled: state.rpc_state.is_some(),
431 rpc_trace_selected: self.is_showing_rpc_trace
432 && self.current_server_id == Some(server_id),
433 logs_selected: !self.is_showing_rpc_trace
434 && self.current_server_id == Some(server_id),
435 })
436 }),
437 )
438 .collect::<Vec<_>>();
439 rows.sort_by_key(|row| row.server_id);
440 rows.dedup_by_key(|row| row.server_id);
441 Some(rows)
442 }
443
444 fn show_logs_for_server(&mut self, server_id: LanguageServerId, cx: &mut ViewContext<Self>) {
445 let buffer = self
446 .log_store
447 .read(cx)
448 .log_buffer_for_server(&self.project, server_id);
449 if let Some(buffer) = buffer {
450 self.current_server_id = Some(server_id);
451 self.is_showing_rpc_trace = false;
452 self.editor = Self::editor_for_buffer(self.project.clone(), buffer, cx);
453 cx.notify();
454 }
455 }
456
457 fn show_rpc_trace_for_server(
458 &mut self,
459 server_id: LanguageServerId,
460 cx: &mut ViewContext<Self>,
461 ) {
462 let buffer = self.log_store.update(cx, |log_set, cx| {
463 log_set.enable_rpc_trace_for_language_server(&self.project, server_id, cx)
464 });
465 if let Some(buffer) = buffer {
466 self.current_server_id = Some(server_id);
467 self.is_showing_rpc_trace = true;
468 self.editor = Self::editor_for_buffer(self.project.clone(), buffer, cx);
469 cx.notify();
470 }
471 }
472
473 fn toggle_rpc_trace_for_server(
474 &mut self,
475 server_id: LanguageServerId,
476 enabled: bool,
477 cx: &mut ViewContext<Self>,
478 ) {
479 self.log_store.update(cx, |log_store, cx| {
480 if enabled {
481 log_store.enable_rpc_trace_for_language_server(&self.project, server_id, cx);
482 } else {
483 log_store.disable_rpc_trace_for_language_server(&self.project, server_id, cx);
484 }
485 });
486 if !enabled && Some(server_id) == self.current_server_id {
487 self.show_logs_for_server(server_id, cx);
488 cx.notify();
489 }
490 }
491}
492
493impl View for LspLogView {
494 fn ui_name() -> &'static str {
495 "LspLogView"
496 }
497
498 fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
499 ChildView::new(&self.editor, cx).into_any()
500 }
501
502 fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
503 if cx.is_self_focused() {
504 cx.focus(&self.editor);
505 }
506 }
507}
508
509impl Item for LspLogView {
510 fn tab_content<V: 'static>(
511 &self,
512 _: Option<usize>,
513 style: &theme::Tab,
514 _: &AppContext,
515 ) -> AnyElement<V> {
516 Label::new("LSP Logs", style.label.clone()).into_any()
517 }
518
519 fn as_searchable(&self, handle: &ViewHandle<Self>) -> Option<Box<dyn SearchableItemHandle>> {
520 Some(Box::new(handle.clone()))
521 }
522}
523
524impl SearchableItem for LspLogView {
525 type Match = <Editor as SearchableItem>::Match;
526
527 fn to_search_event(
528 &mut self,
529 event: &Self::Event,
530 cx: &mut ViewContext<Self>,
531 ) -> Option<workspace::searchable::SearchEvent> {
532 self.editor
533 .update(cx, |editor, cx| editor.to_search_event(event, cx))
534 }
535
536 fn clear_matches(&mut self, cx: &mut ViewContext<Self>) {
537 self.editor.update(cx, |e, cx| e.clear_matches(cx))
538 }
539
540 fn update_matches(&mut self, matches: Vec<Self::Match>, cx: &mut ViewContext<Self>) {
541 self.editor
542 .update(cx, |e, cx| e.update_matches(matches, cx))
543 }
544
545 fn query_suggestion(&mut self, cx: &mut ViewContext<Self>) -> String {
546 self.editor.update(cx, |e, cx| e.query_suggestion(cx))
547 }
548
549 fn activate_match(
550 &mut self,
551 index: usize,
552 matches: Vec<Self::Match>,
553 cx: &mut ViewContext<Self>,
554 ) {
555 self.editor
556 .update(cx, |e, cx| e.activate_match(index, matches, cx))
557 }
558
559 fn select_matches(&mut self, matches: Vec<Self::Match>, cx: &mut ViewContext<Self>) {
560 self.editor
561 .update(cx, |e, cx| e.select_matches(matches, cx))
562 }
563
564 fn find_matches(
565 &mut self,
566 query: Arc<project::search::SearchQuery>,
567 cx: &mut ViewContext<Self>,
568 ) -> gpui::Task<Vec<Self::Match>> {
569 self.editor.update(cx, |e, cx| e.find_matches(query, cx))
570 }
571
572 fn replace(&mut self, _: &Self::Match, _: &SearchQuery, _: &mut ViewContext<Self>) {
573 // Since LSP Log is read-only, it doesn't make sense to support replace operation.
574 }
575 fn supported_options() -> workspace::searchable::SearchOptions {
576 workspace::searchable::SearchOptions {
577 case: true,
578 word: true,
579 regex: true,
580 // LSP log is read-only.
581 replacement: false,
582 }
583 }
584 fn active_match_index(
585 &mut self,
586 matches: Vec<Self::Match>,
587 cx: &mut ViewContext<Self>,
588 ) -> Option<usize> {
589 self.editor
590 .update(cx, |e, cx| e.active_match_index(matches, cx))
591 }
592}
593
594impl ToolbarItemView for LspLogToolbarItemView {
595 fn set_active_pane_item(
596 &mut self,
597 active_pane_item: Option<&dyn ItemHandle>,
598 _: &mut ViewContext<Self>,
599 ) -> workspace::ToolbarItemLocation {
600 self.menu_open = false;
601 if let Some(item) = active_pane_item {
602 if let Some(log_view) = item.downcast::<LspLogView>() {
603 self.log_view = Some(log_view.clone());
604 return ToolbarItemLocation::PrimaryLeft {
605 flex: Some((1., false)),
606 };
607 }
608 }
609 self.log_view = None;
610 ToolbarItemLocation::Hidden
611 }
612}
613
614impl View for LspLogToolbarItemView {
615 fn ui_name() -> &'static str {
616 "LspLogView"
617 }
618
619 fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
620 let theme = theme::current(cx).clone();
621 let Some(log_view) = self.log_view.as_ref() else {
622 return Empty::new().into_any();
623 };
624 let (menu_rows, current_server_id) = log_view.update(cx, |log_view, cx| {
625 let menu_rows = log_view.menu_items(cx).unwrap_or_default();
626 let current_server_id = log_view.current_server_id;
627 (menu_rows, current_server_id)
628 });
629
630 let current_server = current_server_id.and_then(|current_server_id| {
631 if let Ok(ix) = menu_rows.binary_search_by_key(¤t_server_id, |e| e.server_id) {
632 Some(menu_rows[ix].clone())
633 } else {
634 None
635 }
636 });
637 let server_selected = current_server.is_some();
638
639 enum Menu {}
640 let lsp_menu = Stack::new()
641 .with_child(Self::render_language_server_menu_header(
642 current_server,
643 &theme,
644 cx,
645 ))
646 .with_children(if self.menu_open {
647 Some(
648 Overlay::new(
649 MouseEventHandler::new::<Menu, _>(0, cx, move |_, cx| {
650 Flex::column()
651 .with_children(menu_rows.into_iter().map(|row| {
652 Self::render_language_server_menu_item(
653 row.server_id,
654 row.server_name,
655 &row.worktree_root_name,
656 row.rpc_trace_enabled,
657 row.logs_selected,
658 row.rpc_trace_selected,
659 &theme,
660 cx,
661 )
662 }))
663 .contained()
664 .with_style(theme.toolbar_dropdown_menu.container)
665 .constrained()
666 .with_width(400.)
667 .with_height(400.)
668 })
669 .on_down_out(MouseButton::Left, |_, this, cx| {
670 this.menu_open = false;
671 cx.notify()
672 }),
673 )
674 .with_hoverable(true)
675 .with_fit_mode(OverlayFitMode::SwitchAnchor)
676 .with_anchor_corner(AnchorCorner::TopLeft)
677 .with_z_index(999)
678 .aligned()
679 .bottom()
680 .left(),
681 )
682 } else {
683 None
684 })
685 .aligned()
686 .left()
687 .clipped();
688
689 enum LspCleanupButton {}
690 let log_cleanup_button =
691 MouseEventHandler::new::<LspCleanupButton, _>(1, cx, |state, cx| {
692 let theme = theme::current(cx).clone();
693 let style = theme
694 .workspace
695 .toolbar
696 .toggleable_text_tool
697 .in_state(server_selected)
698 .style_for(state);
699 Label::new("Clear", style.text.clone())
700 .aligned()
701 .contained()
702 .with_style(style.container)
703 .constrained()
704 .with_height(theme.toolbar_dropdown_menu.row_height / 6.0 * 5.0)
705 })
706 .on_click(MouseButton::Left, move |_, this, cx| {
707 if let Some(log_view) = this.log_view.as_ref() {
708 log_view.update(cx, |log_view, cx| {
709 log_view.editor.update(cx, |editor, cx| {
710 editor.set_read_only(false);
711 editor.clear(cx);
712 editor.set_read_only(true);
713 });
714 })
715 }
716 })
717 .with_cursor_style(CursorStyle::PointingHand)
718 .aligned()
719 .right();
720
721 Flex::row()
722 .with_child(lsp_menu)
723 .with_child(log_cleanup_button)
724 .contained()
725 .aligned()
726 .left()
727 .into_any_named("lsp log controls")
728 }
729}
730
731const RPC_MESSAGES: &str = "RPC Messages";
732const SERVER_LOGS: &str = "Server Logs";
733
734impl LspLogToolbarItemView {
735 pub fn new() -> Self {
736 Self {
737 menu_open: false,
738 log_view: None,
739 }
740 }
741
742 fn toggle_menu(&mut self, cx: &mut ViewContext<Self>) {
743 self.menu_open = !self.menu_open;
744 cx.notify();
745 }
746
747 fn toggle_logging_for_server(
748 &mut self,
749 id: LanguageServerId,
750 enabled: bool,
751 cx: &mut ViewContext<Self>,
752 ) {
753 if let Some(log_view) = &self.log_view {
754 log_view.update(cx, |log_view, cx| {
755 log_view.toggle_rpc_trace_for_server(id, enabled, cx);
756 if !enabled && Some(id) == log_view.current_server_id {
757 log_view.show_logs_for_server(id, cx);
758 cx.notify();
759 }
760 });
761 }
762 cx.notify();
763 }
764
765 fn show_logs_for_server(&mut self, id: LanguageServerId, cx: &mut ViewContext<Self>) {
766 if let Some(log_view) = &self.log_view {
767 log_view.update(cx, |view, cx| view.show_logs_for_server(id, cx));
768 self.menu_open = false;
769 cx.notify();
770 }
771 }
772
773 fn show_rpc_trace_for_server(&mut self, id: LanguageServerId, cx: &mut ViewContext<Self>) {
774 if let Some(log_view) = &self.log_view {
775 log_view.update(cx, |view, cx| view.show_rpc_trace_for_server(id, cx));
776 self.menu_open = false;
777 cx.notify();
778 }
779 }
780
781 fn render_language_server_menu_header(
782 current_server: Option<LogMenuItem>,
783 theme: &Arc<Theme>,
784 cx: &mut ViewContext<Self>,
785 ) -> impl Element<Self> {
786 enum ToggleMenu {}
787 MouseEventHandler::new::<ToggleMenu, _>(0, cx, move |state, _| {
788 let label: Cow<str> = current_server
789 .and_then(|row| {
790 Some(
791 format!(
792 "{} ({}) - {}",
793 row.server_name.0,
794 row.worktree_root_name,
795 if row.rpc_trace_selected {
796 RPC_MESSAGES
797 } else {
798 SERVER_LOGS
799 },
800 )
801 .into(),
802 )
803 })
804 .unwrap_or_else(|| "No server selected".into());
805 let style = theme.toolbar_dropdown_menu.header.style_for(state);
806 Label::new(label, style.text.clone())
807 .contained()
808 .with_style(style.container)
809 })
810 .with_cursor_style(CursorStyle::PointingHand)
811 .on_click(MouseButton::Left, move |_, view, cx| {
812 view.toggle_menu(cx);
813 })
814 }
815
816 fn render_language_server_menu_item(
817 id: LanguageServerId,
818 name: LanguageServerName,
819 worktree_root_name: &str,
820 rpc_trace_enabled: bool,
821 logs_selected: bool,
822 rpc_trace_selected: bool,
823 theme: &Arc<Theme>,
824 cx: &mut ViewContext<Self>,
825 ) -> impl Element<Self> {
826 enum ActivateLog {}
827 enum ActivateRpcTrace {}
828
829 Flex::column()
830 .with_child({
831 let style = &theme.toolbar_dropdown_menu.section_header;
832 Label::new(
833 format!("{} ({})", name.0, worktree_root_name),
834 style.text.clone(),
835 )
836 .contained()
837 .with_style(style.container)
838 .constrained()
839 .with_height(theme.toolbar_dropdown_menu.row_height)
840 })
841 .with_child(
842 MouseEventHandler::new::<ActivateLog, _>(id.0, cx, move |state, _| {
843 let style = theme
844 .toolbar_dropdown_menu
845 .item
846 .in_state(logs_selected)
847 .style_for(state);
848 Label::new(SERVER_LOGS, style.text.clone())
849 .contained()
850 .with_style(style.container)
851 .constrained()
852 .with_height(theme.toolbar_dropdown_menu.row_height)
853 })
854 .with_cursor_style(CursorStyle::PointingHand)
855 .on_click(MouseButton::Left, move |_, view, cx| {
856 view.show_logs_for_server(id, cx);
857 }),
858 )
859 .with_child(
860 MouseEventHandler::new::<ActivateRpcTrace, _>(id.0, cx, move |state, cx| {
861 let style = theme
862 .toolbar_dropdown_menu
863 .item
864 .in_state(rpc_trace_selected)
865 .style_for(state);
866 Flex::row()
867 .with_child(
868 Label::new(RPC_MESSAGES, style.text.clone())
869 .constrained()
870 .with_height(theme.toolbar_dropdown_menu.row_height),
871 )
872 .with_child(
873 ui::checkbox_with_label::<Self, _, Self, _>(
874 Empty::new(),
875 &theme.welcome.checkbox,
876 rpc_trace_enabled,
877 id.0,
878 cx,
879 move |this, enabled, cx| {
880 this.toggle_logging_for_server(id, enabled, cx);
881 },
882 )
883 .flex_float(),
884 )
885 .align_children_center()
886 .contained()
887 .with_style(style.container)
888 .constrained()
889 .with_height(theme.toolbar_dropdown_menu.row_height)
890 })
891 .with_cursor_style(CursorStyle::PointingHand)
892 .on_click(MouseButton::Left, move |_, view, cx| {
893 view.show_rpc_trace_for_server(id, cx);
894 }),
895 )
896 }
897}
898
899impl Entity for LogStore {
900 type Event = ();
901}
902
903impl Entity for LspLogView {
904 type Event = editor::Event;
905}
906
907impl Entity for LspLogToolbarItemView {
908 type Event = ();
909}