1use std::{ops::Range, sync::Arc};
2
3use buffer_diff::BufferDiff;
4use feature_flags::{FeatureFlag, FeatureFlagAppExt as _};
5use gpui::{
6 Action, AppContext as _, Entity, EventEmitter, Focusable, NoAction, Subscription, WeakEntity,
7};
8use language::{Buffer, Capability, LanguageRegistry};
9use multi_buffer::{Anchor, ExcerptRange, MultiBuffer, PathKey};
10use project::Project;
11use rope::Point;
12use text::OffsetRangeExt as _;
13use ui::{
14 App, Context, InteractiveElement as _, IntoElement as _, ParentElement as _, Render,
15 Styled as _, Window, div,
16};
17use workspace::{
18 ActivePaneDecorator, Item, ItemHandle, Pane, PaneGroup, SplitDirection, Workspace,
19};
20
21use crate::{Editor, EditorEvent};
22
23struct SplitDiffFeatureFlag;
24
25impl FeatureFlag for SplitDiffFeatureFlag {
26 const NAME: &'static str = "split-diff";
27
28 fn enabled_for_staff() -> bool {
29 true
30 }
31}
32
33#[derive(Clone, Copy, PartialEq, Eq, Action, Default)]
34#[action(namespace = editor)]
35struct SplitDiff;
36
37#[derive(Clone, Copy, PartialEq, Eq, Action, Default)]
38#[action(namespace = editor)]
39struct UnsplitDiff;
40
41pub struct SplittableEditor {
42 primary_editor: Entity<Editor>,
43 secondary: Option<SecondaryEditor>,
44 panes: PaneGroup,
45 workspace: WeakEntity<Workspace>,
46 _subscriptions: Vec<Subscription>,
47}
48
49struct SecondaryEditor {
50 editor: Entity<Editor>,
51 pane: Entity<Pane>,
52 has_latest_selection: bool,
53 _subscriptions: Vec<Subscription>,
54}
55
56impl SplittableEditor {
57 pub fn primary_editor(&self) -> &Entity<Editor> {
58 &self.primary_editor
59 }
60
61 pub fn last_selected_editor(&self) -> &Entity<Editor> {
62 if let Some(secondary) = &self.secondary
63 && secondary.has_latest_selection
64 {
65 &secondary.editor
66 } else {
67 &self.primary_editor
68 }
69 }
70
71 pub fn new_unsplit(
72 buffer: Entity<MultiBuffer>,
73 project: Entity<Project>,
74 workspace: Entity<Workspace>,
75 window: &mut Window,
76 cx: &mut Context<Self>,
77 ) -> Self {
78 let primary_editor =
79 cx.new(|cx| Editor::for_multibuffer(buffer, Some(project.clone()), window, cx));
80 let pane = cx.new(|cx| {
81 let mut pane = Pane::new(
82 workspace.downgrade(),
83 project,
84 Default::default(),
85 None,
86 NoAction.boxed_clone(),
87 true,
88 window,
89 cx,
90 );
91 pane.set_should_display_tab_bar(|_, _| false);
92 pane.add_item(primary_editor.boxed_clone(), true, true, None, window, cx);
93 pane
94 });
95 let panes = PaneGroup::new(pane);
96 // TODO(split-diff) we might want to tag editor events with whether they came from primary/secondary
97 let subscriptions =
98 vec![
99 cx.subscribe(&primary_editor, |this, _, event: &EditorEvent, cx| {
100 if let EditorEvent::SelectionsChanged { .. } = event
101 && let Some(secondary) = &mut this.secondary
102 {
103 secondary.has_latest_selection = false;
104 }
105 cx.emit(event.clone())
106 }),
107 ];
108
109 window.defer(cx, {
110 let workspace = workspace.downgrade();
111 let primary_editor = primary_editor.downgrade();
112 move |window, cx| {
113 workspace
114 .update(cx, |workspace, cx| {
115 primary_editor.update(cx, |editor, cx| {
116 editor.added_to_workspace(workspace, window, cx);
117 })
118 })
119 .ok();
120 }
121 });
122 Self {
123 primary_editor,
124 secondary: None,
125 panes,
126 workspace: workspace.downgrade(),
127 _subscriptions: subscriptions,
128 }
129 }
130
131 fn split(&mut self, _: &SplitDiff, window: &mut Window, cx: &mut Context<Self>) {
132 if !cx.has_flag::<SplitDiffFeatureFlag>() {
133 return;
134 }
135 if self.secondary.is_some() {
136 return;
137 }
138 let Some(workspace) = self.workspace.upgrade() else {
139 return;
140 };
141 let project = workspace.read(cx).project().clone();
142
143 let secondary_editor = cx.new(|cx| {
144 let multibuffer = cx.new(|cx| {
145 let mut multibuffer = MultiBuffer::new(Capability::ReadOnly);
146 multibuffer.set_all_diff_hunks_expanded(cx);
147 multibuffer
148 });
149 Editor::for_multibuffer(multibuffer, Some(project.clone()), window, cx)
150 });
151 let secondary_pane = cx.new(|cx| {
152 let mut pane = Pane::new(
153 workspace.downgrade(),
154 workspace.read(cx).project().clone(),
155 Default::default(),
156 None,
157 NoAction.boxed_clone(),
158 true,
159 window,
160 cx,
161 );
162 pane.set_should_display_tab_bar(|_, _| false);
163 pane.add_item(
164 ItemHandle::boxed_clone(&secondary_editor),
165 false,
166 false,
167 None,
168 window,
169 cx,
170 );
171 pane
172 });
173
174 let subscriptions =
175 vec![
176 cx.subscribe(&secondary_editor, |this, _, event: &EditorEvent, cx| {
177 if let EditorEvent::SelectionsChanged { .. } = event
178 && let Some(secondary) = &mut this.secondary
179 {
180 secondary.has_latest_selection = true;
181 }
182 cx.emit(event.clone())
183 }),
184 ];
185 let mut secondary = SecondaryEditor {
186 editor: secondary_editor,
187 pane: secondary_pane.clone(),
188 has_latest_selection: false,
189 _subscriptions: subscriptions,
190 };
191 self.primary_editor.update(cx, |editor, cx| {
192 editor.buffer().update(cx, |primary_multibuffer, cx| {
193 primary_multibuffer.set_show_deleted_hunks(false, cx);
194 let paths = primary_multibuffer.paths().collect::<Vec<_>>();
195 for path in paths {
196 let Some(excerpt_id) = primary_multibuffer.excerpts_for_path(&path).next()
197 else {
198 continue;
199 };
200 let snapshot = primary_multibuffer.snapshot(cx);
201 let buffer = snapshot.buffer_for_excerpt(excerpt_id).unwrap();
202 let diff = primary_multibuffer.diff_for(buffer.remote_id()).unwrap();
203 secondary.sync_path_excerpts(path, primary_multibuffer, diff, cx);
204 }
205 })
206 });
207 self.secondary = Some(secondary);
208
209 let primary_pane = self.panes.first_pane();
210 self.panes
211 .split(&primary_pane, &secondary_pane, SplitDirection::Left)
212 .unwrap();
213 cx.notify();
214 }
215
216 fn unsplit(&mut self, _: &UnsplitDiff, _: &mut Window, cx: &mut Context<Self>) {
217 let Some(secondary) = self.secondary.take() else {
218 return;
219 };
220 self.panes.remove(&secondary.pane).unwrap();
221 self.primary_editor.update(cx, |primary, cx| {
222 primary.buffer().update(cx, |buffer, cx| {
223 buffer.set_show_deleted_hunks(true, cx);
224 });
225 });
226 cx.notify();
227 }
228
229 pub fn added_to_workspace(
230 &mut self,
231 workspace: &mut Workspace,
232 window: &mut Window,
233 cx: &mut Context<Self>,
234 ) {
235 self.workspace = workspace.weak_handle();
236 self.primary_editor.update(cx, |primary_editor, cx| {
237 primary_editor.added_to_workspace(workspace, window, cx);
238 });
239 if let Some(secondary) = &self.secondary {
240 secondary.editor.update(cx, |secondary_editor, cx| {
241 secondary_editor.added_to_workspace(workspace, window, cx);
242 });
243 }
244 }
245
246 pub fn set_excerpts_for_path(
247 &mut self,
248 path: PathKey,
249 buffer: Entity<Buffer>,
250 ranges: impl IntoIterator<Item = Range<Point>>,
251 context_line_count: u32,
252 diff: Entity<BufferDiff>,
253 cx: &mut Context<Self>,
254 ) -> (Vec<Range<Anchor>>, bool) {
255 self.primary_editor.update(cx, |editor, cx| {
256 editor.buffer().update(cx, |primary_multibuffer, cx| {
257 let (anchors, added_a_new_excerpt) = primary_multibuffer.set_excerpts_for_path(
258 path.clone(),
259 buffer,
260 ranges,
261 context_line_count,
262 cx,
263 );
264 primary_multibuffer.add_diff(diff.clone(), cx);
265 if let Some(secondary) = &mut self.secondary {
266 secondary.sync_path_excerpts(path, primary_multibuffer, diff, cx);
267 }
268 (anchors, added_a_new_excerpt)
269 })
270 })
271 }
272}
273
274impl EventEmitter<EditorEvent> for SplittableEditor {}
275impl Focusable for SplittableEditor {
276 fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
277 self.primary_editor.read(cx).focus_handle(cx)
278 }
279}
280
281impl Render for SplittableEditor {
282 fn render(
283 &mut self,
284 window: &mut ui::Window,
285 cx: &mut ui::Context<Self>,
286 ) -> impl ui::IntoElement {
287 let inner = if self.secondary.is_none() {
288 self.primary_editor.clone().into_any_element()
289 } else if let Some(active) = self.panes.panes().into_iter().next() {
290 self.panes
291 .render(
292 None,
293 &ActivePaneDecorator::new(active, &self.workspace),
294 window,
295 cx,
296 )
297 .into_any_element()
298 } else {
299 div().into_any_element()
300 };
301 div()
302 .id("splittable-editor")
303 .on_action(cx.listener(Self::split))
304 .on_action(cx.listener(Self::unsplit))
305 .size_full()
306 .child(inner)
307 }
308}
309
310impl SecondaryEditor {
311 fn sync_path_excerpts(
312 &mut self,
313 path_key: PathKey,
314 primary_multibuffer: &mut MultiBuffer,
315 diff: Entity<BufferDiff>,
316 cx: &mut App,
317 ) {
318 let excerpt_id = primary_multibuffer
319 .excerpts_for_path(&path_key)
320 .next()
321 .unwrap();
322 let primary_multibuffer_snapshot = primary_multibuffer.snapshot(cx);
323 let main_buffer = primary_multibuffer_snapshot
324 .buffer_for_excerpt(excerpt_id)
325 .unwrap();
326 let base_text_buffer = diff.read(cx).base_text_buffer();
327 let diff_snapshot = diff.read(cx).snapshot(cx);
328 let base_text_buffer_snapshot = base_text_buffer.read(cx).snapshot();
329 let new = primary_multibuffer
330 .excerpts_for_buffer(main_buffer.remote_id(), cx)
331 .into_iter()
332 .map(|(_, excerpt_range)| {
333 let point_range_to_base_text_point_range = |range: Range<Point>| {
334 let start_row =
335 diff_snapshot.row_to_base_text_row(range.start.row, main_buffer);
336 let start_column = 0;
337 let end_row = diff_snapshot.row_to_base_text_row(range.end.row, main_buffer);
338 let end_column = diff_snapshot.base_text().line_len(end_row);
339 Point::new(start_row, start_column)..Point::new(end_row, end_column)
340 };
341 let primary = excerpt_range.primary.to_point(main_buffer);
342 let context = excerpt_range.context.to_point(main_buffer);
343 ExcerptRange {
344 primary: point_range_to_base_text_point_range(primary),
345 context: point_range_to_base_text_point_range(context),
346 }
347 })
348 .collect();
349
350 let main_buffer = primary_multibuffer.buffer(main_buffer.remote_id()).unwrap();
351
352 self.editor.update(cx, |editor, cx| {
353 editor.buffer().update(cx, |buffer, cx| {
354 buffer.update_path_excerpts(
355 path_key,
356 base_text_buffer,
357 &base_text_buffer_snapshot,
358 new,
359 cx,
360 );
361 buffer.add_inverted_diff(diff, main_buffer, cx);
362 })
363 });
364 }
365}
366
367#[cfg(test)]
368mod tests {
369 use buffer_diff::BufferDiff;
370 use db::indoc;
371 use fs::FakeFs;
372 use gpui::AppContext as _;
373 use language::{Buffer, Capability};
374 use multi_buffer::MultiBuffer;
375 use project::Project;
376 use settings::SettingsStore;
377 use ui::VisualContext as _;
378 use workspace::Workspace;
379
380 use crate::SplittableEditor;
381
382 #[gpui::test]
383 async fn test_basic_excerpts(cx: &mut gpui::TestAppContext) {
384 cx.update(|cx| {
385 let store = SettingsStore::test(cx);
386 cx.set_global(store);
387 theme::init(theme::LoadThemes::JustBase, cx);
388 crate::init(cx);
389 });
390 let base_text = indoc! {"
391 hello
392 "};
393 let buffer_text = indoc! {"
394 HELLO!
395 "};
396 let buffer = cx.new(|cx| Buffer::local(buffer_text, cx));
397 let diff = cx.new(|cx| {
398 BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx)
399 });
400 let project = Project::test(FakeFs::new(cx.executor()), [], cx).await;
401 let (workspace, cx) =
402 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
403 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
404 let editor = cx.new_window_entity(|window, cx| {
405 SplittableEditor::new_unsplit(multibuffer, project, workspace, window, cx)
406 });
407
408 // for _ in 0..random() {
409 // editor.update(cx, |editor, cx| {
410 // randomly_mutate(primary_multibuffer);
411 // editor.primary_editor().update(cx, |editor, cx| {
412 // editor.edit(vec![(random()..random(), "...")], cx);
413 // })
414 // });
415 // }
416
417 // editor.read(cx).primary_editor().read(cx).display_map.read(cx)
418 }
419
420 // MultiB
421
422 // FIXME restore these tests in some form
423 // #[gpui::test]
424 // async fn test_filtered_editor_pair(cx: &mut gpui::TestAppContext) {
425 // init_test(cx, |_| {});
426 // let mut leader_cx = EditorTestContext::new(cx).await;
427
428 // let diff_base = indoc!(
429 // r#"
430 // one
431 // two
432 // three
433 // four
434 // five
435 // six
436 // "#
437 // );
438
439 // let initial_state = indoc!(
440 // r#"
441 // ˇone
442 // two
443 // THREE
444 // four
445 // five
446 // six
447 // "#
448 // );
449
450 // leader_cx.set_state(initial_state);
451
452 // leader_cx.set_head_text(&diff_base);
453 // leader_cx.run_until_parked();
454
455 // let follower = leader_cx.update_multibuffer(|leader, cx| {
456 // leader.set_filter_mode(Some(MultiBufferFilterMode::KeepInsertions));
457 // leader.set_all_diff_hunks_expanded(cx);
458 // leader.get_or_create_follower(cx)
459 // });
460 // follower.update(cx, |follower, cx| {
461 // follower.set_filter_mode(Some(MultiBufferFilterMode::KeepDeletions));
462 // follower.set_all_diff_hunks_expanded(cx);
463 // });
464
465 // let follower_editor =
466 // leader_cx.new_window_entity(|window, cx| build_editor(follower, window, cx));
467 // // leader_cx.window.focus(&follower_editor.focus_handle(cx));
468
469 // let mut follower_cx = EditorTestContext::for_editor_in(follower_editor, &mut leader_cx).await;
470 // cx.run_until_parked();
471
472 // leader_cx.assert_editor_state(initial_state);
473 // follower_cx.assert_editor_state(indoc! {
474 // r#"
475 // ˇone
476 // two
477 // three
478 // four
479 // five
480 // six
481 // "#
482 // });
483
484 // follower_cx.editor(|editor, _window, cx| {
485 // assert!(editor.read_only(cx));
486 // });
487
488 // leader_cx.update_editor(|editor, _window, cx| {
489 // editor.edit([(Point::new(4, 0)..Point::new(5, 0), "FIVE\n")], cx);
490 // });
491 // cx.run_until_parked();
492
493 // leader_cx.assert_editor_state(indoc! {
494 // r#"
495 // ˇone
496 // two
497 // THREE
498 // four
499 // FIVE
500 // six
501 // "#
502 // });
503
504 // follower_cx.assert_editor_state(indoc! {
505 // r#"
506 // ˇone
507 // two
508 // three
509 // four
510 // five
511 // six
512 // "#
513 // });
514
515 // leader_cx.update_editor(|editor, _window, cx| {
516 // editor.edit([(Point::new(6, 0)..Point::new(6, 0), "SEVEN")], cx);
517 // });
518 // cx.run_until_parked();
519
520 // leader_cx.assert_editor_state(indoc! {
521 // r#"
522 // ˇone
523 // two
524 // THREE
525 // four
526 // FIVE
527 // six
528 // SEVEN"#
529 // });
530
531 // follower_cx.assert_editor_state(indoc! {
532 // r#"
533 // ˇone
534 // two
535 // three
536 // four
537 // five
538 // six
539 // "#
540 // });
541
542 // leader_cx.update_editor(|editor, window, cx| {
543 // editor.move_down(&MoveDown, window, cx);
544 // editor.refresh_selected_text_highlights(true, window, cx);
545 // });
546 // leader_cx.run_until_parked();
547 // }
548
549 // #[gpui::test]
550 // async fn test_filtered_editor_pair_complex(cx: &mut gpui::TestAppContext) {
551 // init_test(cx, |_| {});
552 // let base_text = "base\n";
553 // let buffer_text = "buffer\n";
554
555 // let buffer1 = cx.new(|cx| Buffer::local(buffer_text, cx));
556 // let diff1 = cx.new(|cx| BufferDiff::new_with_base_text(base_text, &buffer1, cx));
557
558 // let extra_buffer_1 = cx.new(|cx| Buffer::local("dummy text 1\n", cx));
559 // let extra_diff_1 = cx.new(|cx| BufferDiff::new_with_base_text("", &extra_buffer_1, cx));
560 // let extra_buffer_2 = cx.new(|cx| Buffer::local("dummy text 2\n", cx));
561 // let extra_diff_2 = cx.new(|cx| BufferDiff::new_with_base_text("", &extra_buffer_2, cx));
562
563 // let leader = cx.new(|cx| {
564 // let mut leader = MultiBuffer::new(Capability::ReadWrite);
565 // leader.set_all_diff_hunks_expanded(cx);
566 // leader.set_filter_mode(Some(MultiBufferFilterMode::KeepInsertions));
567 // leader
568 // });
569 // let follower = leader.update(cx, |leader, cx| leader.get_or_create_follower(cx));
570 // follower.update(cx, |follower, _| {
571 // follower.set_filter_mode(Some(MultiBufferFilterMode::KeepDeletions));
572 // });
573
574 // leader.update(cx, |leader, cx| {
575 // leader.insert_excerpts_after(
576 // ExcerptId::min(),
577 // extra_buffer_2.clone(),
578 // vec![ExcerptRange::new(text::Anchor::MIN..text::Anchor::MAX)],
579 // cx,
580 // );
581 // leader.add_diff(extra_diff_2.clone(), cx);
582
583 // leader.insert_excerpts_after(
584 // ExcerptId::min(),
585 // extra_buffer_1.clone(),
586 // vec![ExcerptRange::new(text::Anchor::MIN..text::Anchor::MAX)],
587 // cx,
588 // );
589 // leader.add_diff(extra_diff_1.clone(), cx);
590
591 // leader.insert_excerpts_after(
592 // ExcerptId::min(),
593 // buffer1.clone(),
594 // vec![ExcerptRange::new(text::Anchor::MIN..text::Anchor::MAX)],
595 // cx,
596 // );
597 // leader.add_diff(diff1.clone(), cx);
598 // });
599
600 // cx.run_until_parked();
601 // let mut cx = cx.add_empty_window();
602
603 // let leader_editor = cx
604 // .new_window_entity(|window, cx| Editor::for_multibuffer(leader.clone(), None, window, cx));
605 // let follower_editor = cx.new_window_entity(|window, cx| {
606 // Editor::for_multibuffer(follower.clone(), None, window, cx)
607 // });
608
609 // let mut leader_cx = EditorTestContext::for_editor_in(leader_editor.clone(), &mut cx).await;
610 // leader_cx.assert_editor_state(indoc! {"
611 // ˇbuffer
612
613 // dummy text 1
614
615 // dummy text 2
616 // "});
617 // let mut follower_cx = EditorTestContext::for_editor_in(follower_editor.clone(), &mut cx).await;
618 // follower_cx.assert_editor_state(indoc! {"
619 // ˇbase
620
621 // "});
622 // }
623}