1use crate::{
2 display_map::ToDisplayPoint, link_go_to_definition::hide_link_definition,
3 movement::surrounding_word, persistence::DB, scroll::ScrollAnchor, Anchor, Autoscroll, Editor,
4 Event, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, NavigationData, ToPoint as _,
5};
6use anyhow::{anyhow, Context, Result};
7use collections::HashSet;
8use futures::future::try_join_all;
9use gpui::{
10 elements::*, geometry::vector::vec2f, AppContext, AsyncAppContext, Entity, ModelHandle,
11 Subscription, Task, View, ViewContext, ViewHandle, WeakViewHandle,
12};
13use language::{
14 proto::serialize_anchor as serialize_text_anchor, Bias, Buffer, OffsetRangeExt, Point,
15 SelectionGoal,
16};
17use project::{FormatTrigger, Item as _, Project, ProjectPath};
18use rpc::proto::{self, update_view};
19use settings::Settings;
20use smallvec::SmallVec;
21use std::{
22 borrow::Cow,
23 cmp::{self, Ordering},
24 fmt::Write,
25 iter,
26 ops::Range,
27 path::{Path, PathBuf},
28};
29use text::Selection;
30use util::{ResultExt, TryFutureExt};
31use workspace::item::{BreadcrumbText, FollowableItemHandle};
32use workspace::{
33 item::{FollowableItem, Item, ItemEvent, ItemHandle, ProjectItem},
34 searchable::{Direction, SearchEvent, SearchableItem, SearchableItemHandle},
35 ItemId, ItemNavHistory, Pane, StatusItemView, ToolbarItemLocation, ViewId, Workspace,
36 WorkspaceId,
37};
38
39pub const MAX_TAB_TITLE_LEN: usize = 24;
40
41impl FollowableItem for Editor {
42 fn remote_id(&self) -> Option<ViewId> {
43 self.remote_id
44 }
45
46 fn from_state_proto(
47 pane: ViewHandle<workspace::Pane>,
48 project: ModelHandle<Project>,
49 remote_id: ViewId,
50 state: &mut Option<proto::view::Variant>,
51 cx: &mut AppContext,
52 ) -> Option<Task<Result<ViewHandle<Self>>>> {
53 let Some(proto::view::Variant::Editor(_)) = state else { return None };
54 let Some(proto::view::Variant::Editor(state)) = state.take() else { unreachable!() };
55
56 let client = project.read(cx).client();
57 let replica_id = project.read(cx).replica_id();
58 let buffer_ids = state
59 .excerpts
60 .iter()
61 .map(|excerpt| excerpt.buffer_id)
62 .collect::<HashSet<_>>();
63 let buffers = project.update(cx, |project, cx| {
64 buffer_ids
65 .iter()
66 .map(|id| project.open_buffer_by_id(*id, cx))
67 .collect::<Vec<_>>()
68 });
69
70 let pane = pane.downgrade();
71 Some(cx.spawn(|mut cx| async move {
72 let mut buffers = futures::future::try_join_all(buffers).await?;
73 let editor = pane.read_with(&cx, |pane, cx| {
74 let mut editors = pane.items_of_type::<Self>();
75 editors.find(|editor| {
76 let ids_match = editor.remote_id(&client, cx) == Some(remote_id);
77 let singleton_buffer_matches = state.singleton
78 && buffers.first()
79 == editor.read(cx).buffer.read(cx).as_singleton().as_ref();
80 ids_match || singleton_buffer_matches
81 })
82 })?;
83
84 let editor = if let Some(editor) = editor {
85 editor
86 } else {
87 pane.update(&mut cx, |_, cx| {
88 let multibuffer = cx.add_model(|cx| {
89 let mut multibuffer;
90 if state.singleton && buffers.len() == 1 {
91 multibuffer = MultiBuffer::singleton(buffers.pop().unwrap(), cx)
92 } else {
93 multibuffer = MultiBuffer::new(replica_id);
94 let mut excerpts = state.excerpts.into_iter().peekable();
95 while let Some(excerpt) = excerpts.peek() {
96 let buffer_id = excerpt.buffer_id;
97 let buffer_excerpts = iter::from_fn(|| {
98 let excerpt = excerpts.peek()?;
99 (excerpt.buffer_id == buffer_id)
100 .then(|| excerpts.next().unwrap())
101 });
102 let buffer =
103 buffers.iter().find(|b| b.read(cx).remote_id() == buffer_id);
104 if let Some(buffer) = buffer {
105 multibuffer.push_excerpts(
106 buffer.clone(),
107 buffer_excerpts.filter_map(deserialize_excerpt_range),
108 cx,
109 );
110 }
111 }
112 };
113
114 if let Some(title) = &state.title {
115 multibuffer = multibuffer.with_title(title.clone())
116 }
117
118 multibuffer
119 });
120
121 cx.add_view(|cx| {
122 let mut editor =
123 Editor::for_multibuffer(multibuffer, Some(project.clone()), cx);
124 editor.remote_id = Some(remote_id);
125 editor
126 })
127 })?
128 };
129
130 update_editor_from_message(
131 editor.downgrade(),
132 project,
133 proto::update_view::Editor {
134 selections: state.selections,
135 pending_selection: state.pending_selection,
136 scroll_top_anchor: state.scroll_top_anchor,
137 scroll_x: state.scroll_x,
138 scroll_y: state.scroll_y,
139 ..Default::default()
140 },
141 &mut cx,
142 )
143 .await?;
144
145 Ok(editor)
146 }))
147 }
148
149 fn set_leader_replica_id(
150 &mut self,
151 leader_replica_id: Option<u16>,
152 cx: &mut ViewContext<Self>,
153 ) {
154 self.leader_replica_id = leader_replica_id;
155 if self.leader_replica_id.is_some() {
156 self.buffer.update(cx, |buffer, cx| {
157 buffer.remove_active_selections(cx);
158 });
159 } else {
160 self.buffer.update(cx, |buffer, cx| {
161 if self.focused {
162 buffer.set_active_selections(
163 &self.selections.disjoint_anchors(),
164 self.selections.line_mode,
165 self.cursor_shape,
166 cx,
167 );
168 }
169 });
170 }
171 cx.notify();
172 }
173
174 fn to_state_proto(&self, cx: &AppContext) -> Option<proto::view::Variant> {
175 let buffer = self.buffer.read(cx);
176 let scroll_anchor = self.scroll_manager.anchor();
177 let excerpts = buffer
178 .read(cx)
179 .excerpts()
180 .map(|(id, buffer, range)| proto::Excerpt {
181 id: id.to_proto(),
182 buffer_id: buffer.remote_id(),
183 context_start: Some(serialize_text_anchor(&range.context.start)),
184 context_end: Some(serialize_text_anchor(&range.context.end)),
185 primary_start: range
186 .primary
187 .as_ref()
188 .map(|range| serialize_text_anchor(&range.start)),
189 primary_end: range
190 .primary
191 .as_ref()
192 .map(|range| serialize_text_anchor(&range.end)),
193 })
194 .collect();
195
196 Some(proto::view::Variant::Editor(proto::view::Editor {
197 singleton: buffer.is_singleton(),
198 title: (!buffer.is_singleton()).then(|| buffer.title(cx).into()),
199 excerpts,
200 scroll_top_anchor: Some(serialize_anchor(&scroll_anchor.top_anchor)),
201 scroll_x: scroll_anchor.offset.x(),
202 scroll_y: scroll_anchor.offset.y(),
203 selections: self
204 .selections
205 .disjoint_anchors()
206 .iter()
207 .map(serialize_selection)
208 .collect(),
209 pending_selection: self
210 .selections
211 .pending_anchor()
212 .as_ref()
213 .map(serialize_selection),
214 }))
215 }
216
217 fn add_event_to_update_proto(
218 &self,
219 event: &Self::Event,
220 update: &mut Option<proto::update_view::Variant>,
221 cx: &AppContext,
222 ) -> bool {
223 let update =
224 update.get_or_insert_with(|| proto::update_view::Variant::Editor(Default::default()));
225
226 match update {
227 proto::update_view::Variant::Editor(update) => match event {
228 Event::ExcerptsAdded {
229 buffer,
230 predecessor,
231 excerpts,
232 } => {
233 let buffer_id = buffer.read(cx).remote_id();
234 let mut excerpts = excerpts.iter();
235 if let Some((id, range)) = excerpts.next() {
236 update.inserted_excerpts.push(proto::ExcerptInsertion {
237 previous_excerpt_id: Some(predecessor.to_proto()),
238 excerpt: serialize_excerpt(buffer_id, id, range),
239 });
240 update.inserted_excerpts.extend(excerpts.map(|(id, range)| {
241 proto::ExcerptInsertion {
242 previous_excerpt_id: None,
243 excerpt: serialize_excerpt(buffer_id, id, range),
244 }
245 }))
246 }
247 true
248 }
249 Event::ExcerptsRemoved { ids } => {
250 update
251 .deleted_excerpts
252 .extend(ids.iter().map(ExcerptId::to_proto));
253 true
254 }
255 Event::ScrollPositionChanged { .. } => {
256 let scroll_anchor = self.scroll_manager.anchor();
257 update.scroll_top_anchor = Some(serialize_anchor(&scroll_anchor.top_anchor));
258 update.scroll_x = scroll_anchor.offset.x();
259 update.scroll_y = scroll_anchor.offset.y();
260 true
261 }
262 Event::SelectionsChanged { .. } => {
263 update.selections = self
264 .selections
265 .disjoint_anchors()
266 .iter()
267 .map(serialize_selection)
268 .collect();
269 update.pending_selection = self
270 .selections
271 .pending_anchor()
272 .as_ref()
273 .map(serialize_selection);
274 true
275 }
276 _ => false,
277 },
278 }
279 }
280
281 fn apply_update_proto(
282 &mut self,
283 project: &ModelHandle<Project>,
284 message: update_view::Variant,
285 cx: &mut ViewContext<Self>,
286 ) -> Task<Result<()>> {
287 let update_view::Variant::Editor(message) = message;
288 let project = project.clone();
289 cx.spawn(|this, mut cx| async move {
290 update_editor_from_message(this, project, message, &mut cx).await
291 })
292 }
293
294 fn should_unfollow_on_event(event: &Self::Event, _: &AppContext) -> bool {
295 match event {
296 Event::Edited => true,
297 Event::SelectionsChanged { local } => *local,
298 Event::ScrollPositionChanged { local } => *local,
299 _ => false,
300 }
301 }
302}
303
304async fn update_editor_from_message(
305 this: WeakViewHandle<Editor>,
306 project: ModelHandle<Project>,
307 message: proto::update_view::Editor,
308 cx: &mut AsyncAppContext,
309) -> Result<()> {
310 // Open all of the buffers of which excerpts were added to the editor.
311 let inserted_excerpt_buffer_ids = message
312 .inserted_excerpts
313 .iter()
314 .filter_map(|insertion| Some(insertion.excerpt.as_ref()?.buffer_id))
315 .collect::<HashSet<_>>();
316 let inserted_excerpt_buffers = project.update(cx, |project, cx| {
317 inserted_excerpt_buffer_ids
318 .into_iter()
319 .map(|id| project.open_buffer_by_id(id, cx))
320 .collect::<Vec<_>>()
321 });
322 let _inserted_excerpt_buffers = try_join_all(inserted_excerpt_buffers).await?;
323
324 // Update the editor's excerpts.
325 this.update(cx, |editor, cx| {
326 editor.buffer.update(cx, |multibuffer, cx| {
327 let mut removed_excerpt_ids = message
328 .deleted_excerpts
329 .into_iter()
330 .map(ExcerptId::from_proto)
331 .collect::<Vec<_>>();
332 removed_excerpt_ids.sort_by({
333 let multibuffer = multibuffer.read(cx);
334 move |a, b| a.cmp(&b, &multibuffer)
335 });
336
337 let mut insertions = message.inserted_excerpts.into_iter().peekable();
338 while let Some(insertion) = insertions.next() {
339 let Some(excerpt) = insertion.excerpt else { continue };
340 let Some(previous_excerpt_id) = insertion.previous_excerpt_id else { continue };
341 let buffer_id = excerpt.buffer_id;
342 let Some(buffer) = project.read(cx).buffer_for_id(buffer_id, cx) else { continue };
343
344 let adjacent_excerpts = iter::from_fn(|| {
345 let insertion = insertions.peek()?;
346 if insertion.previous_excerpt_id.is_none()
347 && insertion.excerpt.as_ref()?.buffer_id == buffer_id
348 {
349 insertions.next()?.excerpt
350 } else {
351 None
352 }
353 });
354
355 multibuffer.insert_excerpts_with_ids_after(
356 ExcerptId::from_proto(previous_excerpt_id),
357 buffer,
358 [excerpt]
359 .into_iter()
360 .chain(adjacent_excerpts)
361 .filter_map(|excerpt| {
362 Some((
363 ExcerptId::from_proto(excerpt.id),
364 deserialize_excerpt_range(excerpt)?,
365 ))
366 }),
367 cx,
368 );
369 }
370
371 multibuffer.remove_excerpts(removed_excerpt_ids, cx);
372 });
373 })?;
374
375 // Deserialize the editor state.
376 let (selections, pending_selection, scroll_top_anchor) = this.update(cx, |editor, cx| {
377 let buffer = editor.buffer.read(cx).read(cx);
378 let selections = message
379 .selections
380 .into_iter()
381 .filter_map(|selection| deserialize_selection(&buffer, selection))
382 .collect::<Vec<_>>();
383 let pending_selection = message
384 .pending_selection
385 .and_then(|selection| deserialize_selection(&buffer, selection));
386 let scroll_top_anchor = message
387 .scroll_top_anchor
388 .and_then(|anchor| deserialize_anchor(&buffer, anchor));
389 anyhow::Ok((selections, pending_selection, scroll_top_anchor))
390 })??;
391
392 // Wait until the buffer has received all of the operations referenced by
393 // the editor's new state.
394 this.update(cx, |editor, cx| {
395 editor.buffer.update(cx, |buffer, cx| {
396 buffer.wait_for_anchors(
397 selections
398 .iter()
399 .chain(pending_selection.as_ref())
400 .flat_map(|selection| [selection.start, selection.end])
401 .chain(scroll_top_anchor),
402 cx,
403 )
404 })
405 })?
406 .await?;
407
408 // Update the editor's state.
409 this.update(cx, |editor, cx| {
410 if !selections.is_empty() || pending_selection.is_some() {
411 editor.set_selections_from_remote(selections, pending_selection, cx);
412 editor.request_autoscroll_remotely(Autoscroll::newest(), cx);
413 } else if let Some(scroll_top_anchor) = scroll_top_anchor {
414 editor.set_scroll_anchor_remote(
415 ScrollAnchor {
416 top_anchor: scroll_top_anchor,
417 offset: vec2f(message.scroll_x, message.scroll_y),
418 },
419 cx,
420 );
421 }
422 })?;
423 Ok(())
424}
425
426fn serialize_excerpt(
427 buffer_id: u64,
428 id: &ExcerptId,
429 range: &ExcerptRange<language::Anchor>,
430) -> Option<proto::Excerpt> {
431 Some(proto::Excerpt {
432 id: id.to_proto(),
433 buffer_id,
434 context_start: Some(serialize_text_anchor(&range.context.start)),
435 context_end: Some(serialize_text_anchor(&range.context.end)),
436 primary_start: range
437 .primary
438 .as_ref()
439 .map(|r| serialize_text_anchor(&r.start)),
440 primary_end: range
441 .primary
442 .as_ref()
443 .map(|r| serialize_text_anchor(&r.end)),
444 })
445}
446
447fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
448 proto::Selection {
449 id: selection.id as u64,
450 start: Some(serialize_anchor(&selection.start)),
451 end: Some(serialize_anchor(&selection.end)),
452 reversed: selection.reversed,
453 }
454}
455
456fn serialize_anchor(anchor: &Anchor) -> proto::EditorAnchor {
457 proto::EditorAnchor {
458 excerpt_id: anchor.excerpt_id.to_proto(),
459 anchor: Some(serialize_text_anchor(&anchor.text_anchor)),
460 }
461}
462
463fn deserialize_excerpt_range(excerpt: proto::Excerpt) -> Option<ExcerptRange<language::Anchor>> {
464 let context = {
465 let start = language::proto::deserialize_anchor(excerpt.context_start?)?;
466 let end = language::proto::deserialize_anchor(excerpt.context_end?)?;
467 start..end
468 };
469 let primary = excerpt
470 .primary_start
471 .zip(excerpt.primary_end)
472 .and_then(|(start, end)| {
473 let start = language::proto::deserialize_anchor(start)?;
474 let end = language::proto::deserialize_anchor(end)?;
475 Some(start..end)
476 });
477 Some(ExcerptRange { context, primary })
478}
479
480fn deserialize_selection(
481 buffer: &MultiBufferSnapshot,
482 selection: proto::Selection,
483) -> Option<Selection<Anchor>> {
484 Some(Selection {
485 id: selection.id as usize,
486 start: deserialize_anchor(buffer, selection.start?)?,
487 end: deserialize_anchor(buffer, selection.end?)?,
488 reversed: selection.reversed,
489 goal: SelectionGoal::None,
490 })
491}
492
493fn deserialize_anchor(buffer: &MultiBufferSnapshot, anchor: proto::EditorAnchor) -> Option<Anchor> {
494 let excerpt_id = ExcerptId::from_proto(anchor.excerpt_id);
495 Some(Anchor {
496 excerpt_id,
497 text_anchor: language::proto::deserialize_anchor(anchor.anchor?)?,
498 buffer_id: buffer.buffer_id_for_excerpt(excerpt_id),
499 })
500}
501
502impl Item for Editor {
503 fn navigate(&mut self, data: Box<dyn std::any::Any>, cx: &mut ViewContext<Self>) -> bool {
504 if let Ok(data) = data.downcast::<NavigationData>() {
505 let newest_selection = self.selections.newest::<Point>(cx);
506 let buffer = self.buffer.read(cx).read(cx);
507 let offset = if buffer.can_resolve(&data.cursor_anchor) {
508 data.cursor_anchor.to_point(&buffer)
509 } else {
510 buffer.clip_point(data.cursor_position, Bias::Left)
511 };
512
513 let mut scroll_anchor = data.scroll_anchor;
514 if !buffer.can_resolve(&scroll_anchor.top_anchor) {
515 scroll_anchor.top_anchor = buffer.anchor_before(
516 buffer.clip_point(Point::new(data.scroll_top_row, 0), Bias::Left),
517 );
518 }
519
520 drop(buffer);
521
522 if newest_selection.head() == offset {
523 false
524 } else {
525 let nav_history = self.nav_history.take();
526 self.set_scroll_anchor(scroll_anchor, cx);
527 self.change_selections(Some(Autoscroll::fit()), cx, |s| {
528 s.select_ranges([offset..offset])
529 });
530 self.nav_history = nav_history;
531 true
532 }
533 } else {
534 false
535 }
536 }
537
538 fn tab_tooltip_text(&self, cx: &AppContext) -> Option<Cow<str>> {
539 let file_path = self
540 .buffer()
541 .read(cx)
542 .as_singleton()?
543 .read(cx)
544 .file()
545 .and_then(|f| f.as_local())?
546 .abs_path(cx);
547
548 let file_path = util::paths::compact(&file_path)
549 .to_string_lossy()
550 .to_string();
551
552 Some(file_path.into())
553 }
554
555 fn tab_description<'a>(&'a self, detail: usize, cx: &'a AppContext) -> Option<Cow<str>> {
556 match path_for_buffer(&self.buffer, detail, true, cx)? {
557 Cow::Borrowed(path) => Some(path.to_string_lossy()),
558 Cow::Owned(path) => Some(path.to_string_lossy().to_string().into()),
559 }
560 }
561
562 fn tab_content<T: View>(
563 &self,
564 detail: Option<usize>,
565 style: &theme::Tab,
566 cx: &AppContext,
567 ) -> AnyElement<T> {
568 Flex::row()
569 .with_child(Label::new(self.title(cx).to_string(), style.label.clone()).aligned())
570 .with_children(detail.and_then(|detail| {
571 let path = path_for_buffer(&self.buffer, detail, false, cx)?;
572 let description = path.to_string_lossy();
573 Some(
574 Label::new(
575 util::truncate_and_trailoff(&description, MAX_TAB_TITLE_LEN),
576 style.description.text.clone(),
577 )
578 .contained()
579 .with_style(style.description.container)
580 .aligned(),
581 )
582 }))
583 .into_any()
584 }
585
586 fn for_each_project_item(&self, cx: &AppContext, f: &mut dyn FnMut(usize, &dyn project::Item)) {
587 self.buffer
588 .read(cx)
589 .for_each_buffer(|buffer| f(buffer.id(), buffer.read(cx)));
590 }
591
592 fn is_singleton(&self, cx: &AppContext) -> bool {
593 self.buffer.read(cx).is_singleton()
594 }
595
596 fn clone_on_split(&self, _workspace_id: WorkspaceId, cx: &mut ViewContext<Self>) -> Option<Self>
597 where
598 Self: Sized,
599 {
600 Some(self.clone(cx))
601 }
602
603 fn set_nav_history(&mut self, history: ItemNavHistory, _: &mut ViewContext<Self>) {
604 self.nav_history = Some(history);
605 }
606
607 fn deactivated(&mut self, cx: &mut ViewContext<Self>) {
608 let selection = self.selections.newest_anchor();
609 self.push_to_nav_history(selection.head(), None, cx);
610 }
611
612 fn workspace_deactivated(&mut self, cx: &mut ViewContext<Self>) {
613 hide_link_definition(self, cx);
614 self.link_go_to_definition_state.last_mouse_location = None;
615 }
616
617 fn is_dirty(&self, cx: &AppContext) -> bool {
618 self.buffer().read(cx).read(cx).is_dirty()
619 }
620
621 fn has_conflict(&self, cx: &AppContext) -> bool {
622 self.buffer().read(cx).read(cx).has_conflict()
623 }
624
625 fn can_save(&self, cx: &AppContext) -> bool {
626 let buffer = &self.buffer().read(cx);
627 if let Some(buffer) = buffer.as_singleton() {
628 buffer.read(cx).project_path(cx).is_some()
629 } else {
630 true
631 }
632 }
633
634 fn save(
635 &mut self,
636 project: ModelHandle<Project>,
637 cx: &mut ViewContext<Self>,
638 ) -> Task<Result<()>> {
639 self.report_editor_event("save", cx);
640 let format = self.perform_format(project.clone(), FormatTrigger::Save, cx);
641 let buffers = self.buffer().clone().read(cx).all_buffers();
642 cx.spawn(|_, mut cx| async move {
643 format.await?;
644
645 if buffers.len() == 1 {
646 project
647 .update(&mut cx, |project, cx| project.save_buffers(buffers, cx))
648 .await?;
649 } else {
650 // For multi-buffers, only save those ones that contain changes. For clean buffers
651 // we simulate saving by calling `Buffer::did_save`, so that language servers or
652 // other downstream listeners of save events get notified.
653 let (dirty_buffers, clean_buffers) = buffers.into_iter().partition(|buffer| {
654 buffer.read_with(&cx, |buffer, _| buffer.is_dirty() || buffer.has_conflict())
655 });
656
657 project
658 .update(&mut cx, |project, cx| {
659 project.save_buffers(dirty_buffers, cx)
660 })
661 .await?;
662 for buffer in clean_buffers {
663 buffer.update(&mut cx, |buffer, cx| {
664 let version = buffer.saved_version().clone();
665 let fingerprint = buffer.saved_version_fingerprint();
666 let mtime = buffer.saved_mtime();
667 buffer.did_save(version, fingerprint, mtime, cx);
668 });
669 }
670 }
671
672 Ok(())
673 })
674 }
675
676 fn save_as(
677 &mut self,
678 project: ModelHandle<Project>,
679 abs_path: PathBuf,
680 cx: &mut ViewContext<Self>,
681 ) -> Task<Result<()>> {
682 let buffer = self
683 .buffer()
684 .read(cx)
685 .as_singleton()
686 .expect("cannot call save_as on an excerpt list");
687
688 project.update(cx, |project, cx| {
689 project.save_buffer_as(buffer, abs_path, cx)
690 })
691 }
692
693 fn reload(
694 &mut self,
695 project: ModelHandle<Project>,
696 cx: &mut ViewContext<Self>,
697 ) -> Task<Result<()>> {
698 let buffer = self.buffer().clone();
699 let buffers = self.buffer.read(cx).all_buffers();
700 let reload_buffers =
701 project.update(cx, |project, cx| project.reload_buffers(buffers, true, cx));
702 cx.spawn(|this, mut cx| async move {
703 let transaction = reload_buffers.log_err().await;
704 this.update(&mut cx, |editor, cx| {
705 editor.request_autoscroll(Autoscroll::fit(), cx)
706 })?;
707 buffer.update(&mut cx, |buffer, _| {
708 if let Some(transaction) = transaction {
709 if !buffer.is_singleton() {
710 buffer.push_transaction(&transaction.0);
711 }
712 }
713 });
714 Ok(())
715 })
716 }
717
718 fn git_diff_recalc(
719 &mut self,
720 _project: ModelHandle<Project>,
721 cx: &mut ViewContext<Self>,
722 ) -> Task<Result<()>> {
723 self.buffer().update(cx, |multibuffer, cx| {
724 multibuffer.git_diff_recalc(cx);
725 });
726 Task::ready(Ok(()))
727 }
728
729 fn to_item_events(event: &Self::Event) -> SmallVec<[ItemEvent; 2]> {
730 let mut result = SmallVec::new();
731 match event {
732 Event::Closed => result.push(ItemEvent::CloseItem),
733 Event::Saved | Event::TitleChanged => {
734 result.push(ItemEvent::UpdateTab);
735 result.push(ItemEvent::UpdateBreadcrumbs);
736 }
737 Event::Reparsed => {
738 result.push(ItemEvent::UpdateBreadcrumbs);
739 }
740 Event::SelectionsChanged { local } if *local => {
741 result.push(ItemEvent::UpdateBreadcrumbs);
742 }
743 Event::DirtyChanged => {
744 result.push(ItemEvent::UpdateTab);
745 }
746 Event::BufferEdited => {
747 result.push(ItemEvent::Edit);
748 result.push(ItemEvent::UpdateBreadcrumbs);
749 }
750 _ => {}
751 }
752 result
753 }
754
755 fn as_searchable(&self, handle: &ViewHandle<Self>) -> Option<Box<dyn SearchableItemHandle>> {
756 Some(Box::new(handle.clone()))
757 }
758
759 fn breadcrumb_location(&self) -> ToolbarItemLocation {
760 ToolbarItemLocation::PrimaryLeft { flex: None }
761 }
762
763 fn breadcrumbs(&self, theme: &theme::Theme, cx: &AppContext) -> Option<Vec<BreadcrumbText>> {
764 let cursor = self.selections.newest_anchor().head();
765 let multibuffer = &self.buffer().read(cx);
766 let (buffer_id, symbols) =
767 multibuffer.symbols_containing(cursor, Some(&theme.editor.syntax), cx)?;
768 let buffer = multibuffer.buffer(buffer_id)?;
769
770 let buffer = buffer.read(cx);
771 let filename = buffer
772 .snapshot()
773 .resolve_file_path(
774 cx,
775 self.project
776 .as_ref()
777 .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
778 .unwrap_or_default(),
779 )
780 .map(|path| path.to_string_lossy().to_string())
781 .unwrap_or_else(|| "untitled".to_string());
782
783 let mut breadcrumbs = vec![BreadcrumbText {
784 text: filename,
785 highlights: None,
786 }];
787 breadcrumbs.extend(symbols.into_iter().map(|symbol| BreadcrumbText {
788 text: symbol.text,
789 highlights: Some(symbol.highlight_ranges),
790 }));
791 Some(breadcrumbs)
792 }
793
794 fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext<Self>) {
795 let workspace_id = workspace.database_id();
796 let item_id = cx.view_id();
797 self.workspace = Some((workspace.weak_handle(), workspace.database_id()));
798
799 fn serialize(
800 buffer: ModelHandle<Buffer>,
801 workspace_id: WorkspaceId,
802 item_id: ItemId,
803 cx: &mut AppContext,
804 ) {
805 if let Some(file) = buffer.read(cx).file().and_then(|file| file.as_local()) {
806 let path = file.abs_path(cx);
807
808 cx.background()
809 .spawn(async move {
810 DB.save_path(item_id, workspace_id, path.clone())
811 .await
812 .log_err()
813 })
814 .detach();
815 }
816 }
817
818 if let Some(buffer) = self.buffer().read(cx).as_singleton() {
819 serialize(buffer.clone(), workspace_id, item_id, cx);
820
821 cx.subscribe(&buffer, |this, buffer, event, cx| {
822 if let Some((_, workspace_id)) = this.workspace.as_ref() {
823 if let language::Event::FileHandleChanged = event {
824 serialize(buffer, *workspace_id, cx.view_id(), cx);
825 }
826 }
827 })
828 .detach();
829 }
830 }
831
832 fn serialized_item_kind() -> Option<&'static str> {
833 Some("Editor")
834 }
835
836 fn deserialize(
837 project: ModelHandle<Project>,
838 _workspace: WeakViewHandle<Workspace>,
839 workspace_id: workspace::WorkspaceId,
840 item_id: ItemId,
841 cx: &mut ViewContext<Pane>,
842 ) -> Task<Result<ViewHandle<Self>>> {
843 let project_item: Result<_> = project.update(cx, |project, cx| {
844 // Look up the path with this key associated, create a self with that path
845 let path = DB
846 .get_path(item_id, workspace_id)?
847 .context("No path stored for this editor")?;
848
849 let (worktree, path) = project
850 .find_local_worktree(&path, cx)
851 .with_context(|| format!("No worktree for path: {path:?}"))?;
852 let project_path = ProjectPath {
853 worktree_id: worktree.read(cx).id(),
854 path: path.into(),
855 };
856
857 Ok(project.open_path(project_path, cx))
858 });
859
860 project_item
861 .map(|project_item| {
862 cx.spawn(|pane, mut cx| async move {
863 let (_, project_item) = project_item.await?;
864 let buffer = project_item
865 .downcast::<Buffer>()
866 .context("Project item at stored path was not a buffer")?;
867 let pane = pane
868 .upgrade(&cx)
869 .ok_or_else(|| anyhow!("pane was dropped"))?;
870 Ok(cx.update(|cx| {
871 cx.add_view(&pane, |cx| {
872 let mut editor = Editor::for_buffer(buffer, Some(project), cx);
873 editor.read_scroll_position_from_db(item_id, workspace_id, cx);
874 editor
875 })
876 }))
877 })
878 })
879 .unwrap_or_else(|error| Task::ready(Err(error)))
880 }
881}
882
883impl ProjectItem for Editor {
884 type Item = Buffer;
885
886 fn for_project_item(
887 project: ModelHandle<Project>,
888 buffer: ModelHandle<Buffer>,
889 cx: &mut ViewContext<Self>,
890 ) -> Self {
891 Self::for_buffer(buffer, Some(project), cx)
892 }
893}
894
895enum BufferSearchHighlights {}
896impl SearchableItem for Editor {
897 type Match = Range<Anchor>;
898
899 fn to_search_event(event: &Self::Event) -> Option<SearchEvent> {
900 match event {
901 Event::BufferEdited => Some(SearchEvent::MatchesInvalidated),
902 Event::SelectionsChanged { .. } => Some(SearchEvent::ActiveMatchChanged),
903 _ => None,
904 }
905 }
906
907 fn clear_matches(&mut self, cx: &mut ViewContext<Self>) {
908 self.clear_background_highlights::<BufferSearchHighlights>(cx);
909 }
910
911 fn update_matches(&mut self, matches: Vec<Range<Anchor>>, cx: &mut ViewContext<Self>) {
912 self.highlight_background::<BufferSearchHighlights>(
913 matches,
914 |theme| theme.search.match_background,
915 cx,
916 );
917 }
918
919 fn query_suggestion(&mut self, cx: &mut ViewContext<Self>) -> String {
920 let display_map = self.snapshot(cx).display_snapshot;
921 let selection = self.selections.newest::<usize>(cx);
922 if selection.start == selection.end {
923 let point = selection.start.to_display_point(&display_map);
924 let range = surrounding_word(&display_map, point);
925 let range = range.start.to_offset(&display_map, Bias::Left)
926 ..range.end.to_offset(&display_map, Bias::Right);
927 let text: String = display_map.buffer_snapshot.text_for_range(range).collect();
928 if text.trim().is_empty() {
929 String::new()
930 } else {
931 text
932 }
933 } else {
934 display_map
935 .buffer_snapshot
936 .text_for_range(selection.start..selection.end)
937 .collect()
938 }
939 }
940
941 fn activate_match(
942 &mut self,
943 index: usize,
944 matches: Vec<Range<Anchor>>,
945 cx: &mut ViewContext<Self>,
946 ) {
947 self.unfold_ranges([matches[index].clone()], false, true, cx);
948 self.change_selections(Some(Autoscroll::fit()), cx, |s| {
949 s.select_ranges([matches[index].clone()])
950 });
951 }
952
953 fn match_index_for_direction(
954 &mut self,
955 matches: &Vec<Range<Anchor>>,
956 mut current_index: usize,
957 direction: Direction,
958 cx: &mut ViewContext<Self>,
959 ) -> usize {
960 let buffer = self.buffer().read(cx).snapshot(cx);
961 let cursor = self.selections.newest_anchor().head();
962 if matches[current_index].start.cmp(&cursor, &buffer).is_gt() {
963 if direction == Direction::Prev {
964 if current_index == 0 {
965 current_index = matches.len() - 1;
966 } else {
967 current_index -= 1;
968 }
969 }
970 } else if matches[current_index].end.cmp(&cursor, &buffer).is_lt() {
971 if direction == Direction::Next {
972 current_index = 0;
973 }
974 } else if direction == Direction::Prev {
975 if current_index == 0 {
976 current_index = matches.len() - 1;
977 } else {
978 current_index -= 1;
979 }
980 } else if direction == Direction::Next {
981 if current_index == matches.len() - 1 {
982 current_index = 0
983 } else {
984 current_index += 1;
985 }
986 };
987 current_index
988 }
989
990 fn find_matches(
991 &mut self,
992 query: project::search::SearchQuery,
993 cx: &mut ViewContext<Self>,
994 ) -> Task<Vec<Range<Anchor>>> {
995 let buffer = self.buffer().read(cx).snapshot(cx);
996 cx.background().spawn(async move {
997 let mut ranges = Vec::new();
998 if let Some((_, _, excerpt_buffer)) = buffer.as_singleton() {
999 ranges.extend(
1000 query
1001 .search(excerpt_buffer.as_rope())
1002 .await
1003 .into_iter()
1004 .map(|range| {
1005 buffer.anchor_after(range.start)..buffer.anchor_before(range.end)
1006 }),
1007 );
1008 } else {
1009 for excerpt in buffer.excerpt_boundaries_in_range(0..buffer.len()) {
1010 let excerpt_range = excerpt.range.context.to_offset(&excerpt.buffer);
1011 let rope = excerpt.buffer.as_rope().slice(excerpt_range.clone());
1012 ranges.extend(query.search(&rope).await.into_iter().map(|range| {
1013 let start = excerpt
1014 .buffer
1015 .anchor_after(excerpt_range.start + range.start);
1016 let end = excerpt
1017 .buffer
1018 .anchor_before(excerpt_range.start + range.end);
1019 buffer.anchor_in_excerpt(excerpt.id.clone(), start)
1020 ..buffer.anchor_in_excerpt(excerpt.id.clone(), end)
1021 }));
1022 }
1023 }
1024 ranges
1025 })
1026 }
1027
1028 fn active_match_index(
1029 &mut self,
1030 matches: Vec<Range<Anchor>>,
1031 cx: &mut ViewContext<Self>,
1032 ) -> Option<usize> {
1033 active_match_index(
1034 &matches,
1035 &self.selections.newest_anchor().head(),
1036 &self.buffer().read(cx).snapshot(cx),
1037 )
1038 }
1039}
1040
1041pub fn active_match_index(
1042 ranges: &[Range<Anchor>],
1043 cursor: &Anchor,
1044 buffer: &MultiBufferSnapshot,
1045) -> Option<usize> {
1046 if ranges.is_empty() {
1047 None
1048 } else {
1049 match ranges.binary_search_by(|probe| {
1050 if probe.end.cmp(cursor, &*buffer).is_lt() {
1051 Ordering::Less
1052 } else if probe.start.cmp(cursor, &*buffer).is_gt() {
1053 Ordering::Greater
1054 } else {
1055 Ordering::Equal
1056 }
1057 }) {
1058 Ok(i) | Err(i) => Some(cmp::min(i, ranges.len() - 1)),
1059 }
1060 }
1061}
1062
1063pub struct CursorPosition {
1064 position: Option<Point>,
1065 selected_count: usize,
1066 _observe_active_editor: Option<Subscription>,
1067}
1068
1069impl Default for CursorPosition {
1070 fn default() -> Self {
1071 Self::new()
1072 }
1073}
1074
1075impl CursorPosition {
1076 pub fn new() -> Self {
1077 Self {
1078 position: None,
1079 selected_count: 0,
1080 _observe_active_editor: None,
1081 }
1082 }
1083
1084 fn update_position(&mut self, editor: ViewHandle<Editor>, cx: &mut ViewContext<Self>) {
1085 let editor = editor.read(cx);
1086 let buffer = editor.buffer().read(cx).snapshot(cx);
1087
1088 self.selected_count = 0;
1089 let mut last_selection: Option<Selection<usize>> = None;
1090 for selection in editor.selections.all::<usize>(cx) {
1091 self.selected_count += selection.end - selection.start;
1092 if last_selection
1093 .as_ref()
1094 .map_or(true, |last_selection| selection.id > last_selection.id)
1095 {
1096 last_selection = Some(selection);
1097 }
1098 }
1099 self.position = last_selection.map(|s| s.head().to_point(&buffer));
1100
1101 cx.notify();
1102 }
1103}
1104
1105impl Entity for CursorPosition {
1106 type Event = ();
1107}
1108
1109impl View for CursorPosition {
1110 fn ui_name() -> &'static str {
1111 "CursorPosition"
1112 }
1113
1114 fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
1115 if let Some(position) = self.position {
1116 let theme = &cx.global::<Settings>().theme.workspace.status_bar;
1117 let mut text = format!("{},{}", position.row + 1, position.column + 1);
1118 if self.selected_count > 0 {
1119 write!(text, " ({} selected)", self.selected_count).unwrap();
1120 }
1121 Label::new(text, theme.cursor_position.clone()).into_any()
1122 } else {
1123 Empty::new().into_any()
1124 }
1125 }
1126}
1127
1128impl StatusItemView for CursorPosition {
1129 fn set_active_pane_item(
1130 &mut self,
1131 active_pane_item: Option<&dyn ItemHandle>,
1132 cx: &mut ViewContext<Self>,
1133 ) {
1134 if let Some(editor) = active_pane_item.and_then(|item| item.act_as::<Editor>(cx)) {
1135 self._observe_active_editor = Some(cx.observe(&editor, Self::update_position));
1136 self.update_position(editor, cx);
1137 } else {
1138 self.position = None;
1139 self._observe_active_editor = None;
1140 }
1141
1142 cx.notify();
1143 }
1144}
1145
1146fn path_for_buffer<'a>(
1147 buffer: &ModelHandle<MultiBuffer>,
1148 height: usize,
1149 include_filename: bool,
1150 cx: &'a AppContext,
1151) -> Option<Cow<'a, Path>> {
1152 let file = buffer.read(cx).as_singleton()?.read(cx).file()?;
1153 path_for_file(file.as_ref(), height, include_filename, cx)
1154}
1155
1156fn path_for_file<'a>(
1157 file: &'a dyn language::File,
1158 mut height: usize,
1159 include_filename: bool,
1160 cx: &'a AppContext,
1161) -> Option<Cow<'a, Path>> {
1162 // Ensure we always render at least the filename.
1163 height += 1;
1164
1165 let mut prefix = file.path().as_ref();
1166 while height > 0 {
1167 if let Some(parent) = prefix.parent() {
1168 prefix = parent;
1169 height -= 1;
1170 } else {
1171 break;
1172 }
1173 }
1174
1175 // Here we could have just always used `full_path`, but that is very
1176 // allocation-heavy and so we try to use a `Cow<Path>` if we haven't
1177 // traversed all the way up to the worktree's root.
1178 if height > 0 {
1179 let full_path = file.full_path(cx);
1180 if include_filename {
1181 Some(full_path.into())
1182 } else {
1183 Some(full_path.parent()?.to_path_buf().into())
1184 }
1185 } else {
1186 let mut path = file.path().strip_prefix(prefix).ok()?;
1187 if !include_filename {
1188 path = path.parent()?;
1189 }
1190 Some(path.into())
1191 }
1192}
1193
1194#[cfg(test)]
1195mod tests {
1196 use super::*;
1197 use gpui::AppContext;
1198 use std::{
1199 path::{Path, PathBuf},
1200 sync::Arc,
1201 time::SystemTime,
1202 };
1203
1204 #[gpui::test]
1205 fn test_path_for_file(cx: &mut AppContext) {
1206 let file = TestFile {
1207 path: Path::new("").into(),
1208 full_path: PathBuf::from(""),
1209 };
1210 assert_eq!(path_for_file(&file, 0, false, cx), None);
1211 }
1212
1213 struct TestFile {
1214 path: Arc<Path>,
1215 full_path: PathBuf,
1216 }
1217
1218 impl language::File for TestFile {
1219 fn path(&self) -> &Arc<Path> {
1220 &self.path
1221 }
1222
1223 fn full_path(&self, _: &gpui::AppContext) -> PathBuf {
1224 self.full_path.clone()
1225 }
1226
1227 fn as_local(&self) -> Option<&dyn language::LocalFile> {
1228 todo!()
1229 }
1230
1231 fn mtime(&self) -> SystemTime {
1232 todo!()
1233 }
1234
1235 fn file_name<'a>(&'a self, _: &'a gpui::AppContext) -> &'a std::ffi::OsStr {
1236 todo!()
1237 }
1238
1239 fn is_deleted(&self) -> bool {
1240 todo!()
1241 }
1242
1243 fn as_any(&self) -> &dyn std::any::Any {
1244 todo!()
1245 }
1246
1247 fn to_proto(&self) -> rpc::proto::File {
1248 todo!()
1249 }
1250 }
1251}