1use crate::{
2 Anchor, Autoscroll, Editor, EditorEvent, EditorSettings, ExcerptId, ExcerptRange, FormatTarget,
3 MultiBuffer, MultiBufferSnapshot, NavigationData, ReportEditorEvent, SearchWithinRange,
4 SelectionEffects, ToPoint as _,
5 display_map::HighlightKey,
6 editor_settings::SeedQuerySetting,
7 persistence::{DB, SerializedEditor},
8 scroll::ScrollAnchor,
9};
10use anyhow::{Context as _, Result, anyhow};
11use collections::{HashMap, HashSet};
12use file_icons::FileIcons;
13use futures::future::try_join_all;
14use git::status::GitSummary;
15use gpui::{
16 AnyElement, App, AsyncWindowContext, Context, Entity, EntityId, EventEmitter, IntoElement,
17 ParentElement, Pixels, SharedString, Styled, Task, WeakEntity, Window, point,
18};
19use language::{
20 Bias, Buffer, BufferRow, CharKind, DiskState, LocalFile, Point, SelectionGoal,
21 proto::serialize_anchor as serialize_text_anchor,
22};
23use lsp::DiagnosticSeverity;
24use project::{
25 Project, ProjectItem as _, ProjectPath, lsp_store::FormatTrigger,
26 project_settings::ProjectSettings, search::SearchQuery,
27};
28use rpc::proto::{self, update_view};
29use settings::Settings;
30use std::{
31 any::TypeId,
32 borrow::Cow,
33 cmp::{self, Ordering},
34 iter,
35 ops::Range,
36 path::{Path, PathBuf},
37 sync::Arc,
38};
39use text::{BufferId, BufferSnapshot, Selection};
40use theme::{Theme, ThemeSettings};
41use ui::{IconDecorationKind, prelude::*};
42use util::{ResultExt, TryFutureExt, paths::PathExt};
43use workspace::{
44 CollaboratorId, ItemId, ItemNavHistory, ToolbarItemLocation, ViewId, Workspace, WorkspaceId,
45 item::{FollowableItem, Item, ItemEvent, ProjectItem, SaveOptions},
46 searchable::{Direction, SearchEvent, SearchableItem, SearchableItemHandle},
47};
48use workspace::{
49 OpenOptions,
50 item::{Dedup, ItemSettings, SerializableItem, TabContentParams},
51};
52use workspace::{
53 OpenVisible, Pane, WorkspaceSettings,
54 item::{BreadcrumbText, FollowEvent, ProjectItemKind},
55 searchable::SearchOptions,
56};
57
58pub const MAX_TAB_TITLE_LEN: usize = 24;
59
60impl FollowableItem for Editor {
61 fn remote_id(&self) -> Option<ViewId> {
62 self.remote_id
63 }
64
65 fn from_state_proto(
66 workspace: Entity<Workspace>,
67 remote_id: ViewId,
68 state: &mut Option<proto::view::Variant>,
69 window: &mut Window,
70 cx: &mut App,
71 ) -> Option<Task<Result<Entity<Self>>>> {
72 let project = workspace.read(cx).project().to_owned();
73 let Some(proto::view::Variant::Editor(_)) = state else {
74 return None;
75 };
76 let Some(proto::view::Variant::Editor(state)) = state.take() else {
77 unreachable!()
78 };
79
80 let buffer_ids = state
81 .excerpts
82 .iter()
83 .map(|excerpt| excerpt.buffer_id)
84 .collect::<HashSet<_>>();
85 let buffers = project.update(cx, |project, cx| {
86 buffer_ids
87 .iter()
88 .map(|id| BufferId::new(*id).map(|id| project.open_buffer_by_id(id, cx)))
89 .collect::<Result<Vec<_>>>()
90 });
91
92 Some(window.spawn(cx, async move |cx| {
93 let mut buffers = futures::future::try_join_all(buffers?)
94 .await
95 .debug_assert_ok("leaders don't share views for unshared buffers")?;
96
97 let editor = cx.update(|window, cx| {
98 let multibuffer = cx.new(|cx| {
99 let mut multibuffer;
100 if state.singleton && buffers.len() == 1 {
101 multibuffer = MultiBuffer::singleton(buffers.pop().unwrap(), cx)
102 } else {
103 multibuffer = MultiBuffer::new(project.read(cx).capability());
104 let mut sorted_excerpts = state.excerpts.clone();
105 sorted_excerpts.sort_by_key(|e| e.id);
106 let mut sorted_excerpts = sorted_excerpts.into_iter().peekable();
107
108 while let Some(excerpt) = sorted_excerpts.next() {
109 let Ok(buffer_id) = BufferId::new(excerpt.buffer_id) else {
110 continue;
111 };
112
113 let mut insert_position = ExcerptId::min();
114 for e in &state.excerpts {
115 if e.id == excerpt.id {
116 break;
117 }
118 if e.id < excerpt.id {
119 insert_position = ExcerptId::from_proto(e.id);
120 }
121 }
122
123 let buffer =
124 buffers.iter().find(|b| b.read(cx).remote_id() == buffer_id);
125
126 let Some(excerpt) = deserialize_excerpt_range(excerpt) else {
127 continue;
128 };
129
130 let Some(buffer) = buffer else { continue };
131
132 multibuffer.insert_excerpts_with_ids_after(
133 insert_position,
134 buffer.clone(),
135 [excerpt],
136 cx,
137 );
138 }
139 };
140
141 if let Some(title) = &state.title {
142 multibuffer = multibuffer.with_title(title.clone())
143 }
144
145 multibuffer
146 });
147
148 cx.new(|cx| {
149 let mut editor =
150 Editor::for_multibuffer(multibuffer, Some(project.clone()), window, cx);
151 editor.remote_id = Some(remote_id);
152 editor
153 })
154 })?;
155
156 update_editor_from_message(
157 editor.downgrade(),
158 project,
159 proto::update_view::Editor {
160 selections: state.selections,
161 pending_selection: state.pending_selection,
162 scroll_top_anchor: state.scroll_top_anchor,
163 scroll_x: state.scroll_x,
164 scroll_y: state.scroll_y,
165 ..Default::default()
166 },
167 cx,
168 )
169 .await?;
170
171 Ok(editor)
172 }))
173 }
174
175 fn set_leader_id(
176 &mut self,
177 leader_id: Option<CollaboratorId>,
178 window: &mut Window,
179 cx: &mut Context<Self>,
180 ) {
181 self.leader_id = leader_id;
182 if self.leader_id.is_some() {
183 self.buffer.update(cx, |buffer, cx| {
184 buffer.remove_active_selections(cx);
185 });
186 } else if self.focus_handle.is_focused(window) {
187 self.buffer.update(cx, |buffer, cx| {
188 buffer.set_active_selections(
189 &self.selections.disjoint_anchors(),
190 self.selections.line_mode,
191 self.cursor_shape,
192 cx,
193 );
194 });
195 }
196 cx.notify();
197 }
198
199 fn to_state_proto(&self, _: &Window, cx: &App) -> Option<proto::view::Variant> {
200 let buffer = self.buffer.read(cx);
201 if buffer
202 .as_singleton()
203 .and_then(|buffer| buffer.read(cx).file())
204 .is_some_and(|file| file.is_private())
205 {
206 return None;
207 }
208
209 let scroll_anchor = self.scroll_manager.anchor();
210 let excerpts = buffer
211 .read(cx)
212 .excerpts()
213 .map(|(id, buffer, range)| proto::Excerpt {
214 id: id.to_proto(),
215 buffer_id: buffer.remote_id().into(),
216 context_start: Some(serialize_text_anchor(&range.context.start)),
217 context_end: Some(serialize_text_anchor(&range.context.end)),
218 primary_start: Some(serialize_text_anchor(&range.primary.start)),
219 primary_end: Some(serialize_text_anchor(&range.primary.end)),
220 })
221 .collect();
222 let snapshot = buffer.snapshot(cx);
223
224 Some(proto::view::Variant::Editor(proto::view::Editor {
225 singleton: buffer.is_singleton(),
226 title: (!buffer.is_singleton()).then(|| buffer.title(cx).into()),
227 excerpts,
228 scroll_top_anchor: Some(serialize_anchor(&scroll_anchor.anchor, &snapshot)),
229 scroll_x: scroll_anchor.offset.x,
230 scroll_y: scroll_anchor.offset.y,
231 selections: self
232 .selections
233 .disjoint_anchors()
234 .iter()
235 .map(|s| serialize_selection(s, &snapshot))
236 .collect(),
237 pending_selection: self
238 .selections
239 .pending_anchor()
240 .as_ref()
241 .map(|s| serialize_selection(s, &snapshot)),
242 }))
243 }
244
245 fn to_follow_event(event: &EditorEvent) -> Option<workspace::item::FollowEvent> {
246 match event {
247 EditorEvent::Edited { .. } => Some(FollowEvent::Unfollow),
248 EditorEvent::SelectionsChanged { local }
249 | EditorEvent::ScrollPositionChanged { local, .. } => {
250 if *local {
251 Some(FollowEvent::Unfollow)
252 } else {
253 None
254 }
255 }
256 _ => None,
257 }
258 }
259
260 fn add_event_to_update_proto(
261 &self,
262 event: &EditorEvent,
263 update: &mut Option<proto::update_view::Variant>,
264 _: &Window,
265 cx: &App,
266 ) -> bool {
267 let update =
268 update.get_or_insert_with(|| proto::update_view::Variant::Editor(Default::default()));
269
270 match update {
271 proto::update_view::Variant::Editor(update) => match event {
272 EditorEvent::ExcerptsAdded {
273 buffer,
274 predecessor,
275 excerpts,
276 } => {
277 let buffer_id = buffer.read(cx).remote_id();
278 let mut excerpts = excerpts.iter();
279 if let Some((id, range)) = excerpts.next() {
280 update.inserted_excerpts.push(proto::ExcerptInsertion {
281 previous_excerpt_id: Some(predecessor.to_proto()),
282 excerpt: serialize_excerpt(buffer_id, id, range),
283 });
284 update.inserted_excerpts.extend(excerpts.map(|(id, range)| {
285 proto::ExcerptInsertion {
286 previous_excerpt_id: None,
287 excerpt: serialize_excerpt(buffer_id, id, range),
288 }
289 }))
290 }
291 true
292 }
293 EditorEvent::ExcerptsRemoved { ids, .. } => {
294 update
295 .deleted_excerpts
296 .extend(ids.iter().copied().map(ExcerptId::to_proto));
297 true
298 }
299 EditorEvent::ScrollPositionChanged { autoscroll, .. } if !autoscroll => {
300 let snapshot = self.buffer.read(cx).snapshot(cx);
301 let scroll_anchor = self.scroll_manager.anchor();
302 update.scroll_top_anchor =
303 Some(serialize_anchor(&scroll_anchor.anchor, &snapshot));
304 update.scroll_x = scroll_anchor.offset.x;
305 update.scroll_y = scroll_anchor.offset.y;
306 true
307 }
308 EditorEvent::SelectionsChanged { .. } => {
309 let snapshot = self.buffer.read(cx).snapshot(cx);
310 update.selections = self
311 .selections
312 .disjoint_anchors()
313 .iter()
314 .map(|s| serialize_selection(s, &snapshot))
315 .collect();
316 update.pending_selection = self
317 .selections
318 .pending_anchor()
319 .as_ref()
320 .map(|s| serialize_selection(s, &snapshot));
321 true
322 }
323 _ => false,
324 },
325 }
326 }
327
328 fn apply_update_proto(
329 &mut self,
330 project: &Entity<Project>,
331 message: update_view::Variant,
332 window: &mut Window,
333 cx: &mut Context<Self>,
334 ) -> Task<Result<()>> {
335 let update_view::Variant::Editor(message) = message;
336 let project = project.clone();
337 cx.spawn_in(window, async move |this, cx| {
338 update_editor_from_message(this, project, message, cx).await
339 })
340 }
341
342 fn is_project_item(&self, _window: &Window, _cx: &App) -> bool {
343 true
344 }
345
346 fn dedup(&self, existing: &Self, _: &Window, cx: &App) -> Option<Dedup> {
347 let self_singleton = self.buffer.read(cx).as_singleton()?;
348 let other_singleton = existing.buffer.read(cx).as_singleton()?;
349 if self_singleton == other_singleton {
350 Some(Dedup::KeepExisting)
351 } else {
352 None
353 }
354 }
355
356 fn update_agent_location(
357 &mut self,
358 location: language::Anchor,
359 window: &mut Window,
360 cx: &mut Context<Self>,
361 ) {
362 let buffer = self.buffer.read(cx);
363 let buffer = buffer.read(cx);
364 let Some((excerpt_id, _, _)) = buffer.as_singleton() else {
365 return;
366 };
367 let position = buffer.anchor_in_excerpt(*excerpt_id, location).unwrap();
368 let selection = Selection {
369 id: 0,
370 reversed: false,
371 start: position,
372 end: position,
373 goal: SelectionGoal::None,
374 };
375 drop(buffer);
376 self.set_selections_from_remote(vec![selection], None, window, cx);
377 self.request_autoscroll_remotely(Autoscroll::fit(), cx);
378 }
379}
380
381async fn update_editor_from_message(
382 this: WeakEntity<Editor>,
383 project: Entity<Project>,
384 message: proto::update_view::Editor,
385 cx: &mut AsyncWindowContext,
386) -> Result<()> {
387 // Open all of the buffers of which excerpts were added to the editor.
388 let inserted_excerpt_buffer_ids = message
389 .inserted_excerpts
390 .iter()
391 .filter_map(|insertion| Some(insertion.excerpt.as_ref()?.buffer_id))
392 .collect::<HashSet<_>>();
393 let inserted_excerpt_buffers = project.update(cx, |project, cx| {
394 inserted_excerpt_buffer_ids
395 .into_iter()
396 .map(|id| BufferId::new(id).map(|id| project.open_buffer_by_id(id, cx)))
397 .collect::<Result<Vec<_>>>()
398 })??;
399 let _inserted_excerpt_buffers = try_join_all(inserted_excerpt_buffers).await?;
400
401 // Update the editor's excerpts.
402 this.update(cx, |editor, cx| {
403 editor.buffer.update(cx, |multibuffer, cx| {
404 let mut removed_excerpt_ids = message
405 .deleted_excerpts
406 .into_iter()
407 .map(ExcerptId::from_proto)
408 .collect::<Vec<_>>();
409 removed_excerpt_ids.sort_by({
410 let multibuffer = multibuffer.read(cx);
411 move |a, b| a.cmp(b, &multibuffer)
412 });
413
414 let mut insertions = message.inserted_excerpts.into_iter().peekable();
415 while let Some(insertion) = insertions.next() {
416 let Some(excerpt) = insertion.excerpt else {
417 continue;
418 };
419 let Some(previous_excerpt_id) = insertion.previous_excerpt_id else {
420 continue;
421 };
422 let buffer_id = BufferId::new(excerpt.buffer_id)?;
423 let Some(buffer) = project.read(cx).buffer_for_id(buffer_id, cx) else {
424 continue;
425 };
426
427 let adjacent_excerpts = iter::from_fn(|| {
428 let insertion = insertions.peek()?;
429 if insertion.previous_excerpt_id.is_none()
430 && insertion.excerpt.as_ref()?.buffer_id == u64::from(buffer_id)
431 {
432 insertions.next()?.excerpt
433 } else {
434 None
435 }
436 });
437
438 multibuffer.insert_excerpts_with_ids_after(
439 ExcerptId::from_proto(previous_excerpt_id),
440 buffer,
441 [excerpt]
442 .into_iter()
443 .chain(adjacent_excerpts)
444 .filter_map(deserialize_excerpt_range),
445 cx,
446 );
447 }
448
449 multibuffer.remove_excerpts(removed_excerpt_ids, cx);
450 anyhow::Ok(())
451 })
452 })??;
453
454 // Deserialize the editor state.
455 let (selections, pending_selection, scroll_top_anchor) = this.update(cx, |editor, cx| {
456 let buffer = editor.buffer.read(cx).read(cx);
457 let selections = message
458 .selections
459 .into_iter()
460 .filter_map(|selection| deserialize_selection(&buffer, selection))
461 .collect::<Vec<_>>();
462 let pending_selection = message
463 .pending_selection
464 .and_then(|selection| deserialize_selection(&buffer, selection));
465 let scroll_top_anchor = message
466 .scroll_top_anchor
467 .and_then(|anchor| deserialize_anchor(&buffer, anchor));
468 anyhow::Ok((selections, pending_selection, scroll_top_anchor))
469 })??;
470
471 // Wait until the buffer has received all of the operations referenced by
472 // the editor's new state.
473 this.update(cx, |editor, cx| {
474 editor.buffer.update(cx, |buffer, cx| {
475 buffer.wait_for_anchors(
476 selections
477 .iter()
478 .chain(pending_selection.as_ref())
479 .flat_map(|selection| [selection.start, selection.end])
480 .chain(scroll_top_anchor),
481 cx,
482 )
483 })
484 })?
485 .await?;
486
487 // Update the editor's state.
488 this.update_in(cx, |editor, window, cx| {
489 if !selections.is_empty() || pending_selection.is_some() {
490 editor.set_selections_from_remote(selections, pending_selection, window, cx);
491 editor.request_autoscroll_remotely(Autoscroll::newest(), cx);
492 } else if let Some(scroll_top_anchor) = scroll_top_anchor {
493 editor.set_scroll_anchor_remote(
494 ScrollAnchor {
495 anchor: scroll_top_anchor,
496 offset: point(message.scroll_x, message.scroll_y),
497 },
498 window,
499 cx,
500 );
501 }
502 })?;
503 Ok(())
504}
505
506fn serialize_excerpt(
507 buffer_id: BufferId,
508 id: &ExcerptId,
509 range: &ExcerptRange<language::Anchor>,
510) -> Option<proto::Excerpt> {
511 Some(proto::Excerpt {
512 id: id.to_proto(),
513 buffer_id: buffer_id.into(),
514 context_start: Some(serialize_text_anchor(&range.context.start)),
515 context_end: Some(serialize_text_anchor(&range.context.end)),
516 primary_start: Some(serialize_text_anchor(&range.primary.start)),
517 primary_end: Some(serialize_text_anchor(&range.primary.end)),
518 })
519}
520
521fn serialize_selection(
522 selection: &Selection<Anchor>,
523 buffer: &MultiBufferSnapshot,
524) -> proto::Selection {
525 proto::Selection {
526 id: selection.id as u64,
527 start: Some(serialize_anchor(&selection.start, buffer)),
528 end: Some(serialize_anchor(&selection.end, buffer)),
529 reversed: selection.reversed,
530 }
531}
532
533fn serialize_anchor(anchor: &Anchor, buffer: &MultiBufferSnapshot) -> proto::EditorAnchor {
534 proto::EditorAnchor {
535 excerpt_id: buffer.latest_excerpt_id(anchor.excerpt_id).to_proto(),
536 anchor: Some(serialize_text_anchor(&anchor.text_anchor)),
537 }
538}
539
540fn deserialize_excerpt_range(
541 excerpt: proto::Excerpt,
542) -> Option<(ExcerptId, ExcerptRange<language::Anchor>)> {
543 let context = {
544 let start = language::proto::deserialize_anchor(excerpt.context_start?)?;
545 let end = language::proto::deserialize_anchor(excerpt.context_end?)?;
546 start..end
547 };
548 let primary = excerpt
549 .primary_start
550 .zip(excerpt.primary_end)
551 .and_then(|(start, end)| {
552 let start = language::proto::deserialize_anchor(start)?;
553 let end = language::proto::deserialize_anchor(end)?;
554 Some(start..end)
555 })
556 .unwrap_or_else(|| context.clone());
557 Some((
558 ExcerptId::from_proto(excerpt.id),
559 ExcerptRange { context, primary },
560 ))
561}
562
563fn deserialize_selection(
564 buffer: &MultiBufferSnapshot,
565 selection: proto::Selection,
566) -> Option<Selection<Anchor>> {
567 Some(Selection {
568 id: selection.id as usize,
569 start: deserialize_anchor(buffer, selection.start?)?,
570 end: deserialize_anchor(buffer, selection.end?)?,
571 reversed: selection.reversed,
572 goal: SelectionGoal::None,
573 })
574}
575
576fn deserialize_anchor(buffer: &MultiBufferSnapshot, anchor: proto::EditorAnchor) -> Option<Anchor> {
577 let excerpt_id = ExcerptId::from_proto(anchor.excerpt_id);
578 Some(Anchor {
579 excerpt_id,
580 text_anchor: language::proto::deserialize_anchor(anchor.anchor?)?,
581 buffer_id: buffer.buffer_id_for_excerpt(excerpt_id),
582 diff_base_anchor: None,
583 })
584}
585
586impl Item for Editor {
587 type Event = EditorEvent;
588
589 fn navigate(
590 &mut self,
591 data: Box<dyn std::any::Any>,
592 window: &mut Window,
593 cx: &mut Context<Self>,
594 ) -> bool {
595 if let Ok(data) = data.downcast::<NavigationData>() {
596 let newest_selection = self.selections.newest::<Point>(cx);
597 let buffer = self.buffer.read(cx).read(cx);
598 let offset = if buffer.can_resolve(&data.cursor_anchor) {
599 data.cursor_anchor.to_point(&buffer)
600 } else {
601 buffer.clip_point(data.cursor_position, Bias::Left)
602 };
603
604 let mut scroll_anchor = data.scroll_anchor;
605 if !buffer.can_resolve(&scroll_anchor.anchor) {
606 scroll_anchor.anchor = buffer.anchor_before(
607 buffer.clip_point(Point::new(data.scroll_top_row, 0), Bias::Left),
608 );
609 }
610
611 drop(buffer);
612
613 if newest_selection.head() == offset {
614 false
615 } else {
616 self.set_scroll_anchor(scroll_anchor, window, cx);
617 self.change_selections(
618 SelectionEffects::default().nav_history(false),
619 window,
620 cx,
621 |s| s.select_ranges([offset..offset]),
622 );
623 true
624 }
625 } else {
626 false
627 }
628 }
629
630 fn tab_tooltip_text(&self, cx: &App) -> Option<SharedString> {
631 let file_path = self
632 .buffer()
633 .read(cx)
634 .as_singleton()?
635 .read(cx)
636 .file()
637 .and_then(|f| f.as_local())?
638 .abs_path(cx);
639
640 let file_path = file_path.compact().to_string_lossy().to_string();
641
642 Some(file_path.into())
643 }
644
645 fn telemetry_event_text(&self) -> Option<&'static str> {
646 None
647 }
648
649 fn tab_content_text(&self, detail: usize, cx: &App) -> SharedString {
650 if let Some(path) = path_for_buffer(&self.buffer, detail, true, cx) {
651 path.to_string_lossy().to_string().into()
652 } else {
653 "untitled".into()
654 }
655 }
656
657 fn suggested_filename(&self, cx: &App) -> SharedString {
658 self.buffer.read(cx).title(cx).to_string().into()
659 }
660
661 fn tab_icon(&self, _: &Window, cx: &App) -> Option<Icon> {
662 ItemSettings::get_global(cx)
663 .file_icons
664 .then(|| {
665 path_for_buffer(&self.buffer, 0, true, cx)
666 .and_then(|path| FileIcons::get_icon(path.as_ref(), cx))
667 })
668 .flatten()
669 .map(Icon::from_path)
670 }
671
672 fn tab_content(&self, params: TabContentParams, _: &Window, cx: &App) -> AnyElement {
673 let label_color = if ItemSettings::get_global(cx).git_status {
674 self.buffer()
675 .read(cx)
676 .as_singleton()
677 .and_then(|buffer| {
678 let buffer = buffer.read(cx);
679 let path = buffer.project_path(cx)?;
680 let buffer_id = buffer.remote_id();
681 let project = self.project()?.read(cx);
682 let entry = project.entry_for_path(&path, cx)?;
683 let (repo, repo_path) = project
684 .git_store()
685 .read(cx)
686 .repository_and_path_for_buffer_id(buffer_id, cx)?;
687 let status = repo.read(cx).status_for_path(&repo_path)?.status;
688
689 Some(entry_git_aware_label_color(
690 status.summary(),
691 entry.is_ignored,
692 params.selected,
693 ))
694 })
695 .unwrap_or_else(|| entry_label_color(params.selected))
696 } else {
697 entry_label_color(params.selected)
698 };
699
700 let description = params.detail.and_then(|detail| {
701 let path = path_for_buffer(&self.buffer, detail, false, cx)?;
702 let description = path.to_string_lossy();
703 let description = description.trim();
704
705 if description.is_empty() {
706 return None;
707 }
708
709 Some(util::truncate_and_trailoff(description, MAX_TAB_TITLE_LEN))
710 });
711
712 // Whether the file was saved in the past but is now deleted.
713 let was_deleted: bool = self
714 .buffer()
715 .read(cx)
716 .as_singleton()
717 .and_then(|buffer| buffer.read(cx).file())
718 .is_some_and(|file| file.disk_state() == DiskState::Deleted);
719
720 h_flex()
721 .gap_2()
722 .child(
723 Label::new(self.title(cx).to_string())
724 .color(label_color)
725 .when(params.preview, |this| this.italic())
726 .when(was_deleted, |this| this.strikethrough()),
727 )
728 .when_some(description, |this, description| {
729 this.child(
730 Label::new(description)
731 .size(LabelSize::XSmall)
732 .color(Color::Muted),
733 )
734 })
735 .into_any_element()
736 }
737
738 fn for_each_project_item(
739 &self,
740 cx: &App,
741 f: &mut dyn FnMut(EntityId, &dyn project::ProjectItem),
742 ) {
743 self.buffer
744 .read(cx)
745 .for_each_buffer(|buffer| f(buffer.entity_id(), buffer.read(cx)));
746 }
747
748 fn is_singleton(&self, cx: &App) -> bool {
749 self.buffer.read(cx).is_singleton()
750 }
751
752 fn can_save_as(&self, cx: &App) -> bool {
753 self.buffer.read(cx).is_singleton()
754 }
755
756 fn clone_on_split(
757 &self,
758 _workspace_id: Option<WorkspaceId>,
759 window: &mut Window,
760 cx: &mut Context<Self>,
761 ) -> Option<Entity<Editor>>
762 where
763 Self: Sized,
764 {
765 Some(cx.new(|cx| self.clone(window, cx)))
766 }
767
768 fn set_nav_history(
769 &mut self,
770 history: ItemNavHistory,
771 _window: &mut Window,
772 _: &mut Context<Self>,
773 ) {
774 self.nav_history = Some(history);
775 }
776
777 fn discarded(&self, _project: Entity<Project>, _: &mut Window, cx: &mut Context<Self>) {
778 for buffer in self.buffer().clone().read(cx).all_buffers() {
779 buffer.update(cx, |buffer, cx| buffer.discarded(cx))
780 }
781 }
782
783 fn on_removed(&self, cx: &App) {
784 self.report_editor_event(ReportEditorEvent::Closed, None, cx);
785 }
786
787 fn deactivated(&mut self, _: &mut Window, cx: &mut Context<Self>) {
788 let selection = self.selections.newest_anchor();
789 self.push_to_nav_history(selection.head(), None, true, false, cx);
790 }
791
792 fn workspace_deactivated(&mut self, _: &mut Window, cx: &mut Context<Self>) {
793 self.hide_hovered_link(cx);
794 }
795
796 fn is_dirty(&self, cx: &App) -> bool {
797 self.buffer().read(cx).read(cx).is_dirty()
798 }
799
800 fn has_deleted_file(&self, cx: &App) -> bool {
801 self.buffer().read(cx).read(cx).has_deleted_file()
802 }
803
804 fn has_conflict(&self, cx: &App) -> bool {
805 self.buffer().read(cx).read(cx).has_conflict()
806 }
807
808 fn can_save(&self, cx: &App) -> bool {
809 let buffer = &self.buffer().read(cx);
810 if let Some(buffer) = buffer.as_singleton() {
811 buffer.read(cx).project_path(cx).is_some()
812 } else {
813 true
814 }
815 }
816
817 fn save(
818 &mut self,
819 options: SaveOptions,
820 project: Entity<Project>,
821 window: &mut Window,
822 cx: &mut Context<Self>,
823 ) -> Task<Result<()>> {
824 // Add meta data tracking # of auto saves
825 if options.autosave {
826 self.report_editor_event(ReportEditorEvent::Saved { auto_saved: true }, None, cx);
827 } else {
828 self.report_editor_event(ReportEditorEvent::Saved { auto_saved: false }, None, cx);
829 }
830
831 let buffers = self.buffer().clone().read(cx).all_buffers();
832 let buffers = buffers
833 .into_iter()
834 .map(|handle| handle.read(cx).base_buffer().unwrap_or(handle.clone()))
835 .collect::<HashSet<_>>();
836
837 // let mut buffers_to_save =
838 let buffers_to_save = if self.buffer.read(cx).is_singleton() && !options.autosave {
839 buffers.clone()
840 } else {
841 buffers
842 .iter()
843 .filter(|buffer| buffer.read(cx).is_dirty())
844 .cloned()
845 .collect()
846 };
847
848 cx.spawn_in(window, async move |this, cx| {
849 if options.format {
850 this.update_in(cx, |editor, window, cx| {
851 editor.perform_format(
852 project.clone(),
853 FormatTrigger::Save,
854 FormatTarget::Buffers(buffers_to_save.clone()),
855 window,
856 cx,
857 )
858 })?
859 .await?;
860 }
861
862 if !buffers_to_save.is_empty() {
863 project
864 .update(cx, |project, cx| {
865 project.save_buffers(buffers_to_save.clone(), cx)
866 })?
867 .await?;
868 }
869
870 // Notify about clean buffers for language server events
871 let buffers_that_were_not_saved: Vec<_> = buffers
872 .into_iter()
873 .filter(|b| !buffers_to_save.contains(b))
874 .collect();
875
876 for buffer in buffers_that_were_not_saved {
877 buffer
878 .update(cx, |buffer, cx| {
879 let version = buffer.saved_version().clone();
880 let mtime = buffer.saved_mtime();
881 buffer.did_save(version, mtime, cx);
882 })
883 .ok();
884 }
885
886 Ok(())
887 })
888 }
889
890 fn save_as(
891 &mut self,
892 project: Entity<Project>,
893 path: ProjectPath,
894 _: &mut Window,
895 cx: &mut Context<Self>,
896 ) -> Task<Result<()>> {
897 let buffer = self
898 .buffer()
899 .read(cx)
900 .as_singleton()
901 .expect("cannot call save_as on an excerpt list");
902
903 let file_extension = path
904 .path
905 .extension()
906 .map(|a| a.to_string_lossy().to_string());
907 self.report_editor_event(
908 ReportEditorEvent::Saved { auto_saved: false },
909 file_extension,
910 cx,
911 );
912
913 project.update(cx, |project, cx| project.save_buffer_as(buffer, path, cx))
914 }
915
916 fn reload(
917 &mut self,
918 project: Entity<Project>,
919 window: &mut Window,
920 cx: &mut Context<Self>,
921 ) -> Task<Result<()>> {
922 let buffer = self.buffer().clone();
923 let buffers = self.buffer.read(cx).all_buffers();
924 let reload_buffers =
925 project.update(cx, |project, cx| project.reload_buffers(buffers, true, cx));
926 cx.spawn_in(window, async move |this, cx| {
927 let transaction = reload_buffers.log_err().await;
928 this.update(cx, |editor, cx| {
929 editor.request_autoscroll(Autoscroll::fit(), cx)
930 })?;
931 buffer
932 .update(cx, |buffer, cx| {
933 if let Some(transaction) = transaction
934 && !buffer.is_singleton()
935 {
936 buffer.push_transaction(&transaction.0, cx);
937 }
938 })
939 .ok();
940 Ok(())
941 })
942 }
943
944 fn as_searchable(&self, handle: &Entity<Self>) -> Option<Box<dyn SearchableItemHandle>> {
945 Some(Box::new(handle.clone()))
946 }
947
948 fn pixel_position_of_cursor(&self, _: &App) -> Option<gpui::Point<Pixels>> {
949 self.pixel_position_of_newest_cursor
950 }
951
952 fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation {
953 if self.show_breadcrumbs {
954 ToolbarItemLocation::PrimaryLeft
955 } else {
956 ToolbarItemLocation::Hidden
957 }
958 }
959
960 fn breadcrumbs(&self, variant: &Theme, cx: &App) -> Option<Vec<BreadcrumbText>> {
961 let cursor = self.selections.newest_anchor().head();
962 let multibuffer = &self.buffer().read(cx);
963 let (buffer_id, symbols) =
964 multibuffer.symbols_containing(cursor, Some(variant.syntax()), cx)?;
965 let buffer = multibuffer.buffer(buffer_id)?;
966
967 let buffer = buffer.read(cx);
968 let text = self.breadcrumb_header.clone().unwrap_or_else(|| {
969 buffer
970 .snapshot()
971 .resolve_file_path(
972 cx,
973 self.project
974 .as_ref()
975 .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
976 .unwrap_or_default(),
977 )
978 .map(|path| path.to_string_lossy().to_string())
979 .unwrap_or_else(|| {
980 if multibuffer.is_singleton() {
981 multibuffer.title(cx).to_string()
982 } else {
983 "untitled".to_string()
984 }
985 })
986 });
987
988 let settings = ThemeSettings::get_global(cx);
989
990 let mut breadcrumbs = vec![BreadcrumbText {
991 text,
992 highlights: None,
993 font: Some(settings.buffer_font.clone()),
994 }];
995
996 breadcrumbs.extend(symbols.into_iter().map(|symbol| BreadcrumbText {
997 text: symbol.text,
998 highlights: Some(symbol.highlight_ranges),
999 font: Some(settings.buffer_font.clone()),
1000 }));
1001 Some(breadcrumbs)
1002 }
1003
1004 fn added_to_workspace(
1005 &mut self,
1006 workspace: &mut Workspace,
1007 _window: &mut Window,
1008 cx: &mut Context<Self>,
1009 ) {
1010 self.workspace = Some((workspace.weak_handle(), workspace.database_id()));
1011 if let Some(workspace) = &workspace.weak_handle().upgrade() {
1012 cx.subscribe(workspace, |editor, _, event: &workspace::Event, _cx| {
1013 if let workspace::Event::ModalOpened = event {
1014 editor.mouse_context_menu.take();
1015 editor.inline_blame_popover.take();
1016 }
1017 })
1018 .detach();
1019 }
1020 }
1021
1022 fn to_item_events(event: &EditorEvent, mut f: impl FnMut(ItemEvent)) {
1023 match event {
1024 EditorEvent::Closed => f(ItemEvent::CloseItem),
1025
1026 EditorEvent::Saved | EditorEvent::TitleChanged => {
1027 f(ItemEvent::UpdateTab);
1028 f(ItemEvent::UpdateBreadcrumbs);
1029 }
1030
1031 EditorEvent::Reparsed(_) => {
1032 f(ItemEvent::UpdateBreadcrumbs);
1033 }
1034
1035 EditorEvent::SelectionsChanged { local } if *local => {
1036 f(ItemEvent::UpdateBreadcrumbs);
1037 }
1038
1039 EditorEvent::BreadcrumbsChanged => {
1040 f(ItemEvent::UpdateBreadcrumbs);
1041 }
1042
1043 EditorEvent::DirtyChanged => {
1044 f(ItemEvent::UpdateTab);
1045 }
1046
1047 EditorEvent::BufferEdited => {
1048 f(ItemEvent::Edit);
1049 f(ItemEvent::UpdateBreadcrumbs);
1050 }
1051
1052 EditorEvent::ExcerptsAdded { .. } | EditorEvent::ExcerptsRemoved { .. } => {
1053 f(ItemEvent::Edit);
1054 }
1055
1056 _ => {}
1057 }
1058 }
1059
1060 fn preserve_preview(&self, cx: &App) -> bool {
1061 self.buffer.read(cx).preserve_preview(cx)
1062 }
1063}
1064
1065impl SerializableItem for Editor {
1066 fn serialized_item_kind() -> &'static str {
1067 "Editor"
1068 }
1069
1070 fn cleanup(
1071 workspace_id: WorkspaceId,
1072 alive_items: Vec<ItemId>,
1073 _window: &mut Window,
1074 cx: &mut App,
1075 ) -> Task<Result<()>> {
1076 workspace::delete_unloaded_items(alive_items, workspace_id, "editors", &DB, cx)
1077 }
1078
1079 fn deserialize(
1080 project: Entity<Project>,
1081 workspace: WeakEntity<Workspace>,
1082 workspace_id: workspace::WorkspaceId,
1083 item_id: ItemId,
1084 window: &mut Window,
1085 cx: &mut App,
1086 ) -> Task<Result<Entity<Self>>> {
1087 let serialized_editor = match DB
1088 .get_serialized_editor(item_id, workspace_id)
1089 .context("Failed to query editor state")
1090 {
1091 Ok(Some(serialized_editor)) => {
1092 if ProjectSettings::get_global(cx)
1093 .session
1094 .restore_unsaved_buffers
1095 {
1096 serialized_editor
1097 } else {
1098 SerializedEditor {
1099 abs_path: serialized_editor.abs_path,
1100 contents: None,
1101 language: None,
1102 mtime: None,
1103 }
1104 }
1105 }
1106 Ok(None) => {
1107 return Task::ready(Err(anyhow!("No path or contents found for buffer")));
1108 }
1109 Err(error) => {
1110 return Task::ready(Err(error));
1111 }
1112 };
1113
1114 match serialized_editor {
1115 SerializedEditor {
1116 abs_path: None,
1117 contents: Some(contents),
1118 language,
1119 ..
1120 } => window.spawn(cx, {
1121 let project = project.clone();
1122 async move |cx| {
1123 let language_registry =
1124 project.read_with(cx, |project, _| project.languages().clone())?;
1125
1126 let language = if let Some(language_name) = language {
1127 // We don't fail here, because we'd rather not set the language if the name changed
1128 // than fail to restore the buffer.
1129 language_registry
1130 .language_for_name(&language_name)
1131 .await
1132 .ok()
1133 } else {
1134 None
1135 };
1136
1137 // First create the empty buffer
1138 let buffer = project
1139 .update(cx, |project, cx| project.create_buffer(cx))?
1140 .await?;
1141
1142 // Then set the text so that the dirty bit is set correctly
1143 buffer.update(cx, |buffer, cx| {
1144 buffer.set_language_registry(language_registry);
1145 if let Some(language) = language {
1146 buffer.set_language(Some(language), cx);
1147 }
1148 buffer.set_text(contents, cx);
1149 if let Some(entry) = buffer.peek_undo_stack() {
1150 buffer.forget_transaction(entry.transaction_id());
1151 }
1152 })?;
1153
1154 cx.update(|window, cx| {
1155 cx.new(|cx| {
1156 let mut editor = Editor::for_buffer(buffer, Some(project), window, cx);
1157
1158 editor.read_metadata_from_db(item_id, workspace_id, window, cx);
1159 editor
1160 })
1161 })
1162 }
1163 }),
1164 SerializedEditor {
1165 abs_path: Some(abs_path),
1166 contents,
1167 mtime,
1168 ..
1169 } => {
1170 let opened_buffer = project.update(cx, |project, cx| {
1171 let (worktree, path) = project.find_worktree(&abs_path, cx)?;
1172 let project_path = ProjectPath {
1173 worktree_id: worktree.read(cx).id(),
1174 path: path.into(),
1175 };
1176 Some(project.open_path(project_path, cx))
1177 });
1178
1179 match opened_buffer {
1180 Some(opened_buffer) => {
1181 window.spawn(cx, async move |cx| {
1182 let (_, buffer) = opened_buffer.await?;
1183
1184 // This is a bit wasteful: we're loading the whole buffer from
1185 // disk and then overwrite the content.
1186 // But for now, it keeps the implementation of the content serialization
1187 // simple, because we don't have to persist all of the metadata that we get
1188 // by loading the file (git diff base, ...).
1189 if let Some(buffer_text) = contents {
1190 buffer.update(cx, |buffer, cx| {
1191 // If we did restore an mtime, we want to store it on the buffer
1192 // so that the next edit will mark the buffer as dirty/conflicted.
1193 if mtime.is_some() {
1194 buffer.did_reload(
1195 buffer.version(),
1196 buffer.line_ending(),
1197 mtime,
1198 cx,
1199 );
1200 }
1201 buffer.set_text(buffer_text, cx);
1202 if let Some(entry) = buffer.peek_undo_stack() {
1203 buffer.forget_transaction(entry.transaction_id());
1204 }
1205 })?;
1206 }
1207
1208 cx.update(|window, cx| {
1209 cx.new(|cx| {
1210 let mut editor =
1211 Editor::for_buffer(buffer, Some(project), window, cx);
1212
1213 editor.read_metadata_from_db(item_id, workspace_id, window, cx);
1214 editor
1215 })
1216 })
1217 })
1218 }
1219 None => {
1220 let open_by_abs_path = workspace.update(cx, |workspace, cx| {
1221 workspace.open_abs_path(
1222 abs_path.clone(),
1223 OpenOptions {
1224 visible: Some(OpenVisible::None),
1225 ..Default::default()
1226 },
1227 window,
1228 cx,
1229 )
1230 });
1231 window.spawn(cx, async move |cx| {
1232 let editor = open_by_abs_path?.await?.downcast::<Editor>().with_context(|| format!("Failed to downcast to Editor after opening abs path {abs_path:?}"))?;
1233 editor.update_in(cx, |editor, window, cx| {
1234 editor.read_metadata_from_db(item_id, workspace_id, window, cx);
1235 })?;
1236 Ok(editor)
1237 })
1238 }
1239 }
1240 }
1241 SerializedEditor {
1242 abs_path: None,
1243 contents: None,
1244 ..
1245 } => window.spawn(cx, async move |cx| {
1246 let buffer = project
1247 .update(cx, |project, cx| project.create_buffer(cx))?
1248 .await?;
1249
1250 cx.update(|window, cx| {
1251 cx.new(|cx| {
1252 let mut editor = Editor::for_buffer(buffer, Some(project), window, cx);
1253
1254 editor.read_metadata_from_db(item_id, workspace_id, window, cx);
1255 editor
1256 })
1257 })
1258 }),
1259 }
1260 }
1261
1262 fn serialize(
1263 &mut self,
1264 workspace: &mut Workspace,
1265 item_id: ItemId,
1266 closing: bool,
1267 window: &mut Window,
1268 cx: &mut Context<Self>,
1269 ) -> Option<Task<Result<()>>> {
1270 if self.mode.is_minimap() {
1271 return None;
1272 }
1273 let mut serialize_dirty_buffers = self.serialize_dirty_buffers;
1274
1275 let project = self.project.clone()?;
1276 if project.read(cx).visible_worktrees(cx).next().is_none() {
1277 // If we don't have a worktree, we don't serialize, because
1278 // projects without worktrees aren't deserialized.
1279 serialize_dirty_buffers = false;
1280 }
1281
1282 if closing && !serialize_dirty_buffers {
1283 return None;
1284 }
1285
1286 let workspace_id = workspace.database_id()?;
1287
1288 let buffer = self.buffer().read(cx).as_singleton()?;
1289
1290 let abs_path = buffer.read(cx).file().and_then(|file| {
1291 let worktree_id = file.worktree_id(cx);
1292 project
1293 .read(cx)
1294 .worktree_for_id(worktree_id, cx)
1295 .and_then(|worktree| worktree.read(cx).absolutize(file.path()).ok())
1296 .or_else(|| {
1297 let full_path = file.full_path(cx);
1298 let project_path = project.read(cx).find_project_path(&full_path, cx)?;
1299 project.read(cx).absolute_path(&project_path, cx)
1300 })
1301 });
1302
1303 let is_dirty = buffer.read(cx).is_dirty();
1304 let mtime = buffer.read(cx).saved_mtime();
1305
1306 let snapshot = buffer.read(cx).snapshot();
1307
1308 Some(cx.spawn_in(window, async move |_this, cx| {
1309 cx.background_spawn(async move {
1310 let (contents, language) = if serialize_dirty_buffers && is_dirty {
1311 let contents = snapshot.text();
1312 let language = snapshot.language().map(|lang| lang.name().to_string());
1313 (Some(contents), language)
1314 } else {
1315 (None, None)
1316 };
1317
1318 let editor = SerializedEditor {
1319 abs_path,
1320 contents,
1321 language,
1322 mtime,
1323 };
1324 log::debug!("Serializing editor {item_id:?} in workspace {workspace_id:?}");
1325 DB.save_serialized_editor(item_id, workspace_id, editor)
1326 .await
1327 .context("failed to save serialized editor")
1328 })
1329 .await
1330 .context("failed to save contents of buffer")?;
1331
1332 Ok(())
1333 }))
1334 }
1335
1336 fn should_serialize(&self, event: &Self::Event) -> bool {
1337 matches!(
1338 event,
1339 EditorEvent::Saved | EditorEvent::DirtyChanged | EditorEvent::BufferEdited
1340 )
1341 }
1342}
1343
1344#[derive(Debug, Default)]
1345struct EditorRestorationData {
1346 entries: HashMap<PathBuf, RestorationData>,
1347}
1348
1349#[derive(Default, Debug)]
1350pub struct RestorationData {
1351 pub scroll_position: (BufferRow, gpui::Point<f32>),
1352 pub folds: Vec<Range<Point>>,
1353 pub selections: Vec<Range<Point>>,
1354}
1355
1356impl ProjectItem for Editor {
1357 type Item = Buffer;
1358
1359 fn project_item_kind() -> Option<ProjectItemKind> {
1360 Some(ProjectItemKind("Editor"))
1361 }
1362
1363 fn for_project_item(
1364 project: Entity<Project>,
1365 pane: Option<&Pane>,
1366 buffer: Entity<Buffer>,
1367 window: &mut Window,
1368 cx: &mut Context<Self>,
1369 ) -> Self {
1370 let mut editor = Self::for_buffer(buffer.clone(), Some(project), window, cx);
1371 if let Some((excerpt_id, buffer_id, snapshot)) =
1372 editor.buffer().read(cx).snapshot(cx).as_singleton()
1373 && WorkspaceSettings::get(None, cx).restore_on_file_reopen
1374 && let Some(restoration_data) = Self::project_item_kind()
1375 .and_then(|kind| pane.as_ref()?.project_item_restoration_data.get(&kind))
1376 .and_then(|data| data.downcast_ref::<EditorRestorationData>())
1377 .and_then(|data| {
1378 let file = project::File::from_dyn(buffer.read(cx).file())?;
1379 data.entries.get(&file.abs_path(cx))
1380 })
1381 {
1382 editor.fold_ranges(
1383 clip_ranges(&restoration_data.folds, snapshot),
1384 false,
1385 window,
1386 cx,
1387 );
1388 if !restoration_data.selections.is_empty() {
1389 editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
1390 s.select_ranges(clip_ranges(&restoration_data.selections, snapshot));
1391 });
1392 }
1393 let (top_row, offset) = restoration_data.scroll_position;
1394 let anchor = Anchor::in_buffer(
1395 *excerpt_id,
1396 buffer_id,
1397 snapshot.anchor_before(Point::new(top_row, 0)),
1398 );
1399 editor.set_scroll_anchor(ScrollAnchor { anchor, offset }, window, cx);
1400 }
1401
1402 editor
1403 }
1404}
1405
1406fn clip_ranges<'a>(
1407 original: impl IntoIterator<Item = &'a Range<Point>> + 'a,
1408 snapshot: &'a BufferSnapshot,
1409) -> Vec<Range<Point>> {
1410 original
1411 .into_iter()
1412 .map(|range| {
1413 snapshot.clip_point(range.start, Bias::Left)
1414 ..snapshot.clip_point(range.end, Bias::Right)
1415 })
1416 .collect()
1417}
1418
1419impl EventEmitter<SearchEvent> for Editor {}
1420
1421impl Editor {
1422 pub fn update_restoration_data(
1423 &self,
1424 cx: &mut Context<Self>,
1425 write: impl for<'a> FnOnce(&'a mut RestorationData) + 'static,
1426 ) {
1427 if self.mode.is_minimap() || !WorkspaceSettings::get(None, cx).restore_on_file_reopen {
1428 return;
1429 }
1430
1431 let editor = cx.entity();
1432 cx.defer(move |cx| {
1433 editor.update(cx, |editor, cx| {
1434 let kind = Editor::project_item_kind()?;
1435 let pane = editor.workspace()?.read(cx).pane_for(&cx.entity())?;
1436 let buffer = editor.buffer().read(cx).as_singleton()?;
1437 let file_abs_path = project::File::from_dyn(buffer.read(cx).file())?.abs_path(cx);
1438 pane.update(cx, |pane, _| {
1439 let data = pane
1440 .project_item_restoration_data
1441 .entry(kind)
1442 .or_insert_with(|| Box::new(EditorRestorationData::default()) as Box<_>);
1443 let data = match data.downcast_mut::<EditorRestorationData>() {
1444 Some(data) => data,
1445 None => {
1446 *data = Box::new(EditorRestorationData::default());
1447 data.downcast_mut::<EditorRestorationData>()
1448 .expect("just written the type downcasted to")
1449 }
1450 };
1451
1452 let data = data.entries.entry(file_abs_path).or_default();
1453 write(data);
1454 Some(())
1455 })
1456 });
1457 });
1458 }
1459}
1460
1461pub(crate) enum BufferSearchHighlights {}
1462impl SearchableItem for Editor {
1463 type Match = Range<Anchor>;
1464
1465 fn get_matches(&self, _window: &mut Window, _: &mut App) -> Vec<Range<Anchor>> {
1466 self.background_highlights
1467 .get(&HighlightKey::Type(TypeId::of::<BufferSearchHighlights>()))
1468 .map_or(Vec::new(), |(_color, ranges)| {
1469 ranges.iter().cloned().collect()
1470 })
1471 }
1472
1473 fn clear_matches(&mut self, _: &mut Window, cx: &mut Context<Self>) {
1474 if self
1475 .clear_background_highlights::<BufferSearchHighlights>(cx)
1476 .is_some()
1477 {
1478 cx.emit(SearchEvent::MatchesInvalidated);
1479 }
1480 }
1481
1482 fn update_matches(
1483 &mut self,
1484 matches: &[Range<Anchor>],
1485 _: &mut Window,
1486 cx: &mut Context<Self>,
1487 ) {
1488 let existing_range = self
1489 .background_highlights
1490 .get(&HighlightKey::Type(TypeId::of::<BufferSearchHighlights>()))
1491 .map(|(_, range)| range.as_ref());
1492 let updated = existing_range != Some(matches);
1493 self.highlight_background::<BufferSearchHighlights>(
1494 matches,
1495 |theme| theme.colors().search_match_background,
1496 cx,
1497 );
1498 if updated {
1499 cx.emit(SearchEvent::MatchesInvalidated);
1500 }
1501 }
1502
1503 fn has_filtered_search_ranges(&mut self) -> bool {
1504 self.has_background_highlights::<SearchWithinRange>()
1505 }
1506
1507 fn toggle_filtered_search_ranges(
1508 &mut self,
1509 enabled: bool,
1510 _: &mut Window,
1511 cx: &mut Context<Self>,
1512 ) {
1513 if self.has_filtered_search_ranges() {
1514 self.previous_search_ranges = self
1515 .clear_background_highlights::<SearchWithinRange>(cx)
1516 .map(|(_, ranges)| ranges)
1517 }
1518
1519 if !enabled {
1520 return;
1521 }
1522
1523 let ranges = self.selections.disjoint_anchor_ranges().collect::<Vec<_>>();
1524 if ranges.iter().any(|s| s.start != s.end) {
1525 self.set_search_within_ranges(&ranges, cx);
1526 } else if let Some(previous_search_ranges) = self.previous_search_ranges.take() {
1527 self.set_search_within_ranges(&previous_search_ranges, cx)
1528 }
1529 }
1530
1531 fn supported_options(&self) -> SearchOptions {
1532 if self.in_project_search {
1533 SearchOptions {
1534 case: true,
1535 word: true,
1536 regex: true,
1537 replacement: false,
1538 selection: false,
1539 find_in_results: true,
1540 }
1541 } else {
1542 SearchOptions {
1543 case: true,
1544 word: true,
1545 regex: true,
1546 replacement: true,
1547 selection: true,
1548 find_in_results: false,
1549 }
1550 }
1551 }
1552
1553 fn query_suggestion(&mut self, window: &mut Window, cx: &mut Context<Self>) -> String {
1554 let setting = EditorSettings::get_global(cx).seed_search_query_from_cursor;
1555 let snapshot = &self.snapshot(window, cx).buffer_snapshot;
1556 let selection = self.selections.newest_adjusted(cx);
1557
1558 match setting {
1559 SeedQuerySetting::Never => String::new(),
1560 SeedQuerySetting::Selection | SeedQuerySetting::Always if !selection.is_empty() => {
1561 let text: String = snapshot
1562 .text_for_range(selection.start..selection.end)
1563 .collect();
1564 if text.contains('\n') {
1565 String::new()
1566 } else {
1567 text
1568 }
1569 }
1570 SeedQuerySetting::Selection => String::new(),
1571 SeedQuerySetting::Always => {
1572 let (range, kind) = snapshot.surrounding_word(selection.start, true);
1573 if kind == Some(CharKind::Word) {
1574 let text: String = snapshot.text_for_range(range).collect();
1575 if !text.trim().is_empty() {
1576 return text;
1577 }
1578 }
1579 String::new()
1580 }
1581 }
1582 }
1583
1584 fn activate_match(
1585 &mut self,
1586 index: usize,
1587 matches: &[Range<Anchor>],
1588 window: &mut Window,
1589 cx: &mut Context<Self>,
1590 ) {
1591 self.unfold_ranges(&[matches[index].clone()], false, true, cx);
1592 let range = self.range_for_match(&matches[index]);
1593 self.change_selections(Default::default(), window, cx, |s| {
1594 s.select_ranges([range]);
1595 })
1596 }
1597
1598 fn select_matches(
1599 &mut self,
1600 matches: &[Self::Match],
1601 window: &mut Window,
1602 cx: &mut Context<Self>,
1603 ) {
1604 self.unfold_ranges(matches, false, false, cx);
1605 self.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
1606 s.select_ranges(matches.iter().cloned())
1607 });
1608 }
1609 fn replace(
1610 &mut self,
1611 identifier: &Self::Match,
1612 query: &SearchQuery,
1613 window: &mut Window,
1614 cx: &mut Context<Self>,
1615 ) {
1616 let text = self.buffer.read(cx);
1617 let text = text.snapshot(cx);
1618 let text = text.text_for_range(identifier.clone()).collect::<Vec<_>>();
1619 let text: Cow<_> = if text.len() == 1 {
1620 text.first().cloned().unwrap().into()
1621 } else {
1622 let joined_chunks = text.join("");
1623 joined_chunks.into()
1624 };
1625
1626 if let Some(replacement) = query.replacement_for(&text) {
1627 self.transact(window, cx, |this, _, cx| {
1628 this.edit([(identifier.clone(), Arc::from(&*replacement))], cx);
1629 });
1630 }
1631 }
1632 fn replace_all(
1633 &mut self,
1634 matches: &mut dyn Iterator<Item = &Self::Match>,
1635 query: &SearchQuery,
1636 window: &mut Window,
1637 cx: &mut Context<Self>,
1638 ) {
1639 let text = self.buffer.read(cx);
1640 let text = text.snapshot(cx);
1641 let mut edits = vec![];
1642
1643 for m in matches {
1644 let text = text.text_for_range(m.clone()).collect::<Vec<_>>();
1645
1646 let text: Cow<_> = if text.len() == 1 {
1647 text.first().cloned().unwrap().into()
1648 } else {
1649 let joined_chunks = text.join("");
1650 joined_chunks.into()
1651 };
1652
1653 if let Some(replacement) = query.replacement_for(&text) {
1654 edits.push((m.clone(), Arc::from(&*replacement)));
1655 }
1656 }
1657
1658 if !edits.is_empty() {
1659 self.transact(window, cx, |this, _, cx| {
1660 this.edit(edits, cx);
1661 });
1662 }
1663 }
1664 fn match_index_for_direction(
1665 &mut self,
1666 matches: &[Range<Anchor>],
1667 current_index: usize,
1668 direction: Direction,
1669 count: usize,
1670 _: &mut Window,
1671 cx: &mut Context<Self>,
1672 ) -> usize {
1673 let buffer = self.buffer().read(cx).snapshot(cx);
1674 let current_index_position = if self.selections.disjoint_anchors().len() == 1 {
1675 self.selections.newest_anchor().head()
1676 } else {
1677 matches[current_index].start
1678 };
1679
1680 let mut count = count % matches.len();
1681 if count == 0 {
1682 return current_index;
1683 }
1684 match direction {
1685 Direction::Next => {
1686 if matches[current_index]
1687 .start
1688 .cmp(¤t_index_position, &buffer)
1689 .is_gt()
1690 {
1691 count -= 1
1692 }
1693
1694 (current_index + count) % matches.len()
1695 }
1696 Direction::Prev => {
1697 if matches[current_index]
1698 .end
1699 .cmp(¤t_index_position, &buffer)
1700 .is_lt()
1701 {
1702 count -= 1;
1703 }
1704
1705 if current_index >= count {
1706 current_index - count
1707 } else {
1708 matches.len() - (count - current_index)
1709 }
1710 }
1711 }
1712 }
1713
1714 fn find_matches(
1715 &mut self,
1716 query: Arc<project::search::SearchQuery>,
1717 _: &mut Window,
1718 cx: &mut Context<Self>,
1719 ) -> Task<Vec<Range<Anchor>>> {
1720 let buffer = self.buffer().read(cx).snapshot(cx);
1721 let search_within_ranges = self
1722 .background_highlights
1723 .get(&HighlightKey::Type(TypeId::of::<SearchWithinRange>()))
1724 .map_or(vec![], |(_color, ranges)| {
1725 ranges.iter().cloned().collect::<Vec<_>>()
1726 });
1727
1728 cx.background_spawn(async move {
1729 let mut ranges = Vec::new();
1730
1731 let search_within_ranges = if search_within_ranges.is_empty() {
1732 vec![buffer.anchor_before(0)..buffer.anchor_after(buffer.len())]
1733 } else {
1734 search_within_ranges
1735 };
1736
1737 for range in search_within_ranges {
1738 for (search_buffer, search_range, excerpt_id, deleted_hunk_anchor) in
1739 buffer.range_to_buffer_ranges_with_deleted_hunks(range)
1740 {
1741 ranges.extend(
1742 query
1743 .search(search_buffer, Some(search_range.clone()))
1744 .await
1745 .into_iter()
1746 .map(|match_range| {
1747 if let Some(deleted_hunk_anchor) = deleted_hunk_anchor {
1748 let start = search_buffer
1749 .anchor_after(search_range.start + match_range.start);
1750 let end = search_buffer
1751 .anchor_before(search_range.start + match_range.end);
1752 Anchor {
1753 diff_base_anchor: Some(start),
1754 ..deleted_hunk_anchor
1755 }..Anchor {
1756 diff_base_anchor: Some(end),
1757 ..deleted_hunk_anchor
1758 }
1759 } else {
1760 let start = search_buffer
1761 .anchor_after(search_range.start + match_range.start);
1762 let end = search_buffer
1763 .anchor_before(search_range.start + match_range.end);
1764 Anchor::range_in_buffer(
1765 excerpt_id,
1766 search_buffer.remote_id(),
1767 start..end,
1768 )
1769 }
1770 }),
1771 );
1772 }
1773 }
1774
1775 ranges
1776 })
1777 }
1778
1779 fn active_match_index(
1780 &mut self,
1781 direction: Direction,
1782 matches: &[Range<Anchor>],
1783 _: &mut Window,
1784 cx: &mut Context<Self>,
1785 ) -> Option<usize> {
1786 active_match_index(
1787 direction,
1788 matches,
1789 &self.selections.newest_anchor().head(),
1790 &self.buffer().read(cx).snapshot(cx),
1791 )
1792 }
1793
1794 fn search_bar_visibility_changed(&mut self, _: bool, _: &mut Window, _: &mut Context<Self>) {
1795 self.expect_bounds_change = self.last_bounds;
1796 }
1797}
1798
1799pub fn active_match_index(
1800 direction: Direction,
1801 ranges: &[Range<Anchor>],
1802 cursor: &Anchor,
1803 buffer: &MultiBufferSnapshot,
1804) -> Option<usize> {
1805 if ranges.is_empty() {
1806 None
1807 } else {
1808 let r = ranges.binary_search_by(|probe| {
1809 if probe.end.cmp(cursor, buffer).is_lt() {
1810 Ordering::Less
1811 } else if probe.start.cmp(cursor, buffer).is_gt() {
1812 Ordering::Greater
1813 } else {
1814 Ordering::Equal
1815 }
1816 });
1817 match direction {
1818 Direction::Prev => match r {
1819 Ok(i) => Some(i),
1820 Err(i) => Some(i.saturating_sub(1)),
1821 },
1822 Direction::Next => match r {
1823 Ok(i) | Err(i) => Some(cmp::min(i, ranges.len() - 1)),
1824 },
1825 }
1826 }
1827}
1828
1829pub fn entry_label_color(selected: bool) -> Color {
1830 if selected {
1831 Color::Default
1832 } else {
1833 Color::Muted
1834 }
1835}
1836
1837pub fn entry_diagnostic_aware_icon_name_and_color(
1838 diagnostic_severity: Option<DiagnosticSeverity>,
1839) -> Option<(IconName, Color)> {
1840 match diagnostic_severity {
1841 Some(DiagnosticSeverity::ERROR) => Some((IconName::Close, Color::Error)),
1842 Some(DiagnosticSeverity::WARNING) => Some((IconName::Triangle, Color::Warning)),
1843 _ => None,
1844 }
1845}
1846
1847pub fn entry_diagnostic_aware_icon_decoration_and_color(
1848 diagnostic_severity: Option<DiagnosticSeverity>,
1849) -> Option<(IconDecorationKind, Color)> {
1850 match diagnostic_severity {
1851 Some(DiagnosticSeverity::ERROR) => Some((IconDecorationKind::X, Color::Error)),
1852 Some(DiagnosticSeverity::WARNING) => Some((IconDecorationKind::Triangle, Color::Warning)),
1853 _ => None,
1854 }
1855}
1856
1857pub fn entry_git_aware_label_color(git_status: GitSummary, ignored: bool, selected: bool) -> Color {
1858 let tracked = git_status.index + git_status.worktree;
1859 if ignored {
1860 Color::Ignored
1861 } else if git_status.conflict > 0 {
1862 Color::Conflict
1863 } else if tracked.modified > 0 {
1864 Color::Modified
1865 } else if tracked.added > 0 || git_status.untracked > 0 {
1866 Color::Created
1867 } else {
1868 entry_label_color(selected)
1869 }
1870}
1871
1872fn path_for_buffer<'a>(
1873 buffer: &Entity<MultiBuffer>,
1874 height: usize,
1875 include_filename: bool,
1876 cx: &'a App,
1877) -> Option<Cow<'a, Path>> {
1878 let file = buffer.read(cx).as_singleton()?.read(cx).file()?;
1879 path_for_file(file.as_ref(), height, include_filename, cx)
1880}
1881
1882fn path_for_file<'a>(
1883 file: &'a dyn language::File,
1884 mut height: usize,
1885 include_filename: bool,
1886 cx: &'a App,
1887) -> Option<Cow<'a, Path>> {
1888 // Ensure we always render at least the filename.
1889 height += 1;
1890
1891 let mut prefix = file.path().as_ref();
1892 while height > 0 {
1893 if let Some(parent) = prefix.parent() {
1894 prefix = parent;
1895 height -= 1;
1896 } else {
1897 break;
1898 }
1899 }
1900
1901 // Here we could have just always used `full_path`, but that is very
1902 // allocation-heavy and so we try to use a `Cow<Path>` if we haven't
1903 // traversed all the way up to the worktree's root.
1904 if height > 0 {
1905 let full_path = file.full_path(cx);
1906 if include_filename {
1907 Some(full_path.into())
1908 } else {
1909 Some(full_path.parent()?.to_path_buf().into())
1910 }
1911 } else {
1912 let mut path = file.path().strip_prefix(prefix).ok()?;
1913 if !include_filename {
1914 path = path.parent()?;
1915 }
1916 Some(path.into())
1917 }
1918}
1919
1920#[cfg(test)]
1921mod tests {
1922 use crate::editor_tests::init_test;
1923 use fs::Fs;
1924
1925 use super::*;
1926 use fs::MTime;
1927 use gpui::{App, VisualTestContext};
1928 use language::{LanguageMatcher, TestFile};
1929 use project::FakeFs;
1930 use std::path::{Path, PathBuf};
1931 use util::path;
1932
1933 #[gpui::test]
1934 fn test_path_for_file(cx: &mut App) {
1935 let file = TestFile {
1936 path: Path::new("").into(),
1937 root_name: String::new(),
1938 local_root: None,
1939 };
1940 assert_eq!(path_for_file(&file, 0, false, cx), None);
1941 }
1942
1943 async fn deserialize_editor(
1944 item_id: ItemId,
1945 workspace_id: WorkspaceId,
1946 workspace: Entity<Workspace>,
1947 project: Entity<Project>,
1948 cx: &mut VisualTestContext,
1949 ) -> Entity<Editor> {
1950 workspace
1951 .update_in(cx, |workspace, window, cx| {
1952 let pane = workspace.active_pane();
1953 pane.update(cx, |_, cx| {
1954 Editor::deserialize(
1955 project.clone(),
1956 workspace.weak_handle(),
1957 workspace_id,
1958 item_id,
1959 window,
1960 cx,
1961 )
1962 })
1963 })
1964 .await
1965 .unwrap()
1966 }
1967
1968 fn rust_language() -> Arc<language::Language> {
1969 Arc::new(language::Language::new(
1970 language::LanguageConfig {
1971 name: "Rust".into(),
1972 matcher: LanguageMatcher {
1973 path_suffixes: vec!["rs".to_string()],
1974 ..Default::default()
1975 },
1976 ..Default::default()
1977 },
1978 Some(tree_sitter_rust::LANGUAGE.into()),
1979 ))
1980 }
1981
1982 #[gpui::test]
1983 async fn test_deserialize(cx: &mut gpui::TestAppContext) {
1984 init_test(cx, |_| {});
1985
1986 let fs = FakeFs::new(cx.executor());
1987 fs.insert_file(path!("/file.rs"), Default::default()).await;
1988
1989 // Test case 1: Deserialize with path and contents
1990 {
1991 let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
1992 let (workspace, cx) =
1993 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
1994 let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
1995 let item_id = 1234 as ItemId;
1996 let mtime = fs
1997 .metadata(Path::new(path!("/file.rs")))
1998 .await
1999 .unwrap()
2000 .unwrap()
2001 .mtime;
2002
2003 let serialized_editor = SerializedEditor {
2004 abs_path: Some(PathBuf::from(path!("/file.rs"))),
2005 contents: Some("fn main() {}".to_string()),
2006 language: Some("Rust".to_string()),
2007 mtime: Some(mtime),
2008 };
2009
2010 DB.save_serialized_editor(item_id, workspace_id, serialized_editor.clone())
2011 .await
2012 .unwrap();
2013
2014 let deserialized =
2015 deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2016
2017 deserialized.update(cx, |editor, cx| {
2018 assert_eq!(editor.text(cx), "fn main() {}");
2019 assert!(editor.is_dirty(cx));
2020 assert!(!editor.has_conflict(cx));
2021 let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2022 assert!(buffer.file().is_some());
2023 });
2024 }
2025
2026 // Test case 2: Deserialize with only path
2027 {
2028 let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2029 let (workspace, cx) =
2030 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
2031
2032 let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2033
2034 let item_id = 5678 as ItemId;
2035 let serialized_editor = SerializedEditor {
2036 abs_path: Some(PathBuf::from(path!("/file.rs"))),
2037 contents: None,
2038 language: None,
2039 mtime: None,
2040 };
2041
2042 DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2043 .await
2044 .unwrap();
2045
2046 let deserialized =
2047 deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2048
2049 deserialized.update(cx, |editor, cx| {
2050 assert_eq!(editor.text(cx), ""); // The file should be empty as per our initial setup
2051 assert!(!editor.is_dirty(cx));
2052 assert!(!editor.has_conflict(cx));
2053
2054 let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2055 assert!(buffer.file().is_some());
2056 });
2057 }
2058
2059 // Test case 3: Deserialize with no path (untitled buffer, with content and language)
2060 {
2061 let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2062 // Add Rust to the language, so that we can restore the language of the buffer
2063 project.read_with(cx, |project, _| project.languages().add(rust_language()));
2064
2065 let (workspace, cx) =
2066 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
2067
2068 let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2069
2070 let item_id = 9012 as ItemId;
2071 let serialized_editor = SerializedEditor {
2072 abs_path: None,
2073 contents: Some("hello".to_string()),
2074 language: Some("Rust".to_string()),
2075 mtime: None,
2076 };
2077
2078 DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2079 .await
2080 .unwrap();
2081
2082 let deserialized =
2083 deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2084
2085 deserialized.update(cx, |editor, cx| {
2086 assert_eq!(editor.text(cx), "hello");
2087 assert!(editor.is_dirty(cx)); // The editor should be dirty for an untitled buffer
2088
2089 let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2090 assert_eq!(
2091 buffer.language().map(|lang| lang.name()),
2092 Some("Rust".into())
2093 ); // Language should be set to Rust
2094 assert!(buffer.file().is_none()); // The buffer should not have an associated file
2095 });
2096 }
2097
2098 // Test case 4: Deserialize with path, content, and old mtime
2099 {
2100 let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2101 let (workspace, cx) =
2102 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
2103
2104 let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2105
2106 let item_id = 9345 as ItemId;
2107 let old_mtime = MTime::from_seconds_and_nanos(0, 50);
2108 let serialized_editor = SerializedEditor {
2109 abs_path: Some(PathBuf::from(path!("/file.rs"))),
2110 contents: Some("fn main() {}".to_string()),
2111 language: Some("Rust".to_string()),
2112 mtime: Some(old_mtime),
2113 };
2114
2115 DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2116 .await
2117 .unwrap();
2118
2119 let deserialized =
2120 deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2121
2122 deserialized.update(cx, |editor, cx| {
2123 assert_eq!(editor.text(cx), "fn main() {}");
2124 assert!(editor.has_conflict(cx)); // The editor should have a conflict
2125 });
2126 }
2127
2128 // Test case 5: Deserialize with no path, no content, no language, and no old mtime (new, empty, unsaved buffer)
2129 {
2130 let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2131 let (workspace, cx) =
2132 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
2133
2134 let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2135
2136 let item_id = 10000 as ItemId;
2137 let serialized_editor = SerializedEditor {
2138 abs_path: None,
2139 contents: None,
2140 language: None,
2141 mtime: None,
2142 };
2143
2144 DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2145 .await
2146 .unwrap();
2147
2148 let deserialized =
2149 deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2150
2151 deserialized.update(cx, |editor, cx| {
2152 assert_eq!(editor.text(cx), "");
2153 assert!(!editor.is_dirty(cx));
2154 assert!(!editor.has_conflict(cx));
2155
2156 let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2157 assert!(buffer.file().is_none());
2158 });
2159 }
2160 }
2161}