1use crate::{
2 display_map::ToDisplayPoint, link_go_to_definition::hide_link_definition,
3 movement::surrounding_word, Anchor, Autoscroll, Editor, Event, ExcerptId, MultiBuffer,
4 MultiBufferSnapshot, NavigationData, ToPoint as _, FORMAT_TIMEOUT,
5};
6use anyhow::{anyhow, Result};
7use futures::FutureExt;
8use gpui::{
9 elements::*, geometry::vector::vec2f, AppContext, Entity, ModelHandle, MutableAppContext,
10 RenderContext, Subscription, Task, View, ViewContext, ViewHandle,
11};
12use language::{Bias, Buffer, File as _, OffsetRangeExt, Point, SelectionGoal};
13use project::{File, FormatTrigger, Project, ProjectEntryId, ProjectPath};
14use rpc::proto::{self, update_view};
15use settings::Settings;
16use smallvec::SmallVec;
17use std::{
18 borrow::Cow,
19 cmp::{self, Ordering},
20 fmt::Write,
21 ops::Range,
22 path::{Path, PathBuf},
23};
24use text::Selection;
25use util::TryFutureExt;
26use workspace::{
27 searchable::{Direction, SearchEvent, SearchableItem, SearchableItemHandle},
28 FollowableItem, Item, ItemEvent, ItemHandle, ItemNavHistory, ProjectItem, StatusItemView,
29 ToolbarItemLocation,
30};
31
32pub const MAX_TAB_TITLE_LEN: usize = 24;
33
34impl FollowableItem for Editor {
35 fn from_state_proto(
36 pane: ViewHandle<workspace::Pane>,
37 project: ModelHandle<Project>,
38 state: &mut Option<proto::view::Variant>,
39 cx: &mut MutableAppContext,
40 ) -> Option<Task<Result<ViewHandle<Self>>>> {
41 let state = if matches!(state, Some(proto::view::Variant::Editor(_))) {
42 if let Some(proto::view::Variant::Editor(state)) = state.take() {
43 state
44 } else {
45 unreachable!()
46 }
47 } else {
48 return None;
49 };
50
51 let buffer = project.update(cx, |project, cx| {
52 project.open_buffer_by_id(state.buffer_id, cx)
53 });
54 Some(cx.spawn(|mut cx| async move {
55 let buffer = buffer.await?;
56 let editor = pane
57 .read_with(&cx, |pane, cx| {
58 pane.items_of_type::<Self>().find(|editor| {
59 editor.read(cx).buffer.read(cx).as_singleton().as_ref() == Some(&buffer)
60 })
61 })
62 .unwrap_or_else(|| {
63 pane.update(&mut cx, |_, cx| {
64 cx.add_view(|cx| Editor::for_buffer(buffer, Some(project), cx))
65 })
66 });
67 editor.update(&mut cx, |editor, cx| {
68 let excerpt_id;
69 let buffer_id;
70 {
71 let buffer = editor.buffer.read(cx).read(cx);
72 let singleton = buffer.as_singleton().unwrap();
73 excerpt_id = singleton.0.clone();
74 buffer_id = singleton.1;
75 }
76 let selections = state
77 .selections
78 .into_iter()
79 .map(|selection| {
80 deserialize_selection(&excerpt_id, buffer_id, selection)
81 .ok_or_else(|| anyhow!("invalid selection"))
82 })
83 .collect::<Result<Vec<_>>>()?;
84 if !selections.is_empty() {
85 editor.set_selections_from_remote(selections, cx);
86 }
87
88 if let Some(anchor) = state.scroll_top_anchor {
89 editor.set_scroll_top_anchor(
90 Anchor {
91 buffer_id: Some(state.buffer_id as usize),
92 excerpt_id,
93 text_anchor: language::proto::deserialize_anchor(anchor)
94 .ok_or_else(|| anyhow!("invalid scroll top"))?,
95 },
96 vec2f(state.scroll_x, state.scroll_y),
97 cx,
98 );
99 }
100
101 Ok::<_, anyhow::Error>(())
102 })?;
103 Ok(editor)
104 }))
105 }
106
107 fn set_leader_replica_id(
108 &mut self,
109 leader_replica_id: Option<u16>,
110 cx: &mut ViewContext<Self>,
111 ) {
112 self.leader_replica_id = leader_replica_id;
113 if self.leader_replica_id.is_some() {
114 self.buffer.update(cx, |buffer, cx| {
115 buffer.remove_active_selections(cx);
116 });
117 } else {
118 self.buffer.update(cx, |buffer, cx| {
119 if self.focused {
120 buffer.set_active_selections(
121 &self.selections.disjoint_anchors(),
122 self.selections.line_mode,
123 cx,
124 );
125 }
126 });
127 }
128 cx.notify();
129 }
130
131 fn to_state_proto(&self, cx: &AppContext) -> Option<proto::view::Variant> {
132 let buffer_id = self.buffer.read(cx).as_singleton()?.read(cx).remote_id();
133 Some(proto::view::Variant::Editor(proto::view::Editor {
134 buffer_id,
135 scroll_top_anchor: Some(language::proto::serialize_anchor(
136 &self.scroll_top_anchor.text_anchor,
137 )),
138 scroll_x: self.scroll_position.x(),
139 scroll_y: self.scroll_position.y(),
140 selections: self
141 .selections
142 .disjoint_anchors()
143 .iter()
144 .map(serialize_selection)
145 .collect(),
146 }))
147 }
148
149 fn add_event_to_update_proto(
150 &self,
151 event: &Self::Event,
152 update: &mut Option<proto::update_view::Variant>,
153 _: &AppContext,
154 ) -> bool {
155 let update =
156 update.get_or_insert_with(|| proto::update_view::Variant::Editor(Default::default()));
157
158 match update {
159 proto::update_view::Variant::Editor(update) => match event {
160 Event::ScrollPositionChanged { .. } => {
161 update.scroll_top_anchor = Some(language::proto::serialize_anchor(
162 &self.scroll_top_anchor.text_anchor,
163 ));
164 update.scroll_x = self.scroll_position.x();
165 update.scroll_y = self.scroll_position.y();
166 true
167 }
168 Event::SelectionsChanged { .. } => {
169 update.selections = self
170 .selections
171 .disjoint_anchors()
172 .iter()
173 .chain(self.selections.pending_anchor().as_ref())
174 .map(serialize_selection)
175 .collect();
176 true
177 }
178 _ => false,
179 },
180 }
181 }
182
183 fn apply_update_proto(
184 &mut self,
185 message: update_view::Variant,
186 cx: &mut ViewContext<Self>,
187 ) -> Result<()> {
188 match message {
189 update_view::Variant::Editor(message) => {
190 let buffer = self.buffer.read(cx);
191 let buffer = buffer.read(cx);
192 let (excerpt_id, buffer_id, _) = buffer.as_singleton().unwrap();
193 let excerpt_id = excerpt_id.clone();
194 drop(buffer);
195
196 let selections = message
197 .selections
198 .into_iter()
199 .filter_map(|selection| {
200 deserialize_selection(&excerpt_id, buffer_id, selection)
201 })
202 .collect::<Vec<_>>();
203
204 if !selections.is_empty() {
205 self.set_selections_from_remote(selections, cx);
206 self.request_autoscroll_remotely(Autoscroll::Newest, cx);
207 } else if let Some(anchor) = message.scroll_top_anchor {
208 self.set_scroll_top_anchor(
209 Anchor {
210 buffer_id: Some(buffer_id),
211 excerpt_id,
212 text_anchor: language::proto::deserialize_anchor(anchor)
213 .ok_or_else(|| anyhow!("invalid scroll top"))?,
214 },
215 vec2f(message.scroll_x, message.scroll_y),
216 cx,
217 );
218 }
219 }
220 }
221 Ok(())
222 }
223
224 fn should_unfollow_on_event(event: &Self::Event, _: &AppContext) -> bool {
225 match event {
226 Event::Edited => true,
227 Event::SelectionsChanged { local } => *local,
228 Event::ScrollPositionChanged { local } => *local,
229 _ => false,
230 }
231 }
232}
233
234fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
235 proto::Selection {
236 id: selection.id as u64,
237 start: Some(language::proto::serialize_anchor(
238 &selection.start.text_anchor,
239 )),
240 end: Some(language::proto::serialize_anchor(
241 &selection.end.text_anchor,
242 )),
243 reversed: selection.reversed,
244 }
245}
246
247fn deserialize_selection(
248 excerpt_id: &ExcerptId,
249 buffer_id: usize,
250 selection: proto::Selection,
251) -> Option<Selection<Anchor>> {
252 Some(Selection {
253 id: selection.id as usize,
254 start: Anchor {
255 buffer_id: Some(buffer_id),
256 excerpt_id: excerpt_id.clone(),
257 text_anchor: language::proto::deserialize_anchor(selection.start?)?,
258 },
259 end: Anchor {
260 buffer_id: Some(buffer_id),
261 excerpt_id: excerpt_id.clone(),
262 text_anchor: language::proto::deserialize_anchor(selection.end?)?,
263 },
264 reversed: selection.reversed,
265 goal: SelectionGoal::None,
266 })
267}
268
269impl Item for Editor {
270 fn navigate(&mut self, data: Box<dyn std::any::Any>, cx: &mut ViewContext<Self>) -> bool {
271 if let Ok(data) = data.downcast::<NavigationData>() {
272 let newest_selection = self.selections.newest::<Point>(cx);
273 let buffer = self.buffer.read(cx).read(cx);
274 let offset = if buffer.can_resolve(&data.cursor_anchor) {
275 data.cursor_anchor.to_point(&buffer)
276 } else {
277 buffer.clip_point(data.cursor_position, Bias::Left)
278 };
279
280 let scroll_top_anchor = if buffer.can_resolve(&data.scroll_top_anchor) {
281 data.scroll_top_anchor
282 } else {
283 buffer.anchor_before(
284 buffer.clip_point(Point::new(data.scroll_top_row, 0), Bias::Left),
285 )
286 };
287
288 drop(buffer);
289
290 if newest_selection.head() == offset {
291 false
292 } else {
293 let nav_history = self.nav_history.take();
294 self.scroll_position = data.scroll_position;
295 self.scroll_top_anchor = scroll_top_anchor;
296 self.change_selections(Some(Autoscroll::Fit), cx, |s| {
297 s.select_ranges([offset..offset])
298 });
299 self.nav_history = nav_history;
300 true
301 }
302 } else {
303 false
304 }
305 }
306
307 fn tab_description<'a>(&'a self, detail: usize, cx: &'a AppContext) -> Option<Cow<'a, str>> {
308 match path_for_buffer(&self.buffer, detail, true, cx)? {
309 Cow::Borrowed(path) => Some(path.to_string_lossy()),
310 Cow::Owned(path) => Some(path.to_string_lossy().to_string().into()),
311 }
312 }
313
314 fn tab_content(
315 &self,
316 detail: Option<usize>,
317 style: &theme::Tab,
318 cx: &AppContext,
319 ) -> ElementBox {
320 Flex::row()
321 .with_child(
322 Label::new(self.title(cx).into(), style.label.clone())
323 .aligned()
324 .boxed(),
325 )
326 .with_children(detail.and_then(|detail| {
327 let path = path_for_buffer(&self.buffer, detail, false, cx)?;
328 let description = path.to_string_lossy();
329 Some(
330 Label::new(
331 if description.len() > MAX_TAB_TITLE_LEN {
332 description[..MAX_TAB_TITLE_LEN].to_string() + "…"
333 } else {
334 description.into()
335 },
336 style.description.text.clone(),
337 )
338 .contained()
339 .with_style(style.description.container)
340 .aligned()
341 .boxed(),
342 )
343 }))
344 .boxed()
345 }
346
347 fn project_path(&self, cx: &AppContext) -> Option<ProjectPath> {
348 let buffer = self.buffer.read(cx).as_singleton()?;
349 let file = buffer.read(cx).file();
350 File::from_dyn(file).map(|file| ProjectPath {
351 worktree_id: file.worktree_id(cx),
352 path: file.path().clone(),
353 })
354 }
355
356 fn project_entry_ids(&self, cx: &AppContext) -> SmallVec<[ProjectEntryId; 3]> {
357 self.buffer
358 .read(cx)
359 .files(cx)
360 .into_iter()
361 .filter_map(|file| File::from_dyn(Some(file))?.project_entry_id(cx))
362 .collect()
363 }
364
365 fn is_singleton(&self, cx: &AppContext) -> bool {
366 self.buffer.read(cx).is_singleton()
367 }
368
369 fn clone_on_split(&self, cx: &mut ViewContext<Self>) -> Option<Self>
370 where
371 Self: Sized,
372 {
373 Some(self.clone(cx))
374 }
375
376 fn set_nav_history(&mut self, history: ItemNavHistory, _: &mut ViewContext<Self>) {
377 self.nav_history = Some(history);
378 }
379
380 fn deactivated(&mut self, cx: &mut ViewContext<Self>) {
381 let selection = self.selections.newest_anchor();
382 self.push_to_nav_history(selection.head(), None, cx);
383 }
384
385 fn workspace_deactivated(&mut self, cx: &mut ViewContext<Self>) {
386 hide_link_definition(self, cx);
387 self.link_go_to_definition_state.last_mouse_location = None;
388 }
389
390 fn is_dirty(&self, cx: &AppContext) -> bool {
391 self.buffer().read(cx).read(cx).is_dirty()
392 }
393
394 fn has_conflict(&self, cx: &AppContext) -> bool {
395 self.buffer().read(cx).read(cx).has_conflict()
396 }
397
398 fn can_save(&self, cx: &AppContext) -> bool {
399 !self.buffer().read(cx).is_singleton() || self.project_path(cx).is_some()
400 }
401
402 fn save(
403 &mut self,
404 project: ModelHandle<Project>,
405 cx: &mut ViewContext<Self>,
406 ) -> Task<Result<()>> {
407 self.report_event("save editor", cx);
408
409 let buffer = self.buffer().clone();
410 let buffers = buffer.read(cx).all_buffers();
411 let mut timeout = cx.background().timer(FORMAT_TIMEOUT).fuse();
412 let format = project.update(cx, |project, cx| {
413 project.format(buffers, true, FormatTrigger::Save, cx)
414 });
415 cx.spawn(|_, mut cx| async move {
416 let transaction = futures::select_biased! {
417 _ = timeout => {
418 log::warn!("timed out waiting for formatting");
419 None
420 }
421 transaction = format.log_err().fuse() => transaction,
422 };
423
424 buffer
425 .update(&mut cx, |buffer, cx| {
426 if let Some(transaction) = transaction {
427 if !buffer.is_singleton() {
428 buffer.push_transaction(&transaction.0);
429 }
430 }
431
432 buffer.save(cx)
433 })
434 .await?;
435 Ok(())
436 })
437 }
438
439 fn save_as(
440 &mut self,
441 project: ModelHandle<Project>,
442 abs_path: PathBuf,
443 cx: &mut ViewContext<Self>,
444 ) -> Task<Result<()>> {
445 let buffer = self
446 .buffer()
447 .read(cx)
448 .as_singleton()
449 .expect("cannot call save_as on an excerpt list");
450
451 project.update(cx, |project, cx| {
452 project.save_buffer_as(buffer, abs_path, cx)
453 })
454 }
455
456 fn reload(
457 &mut self,
458 project: ModelHandle<Project>,
459 cx: &mut ViewContext<Self>,
460 ) -> Task<Result<()>> {
461 let buffer = self.buffer().clone();
462 let buffers = self.buffer.read(cx).all_buffers();
463 let reload_buffers =
464 project.update(cx, |project, cx| project.reload_buffers(buffers, true, cx));
465 cx.spawn(|this, mut cx| async move {
466 let transaction = reload_buffers.log_err().await;
467 this.update(&mut cx, |editor, cx| {
468 editor.request_autoscroll(Autoscroll::Fit, cx)
469 });
470 buffer.update(&mut cx, |buffer, _| {
471 if let Some(transaction) = transaction {
472 if !buffer.is_singleton() {
473 buffer.push_transaction(&transaction.0);
474 }
475 }
476 });
477 Ok(())
478 })
479 }
480
481 fn git_diff_recalc(
482 &mut self,
483 _project: ModelHandle<Project>,
484 cx: &mut ViewContext<Self>,
485 ) -> Task<Result<()>> {
486 self.buffer().update(cx, |multibuffer, cx| {
487 multibuffer.git_diff_recalc(cx);
488 });
489 Task::ready(Ok(()))
490 }
491
492 fn to_item_events(event: &Self::Event) -> Vec<workspace::ItemEvent> {
493 let mut result = Vec::new();
494 match event {
495 Event::Closed => result.push(ItemEvent::CloseItem),
496 Event::Saved | Event::TitleChanged => {
497 result.push(ItemEvent::UpdateTab);
498 result.push(ItemEvent::UpdateBreadcrumbs);
499 }
500 Event::Reparsed => {
501 result.push(ItemEvent::UpdateBreadcrumbs);
502 }
503 Event::SelectionsChanged { local } if *local => {
504 result.push(ItemEvent::UpdateBreadcrumbs);
505 }
506 Event::DirtyChanged => {
507 result.push(ItemEvent::UpdateTab);
508 }
509 Event::BufferEdited => {
510 result.push(ItemEvent::Edit);
511 result.push(ItemEvent::UpdateBreadcrumbs);
512 }
513 _ => {}
514 }
515 result
516 }
517
518 fn as_searchable(&self, handle: &ViewHandle<Self>) -> Option<Box<dyn SearchableItemHandle>> {
519 Some(Box::new(handle.clone()))
520 }
521
522 fn breadcrumb_location(&self) -> ToolbarItemLocation {
523 ToolbarItemLocation::PrimaryLeft { flex: None }
524 }
525
526 fn breadcrumbs(&self, theme: &theme::Theme, cx: &AppContext) -> Option<Vec<ElementBox>> {
527 let cursor = self.selections.newest_anchor().head();
528 let multibuffer = &self.buffer().read(cx);
529 let (buffer_id, symbols) =
530 multibuffer.symbols_containing(cursor, Some(&theme.editor.syntax), cx)?;
531 let buffer = multibuffer.buffer(buffer_id)?;
532
533 let buffer = buffer.read(cx);
534 let filename = if let Some(file) = buffer.file() {
535 if file.path().file_name().is_none()
536 || self
537 .project
538 .as_ref()
539 .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
540 .unwrap_or_default()
541 {
542 file.full_path(cx).to_string_lossy().to_string()
543 } else {
544 file.path().to_string_lossy().to_string()
545 }
546 } else {
547 "untitled".to_string()
548 };
549
550 let mut breadcrumbs = vec![Label::new(filename, theme.breadcrumbs.text.clone()).boxed()];
551 breadcrumbs.extend(symbols.into_iter().map(|symbol| {
552 Text::new(symbol.text, theme.breadcrumbs.text.clone())
553 .with_highlights(symbol.highlight_ranges)
554 .boxed()
555 }));
556 Some(breadcrumbs)
557 }
558}
559
560impl ProjectItem for Editor {
561 type Item = Buffer;
562
563 fn for_project_item(
564 project: ModelHandle<Project>,
565 buffer: ModelHandle<Buffer>,
566 cx: &mut ViewContext<Self>,
567 ) -> Self {
568 Self::for_buffer(buffer, Some(project), cx)
569 }
570}
571
572enum BufferSearchHighlights {}
573impl SearchableItem for Editor {
574 type Match = Range<Anchor>;
575
576 fn to_search_event(event: &Self::Event) -> Option<SearchEvent> {
577 match event {
578 Event::BufferEdited => Some(SearchEvent::MatchesInvalidated),
579 Event::SelectionsChanged { .. } => Some(SearchEvent::ActiveMatchChanged),
580 _ => None,
581 }
582 }
583
584 fn clear_matches(&mut self, cx: &mut ViewContext<Self>) {
585 self.clear_background_highlights::<BufferSearchHighlights>(cx);
586 }
587
588 fn update_matches(&mut self, matches: Vec<Range<Anchor>>, cx: &mut ViewContext<Self>) {
589 self.highlight_background::<BufferSearchHighlights>(
590 matches,
591 |theme| theme.search.match_background,
592 cx,
593 );
594 }
595
596 fn query_suggestion(&mut self, cx: &mut ViewContext<Self>) -> String {
597 let display_map = self.snapshot(cx).display_snapshot;
598 let selection = self.selections.newest::<usize>(cx);
599 if selection.start == selection.end {
600 let point = selection.start.to_display_point(&display_map);
601 let range = surrounding_word(&display_map, point);
602 let range = range.start.to_offset(&display_map, Bias::Left)
603 ..range.end.to_offset(&display_map, Bias::Right);
604 let text: String = display_map.buffer_snapshot.text_for_range(range).collect();
605 if text.trim().is_empty() {
606 String::new()
607 } else {
608 text
609 }
610 } else {
611 display_map
612 .buffer_snapshot
613 .text_for_range(selection.start..selection.end)
614 .collect()
615 }
616 }
617
618 fn activate_match(
619 &mut self,
620 index: usize,
621 matches: Vec<Range<Anchor>>,
622 cx: &mut ViewContext<Self>,
623 ) {
624 self.unfold_ranges([matches[index].clone()], false, cx);
625 self.change_selections(Some(Autoscroll::Fit), cx, |s| {
626 s.select_ranges([matches[index].clone()])
627 });
628 }
629
630 fn match_index_for_direction(
631 &mut self,
632 matches: &Vec<Range<Anchor>>,
633 mut current_index: usize,
634 direction: Direction,
635 cx: &mut ViewContext<Self>,
636 ) -> usize {
637 let buffer = self.buffer().read(cx).snapshot(cx);
638 let cursor = self.selections.newest_anchor().head();
639 if matches[current_index].start.cmp(&cursor, &buffer).is_gt() {
640 if direction == Direction::Prev {
641 if current_index == 0 {
642 current_index = matches.len() - 1;
643 } else {
644 current_index -= 1;
645 }
646 }
647 } else if matches[current_index].end.cmp(&cursor, &buffer).is_lt() {
648 if direction == Direction::Next {
649 current_index = 0;
650 }
651 } else if direction == Direction::Prev {
652 if current_index == 0 {
653 current_index = matches.len() - 1;
654 } else {
655 current_index -= 1;
656 }
657 } else if direction == Direction::Next {
658 if current_index == matches.len() - 1 {
659 current_index = 0
660 } else {
661 current_index += 1;
662 }
663 };
664 current_index
665 }
666
667 fn find_matches(
668 &mut self,
669 query: project::search::SearchQuery,
670 cx: &mut ViewContext<Self>,
671 ) -> Task<Vec<Range<Anchor>>> {
672 let buffer = self.buffer().read(cx).snapshot(cx);
673 cx.background().spawn(async move {
674 let mut ranges = Vec::new();
675 if let Some((_, _, excerpt_buffer)) = buffer.as_singleton() {
676 ranges.extend(
677 query
678 .search(excerpt_buffer.as_rope())
679 .await
680 .into_iter()
681 .map(|range| {
682 buffer.anchor_after(range.start)..buffer.anchor_before(range.end)
683 }),
684 );
685 } else {
686 for excerpt in buffer.excerpt_boundaries_in_range(0..buffer.len()) {
687 let excerpt_range = excerpt.range.context.to_offset(&excerpt.buffer);
688 let rope = excerpt.buffer.as_rope().slice(excerpt_range.clone());
689 ranges.extend(query.search(&rope).await.into_iter().map(|range| {
690 let start = excerpt
691 .buffer
692 .anchor_after(excerpt_range.start + range.start);
693 let end = excerpt
694 .buffer
695 .anchor_before(excerpt_range.start + range.end);
696 buffer.anchor_in_excerpt(excerpt.id.clone(), start)
697 ..buffer.anchor_in_excerpt(excerpt.id.clone(), end)
698 }));
699 }
700 }
701 ranges
702 })
703 }
704
705 fn active_match_index(
706 &mut self,
707 matches: Vec<Range<Anchor>>,
708 cx: &mut ViewContext<Self>,
709 ) -> Option<usize> {
710 active_match_index(
711 &matches,
712 &self.selections.newest_anchor().head(),
713 &self.buffer().read(cx).snapshot(cx),
714 )
715 }
716}
717
718pub fn active_match_index(
719 ranges: &[Range<Anchor>],
720 cursor: &Anchor,
721 buffer: &MultiBufferSnapshot,
722) -> Option<usize> {
723 if ranges.is_empty() {
724 None
725 } else {
726 match ranges.binary_search_by(|probe| {
727 if probe.end.cmp(cursor, &*buffer).is_lt() {
728 Ordering::Less
729 } else if probe.start.cmp(cursor, &*buffer).is_gt() {
730 Ordering::Greater
731 } else {
732 Ordering::Equal
733 }
734 }) {
735 Ok(i) | Err(i) => Some(cmp::min(i, ranges.len() - 1)),
736 }
737 }
738}
739
740pub struct CursorPosition {
741 position: Option<Point>,
742 selected_count: usize,
743 _observe_active_editor: Option<Subscription>,
744}
745
746impl Default for CursorPosition {
747 fn default() -> Self {
748 Self::new()
749 }
750}
751
752impl CursorPosition {
753 pub fn new() -> Self {
754 Self {
755 position: None,
756 selected_count: 0,
757 _observe_active_editor: None,
758 }
759 }
760
761 fn update_position(&mut self, editor: ViewHandle<Editor>, cx: &mut ViewContext<Self>) {
762 let editor = editor.read(cx);
763 let buffer = editor.buffer().read(cx).snapshot(cx);
764
765 self.selected_count = 0;
766 let mut last_selection: Option<Selection<usize>> = None;
767 for selection in editor.selections.all::<usize>(cx) {
768 self.selected_count += selection.end - selection.start;
769 if last_selection
770 .as_ref()
771 .map_or(true, |last_selection| selection.id > last_selection.id)
772 {
773 last_selection = Some(selection);
774 }
775 }
776 self.position = last_selection.map(|s| s.head().to_point(&buffer));
777
778 cx.notify();
779 }
780}
781
782impl Entity for CursorPosition {
783 type Event = ();
784}
785
786impl View for CursorPosition {
787 fn ui_name() -> &'static str {
788 "CursorPosition"
789 }
790
791 fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
792 if let Some(position) = self.position {
793 let theme = &cx.global::<Settings>().theme.workspace.status_bar;
794 let mut text = format!("{},{}", position.row + 1, position.column + 1);
795 if self.selected_count > 0 {
796 write!(text, " ({} selected)", self.selected_count).unwrap();
797 }
798 Label::new(text, theme.cursor_position.clone()).boxed()
799 } else {
800 Empty::new().boxed()
801 }
802 }
803}
804
805impl StatusItemView for CursorPosition {
806 fn set_active_pane_item(
807 &mut self,
808 active_pane_item: Option<&dyn ItemHandle>,
809 cx: &mut ViewContext<Self>,
810 ) {
811 if let Some(editor) = active_pane_item.and_then(|item| item.downcast::<Editor>()) {
812 self._observe_active_editor = Some(cx.observe(&editor, Self::update_position));
813 self.update_position(editor, cx);
814 } else {
815 self.position = None;
816 self._observe_active_editor = None;
817 }
818
819 cx.notify();
820 }
821}
822
823fn path_for_buffer<'a>(
824 buffer: &ModelHandle<MultiBuffer>,
825 mut height: usize,
826 include_filename: bool,
827 cx: &'a AppContext,
828) -> Option<Cow<'a, Path>> {
829 let file = buffer.read(cx).as_singleton()?.read(cx).file()?;
830 // Ensure we always render at least the filename.
831 height += 1;
832
833 let mut prefix = file.path().as_ref();
834 while height > 0 {
835 if let Some(parent) = prefix.parent() {
836 prefix = parent;
837 height -= 1;
838 } else {
839 break;
840 }
841 }
842
843 // Here we could have just always used `full_path`, but that is very
844 // allocation-heavy and so we try to use a `Cow<Path>` if we haven't
845 // traversed all the way up to the worktree's root.
846 if height > 0 {
847 let full_path = file.full_path(cx);
848 if include_filename {
849 Some(full_path.into())
850 } else {
851 Some(full_path.parent().unwrap().to_path_buf().into())
852 }
853 } else {
854 let mut path = file.path().strip_prefix(prefix).unwrap();
855 if !include_filename {
856 path = path.parent().unwrap();
857 }
858 Some(path.into())
859 }
860}