1use super::{ItemViewHandle, SplitDirection};
2use crate::{ItemHandle, ItemView, Settings, WeakItemViewHandle, Workspace};
3use collections::HashMap;
4use gpui::{
5 action,
6 elements::*,
7 geometry::{rect::RectF, vector::vec2f},
8 keymap::Binding,
9 platform::CursorStyle,
10 Entity, MutableAppContext, Quad, RenderContext, Task, View, ViewContext, ViewHandle,
11};
12use postage::watch;
13use project::ProjectPath;
14use std::{
15 any::Any,
16 cell::RefCell,
17 cmp, mem,
18 rc::Rc,
19 time::{Duration, Instant},
20};
21use util::ResultExt;
22
23action!(Split, SplitDirection);
24action!(ActivateItem, usize);
25action!(ActivatePrevItem);
26action!(ActivateNextItem);
27action!(CloseActiveItem);
28action!(CloseItem, usize);
29action!(GoBack);
30action!(GoForward);
31
32pub fn init(cx: &mut MutableAppContext) {
33 cx.add_action(|pane: &mut Pane, action: &ActivateItem, cx| {
34 pane.activate_item(action.0, cx);
35 });
36 cx.add_action(|pane: &mut Pane, _: &ActivatePrevItem, cx| {
37 pane.activate_prev_item(cx);
38 });
39 cx.add_action(|pane: &mut Pane, _: &ActivateNextItem, cx| {
40 pane.activate_next_item(cx);
41 });
42 cx.add_action(|pane: &mut Pane, _: &CloseActiveItem, cx| {
43 pane.close_active_item(cx);
44 });
45 cx.add_action(|pane: &mut Pane, action: &CloseItem, cx| {
46 pane.close_item(action.0, cx);
47 });
48 cx.add_action(|pane: &mut Pane, action: &Split, cx| {
49 pane.split(action.0, cx);
50 });
51 cx.add_action(|workspace: &mut Workspace, _: &GoBack, cx| {
52 Pane::go_back(workspace, cx).detach();
53 });
54 cx.add_action(|workspace: &mut Workspace, _: &GoForward, cx| {
55 Pane::go_forward(workspace, cx).detach();
56 });
57
58 cx.add_bindings(vec![
59 Binding::new("shift-cmd-{", ActivatePrevItem, Some("Pane")),
60 Binding::new("shift-cmd-}", ActivateNextItem, Some("Pane")),
61 Binding::new("cmd-w", CloseActiveItem, Some("Pane")),
62 Binding::new("cmd-k up", Split(SplitDirection::Up), Some("Pane")),
63 Binding::new("cmd-k down", Split(SplitDirection::Down), Some("Pane")),
64 Binding::new("cmd-k left", Split(SplitDirection::Left), Some("Pane")),
65 Binding::new("cmd-k right", Split(SplitDirection::Right), Some("Pane")),
66 Binding::new("ctrl--", GoBack, Some("Pane")),
67 Binding::new("shift-ctrl-_", GoForward, Some("Pane")),
68 ]);
69}
70
71pub enum Event {
72 Activate,
73 Remove,
74 Split(SplitDirection),
75}
76
77const MAX_TAB_TITLE_LEN: usize = 24;
78
79pub struct Pane {
80 item_views: Vec<(usize, Box<dyn ItemViewHandle>)>,
81 active_item_index: usize,
82 settings: watch::Receiver<Settings>,
83 navigation: Rc<Navigation>,
84}
85
86#[derive(Default)]
87pub struct Navigation(RefCell<NavigationHistory>);
88
89#[derive(Default)]
90struct NavigationHistory {
91 mode: NavigationMode,
92 backward_stack: Vec<NavigationEntry>,
93 forward_stack: Vec<NavigationEntry>,
94 paths_by_item: HashMap<usize, ProjectPath>,
95}
96
97#[derive(Copy, Clone)]
98enum NavigationMode {
99 Normal,
100 GoingBack,
101 GoingForward,
102}
103
104impl Default for NavigationMode {
105 fn default() -> Self {
106 Self::Normal
107 }
108}
109
110struct NavigationEntry {
111 item_view: Box<dyn WeakItemViewHandle>,
112 data: Option<Box<dyn Any>>,
113 insertion_time: Option<Instant>,
114}
115
116impl Pane {
117 pub fn new(settings: watch::Receiver<Settings>) -> Self {
118 Self {
119 item_views: Vec::new(),
120 active_item_index: 0,
121 settings,
122 navigation: Default::default(),
123 }
124 }
125
126 pub fn activate(&self, cx: &mut ViewContext<Self>) {
127 cx.emit(Event::Activate);
128 }
129
130 pub fn go_back(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) -> Task<()> {
131 Self::navigate_history(
132 workspace,
133 workspace.active_pane().clone(),
134 NavigationMode::GoingBack,
135 cx,
136 )
137 }
138
139 pub fn go_forward(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) -> Task<()> {
140 Self::navigate_history(
141 workspace,
142 workspace.active_pane().clone(),
143 NavigationMode::GoingForward,
144 cx,
145 )
146 }
147
148 fn navigate_history(
149 workspace: &mut Workspace,
150 pane: ViewHandle<Pane>,
151 mode: NavigationMode,
152 cx: &mut ViewContext<Workspace>,
153 ) -> Task<()> {
154 let to_load = pane.update(cx, |pane, cx| {
155 // Retrieve the weak item handle from the history.
156 let entry = pane.navigation.pop(mode)?;
157
158 // If the item is still present in this pane, then activate it.
159 if let Some(index) = entry
160 .item_view
161 .upgrade(cx)
162 .and_then(|v| pane.index_for_item_view(v.as_ref()))
163 {
164 if let Some(item_view) = pane.active_item() {
165 pane.navigation.set_mode(mode);
166 item_view.deactivated(cx);
167 pane.navigation.set_mode(NavigationMode::Normal);
168 }
169
170 pane.active_item_index = index;
171 pane.focus_active_item(cx);
172 if let Some(data) = entry.data {
173 pane.active_item()?.navigate(data, cx);
174 }
175 cx.notify();
176 None
177 }
178 // If the item is no longer present in this pane, then retrieve its
179 // project path in order to reopen it.
180 else {
181 pane.navigation
182 .0
183 .borrow_mut()
184 .paths_by_item
185 .get(&entry.item_view.id())
186 .cloned()
187 .map(|project_path| (project_path, entry))
188 }
189 });
190
191 if let Some((project_path, entry)) = to_load {
192 // If the item was no longer present, then load it again from its previous path.
193 let pane = pane.downgrade();
194 let task = workspace.load_path(project_path, cx);
195 cx.spawn(|workspace, mut cx| async move {
196 let item = task.await;
197 if let Some(pane) = cx.read(|cx| pane.upgrade(cx)) {
198 if let Some(item) = item.log_err() {
199 workspace.update(&mut cx, |workspace, cx| {
200 pane.update(cx, |p, _| p.navigation.set_mode(mode));
201 let item_view = workspace.open_item_in_pane(item, &pane, cx);
202 pane.update(cx, |p, _| p.navigation.set_mode(NavigationMode::Normal));
203
204 if let Some(data) = entry.data {
205 item_view.navigate(data, cx);
206 }
207 });
208 } else {
209 workspace
210 .update(&mut cx, |workspace, cx| {
211 Self::navigate_history(workspace, pane, mode, cx)
212 })
213 .await;
214 }
215 }
216 })
217 } else {
218 Task::ready(())
219 }
220 }
221
222 pub fn open_item<T>(
223 &mut self,
224 item_handle: T,
225 workspace: &Workspace,
226 cx: &mut ViewContext<Self>,
227 ) -> Box<dyn ItemViewHandle>
228 where
229 T: 'static + ItemHandle,
230 {
231 for (ix, (item_id, item_view)) in self.item_views.iter().enumerate() {
232 if *item_id == item_handle.id() {
233 let item_view = item_view.boxed_clone();
234 self.activate_item(ix, cx);
235 return item_view;
236 }
237 }
238
239 let item_view =
240 item_handle.add_view(cx.window_id(), workspace, self.navigation.clone(), cx);
241 self.add_item_view(item_view.boxed_clone(), cx);
242 item_view
243 }
244
245 pub fn add_item_view(
246 &mut self,
247 mut item_view: Box<dyn ItemViewHandle>,
248 cx: &mut ViewContext<Self>,
249 ) {
250 item_view.added_to_pane(cx);
251 let item_idx = cmp::min(self.active_item_index + 1, self.item_views.len());
252 self.item_views
253 .insert(item_idx, (item_view.item_handle(cx).id(), item_view));
254 self.activate_item(item_idx, cx);
255 cx.notify();
256 }
257
258 pub fn contains_item(&self, item: &dyn ItemHandle) -> bool {
259 let item_id = item.id();
260 self.item_views
261 .iter()
262 .any(|(existing_item_id, _)| *existing_item_id == item_id)
263 }
264
265 pub fn item_views(&self) -> impl Iterator<Item = &Box<dyn ItemViewHandle>> {
266 self.item_views.iter().map(|(_, view)| view)
267 }
268
269 pub fn active_item(&self) -> Option<Box<dyn ItemViewHandle>> {
270 self.item_views
271 .get(self.active_item_index)
272 .map(|(_, view)| view.clone())
273 }
274
275 pub fn index_for_item_view(&self, item_view: &dyn ItemViewHandle) -> Option<usize> {
276 self.item_views
277 .iter()
278 .position(|(_, i)| i.id() == item_view.id())
279 }
280
281 pub fn index_for_item(&self, item: &dyn ItemHandle) -> Option<usize> {
282 self.item_views.iter().position(|(id, _)| *id == item.id())
283 }
284
285 pub fn activate_item(&mut self, index: usize, cx: &mut ViewContext<Self>) {
286 if index < self.item_views.len() {
287 let prev_active_item_ix = mem::replace(&mut self.active_item_index, index);
288 if prev_active_item_ix != self.active_item_index {
289 self.item_views[prev_active_item_ix].1.deactivated(cx);
290 }
291 self.focus_active_item(cx);
292 cx.notify();
293 }
294 }
295
296 pub fn activate_prev_item(&mut self, cx: &mut ViewContext<Self>) {
297 let mut index = self.active_item_index;
298 if index > 0 {
299 index -= 1;
300 } else if self.item_views.len() > 0 {
301 index = self.item_views.len() - 1;
302 }
303 self.activate_item(index, cx);
304 }
305
306 pub fn activate_next_item(&mut self, cx: &mut ViewContext<Self>) {
307 let mut index = self.active_item_index;
308 if index + 1 < self.item_views.len() {
309 index += 1;
310 } else {
311 index = 0;
312 }
313 self.activate_item(index, cx);
314 }
315
316 pub fn close_active_item(&mut self, cx: &mut ViewContext<Self>) {
317 if !self.item_views.is_empty() {
318 self.close_item(self.item_views[self.active_item_index].1.id(), cx)
319 }
320 }
321
322 pub fn close_item(&mut self, item_view_id: usize, cx: &mut ViewContext<Self>) {
323 let mut item_ix = 0;
324 self.item_views.retain(|(_, item_view)| {
325 if item_view.id() == item_view_id {
326 if item_ix == self.active_item_index {
327 item_view.deactivated(cx);
328 }
329
330 let mut navigation = self.navigation.0.borrow_mut();
331 if let Some(path) = item_view.project_path(cx) {
332 navigation.paths_by_item.insert(item_view.id(), path);
333 } else {
334 navigation.paths_by_item.remove(&item_view.id());
335 }
336
337 item_ix += 1;
338 false
339 } else {
340 item_ix += 1;
341 true
342 }
343 });
344 self.active_item_index = cmp::min(
345 self.active_item_index,
346 self.item_views.len().saturating_sub(1),
347 );
348
349 if self.item_views.is_empty() {
350 cx.emit(Event::Remove);
351 }
352 cx.notify();
353 }
354
355 fn focus_active_item(&mut self, cx: &mut ViewContext<Self>) {
356 if let Some(active_item) = self.active_item() {
357 cx.focus(active_item.to_any());
358 }
359 }
360
361 pub fn split(&mut self, direction: SplitDirection, cx: &mut ViewContext<Self>) {
362 cx.emit(Event::Split(direction));
363 }
364
365 fn render_tabs(&self, cx: &mut RenderContext<Self>) -> ElementBox {
366 let settings = self.settings.borrow();
367 let theme = &settings.theme;
368
369 enum Tabs {}
370 let tabs = MouseEventHandler::new::<Tabs, _, _, _>(cx.view_id(), cx, |mouse_state, cx| {
371 let mut row = Flex::row();
372 for (ix, (_, item_view)) in self.item_views.iter().enumerate() {
373 let is_active = ix == self.active_item_index;
374
375 row.add_child({
376 let mut title = item_view.title(cx);
377 if title.len() > MAX_TAB_TITLE_LEN {
378 let mut truncated_len = MAX_TAB_TITLE_LEN;
379 while !title.is_char_boundary(truncated_len) {
380 truncated_len -= 1;
381 }
382 title.truncate(truncated_len);
383 title.push('…');
384 }
385
386 let mut style = if is_active {
387 theme.workspace.active_tab.clone()
388 } else {
389 theme.workspace.tab.clone()
390 };
391 if ix == 0 {
392 style.container.border.left = false;
393 }
394
395 EventHandler::new(
396 Container::new(
397 Flex::row()
398 .with_child(
399 Align::new({
400 let diameter = 7.0;
401 let icon_color = if item_view.has_conflict(cx) {
402 Some(style.icon_conflict)
403 } else if item_view.is_dirty(cx) {
404 Some(style.icon_dirty)
405 } else {
406 None
407 };
408
409 ConstrainedBox::new(
410 Canvas::new(move |bounds, _, cx| {
411 if let Some(color) = icon_color {
412 let square = RectF::new(
413 bounds.origin(),
414 vec2f(diameter, diameter),
415 );
416 cx.scene.push_quad(Quad {
417 bounds: square,
418 background: Some(color),
419 border: Default::default(),
420 corner_radius: diameter / 2.,
421 });
422 }
423 })
424 .boxed(),
425 )
426 .with_width(diameter)
427 .with_height(diameter)
428 .boxed()
429 })
430 .boxed(),
431 )
432 .with_child(
433 Container::new(
434 Align::new(
435 Label::new(
436 title,
437 if is_active {
438 theme.workspace.active_tab.label.clone()
439 } else {
440 theme.workspace.tab.label.clone()
441 },
442 )
443 .boxed(),
444 )
445 .boxed(),
446 )
447 .with_style(ContainerStyle {
448 margin: Margin {
449 left: style.spacing,
450 right: style.spacing,
451 ..Default::default()
452 },
453 ..Default::default()
454 })
455 .boxed(),
456 )
457 .with_child(
458 Align::new(
459 ConstrainedBox::new(if mouse_state.hovered {
460 let item_id = item_view.id();
461 enum TabCloseButton {}
462 let icon = Svg::new("icons/x.svg");
463 MouseEventHandler::new::<TabCloseButton, _, _, _>(
464 item_id,
465 cx,
466 |mouse_state, _| {
467 if mouse_state.hovered {
468 icon.with_color(style.icon_close_active)
469 .boxed()
470 } else {
471 icon.with_color(style.icon_close).boxed()
472 }
473 },
474 )
475 .with_padding(Padding::uniform(4.))
476 .with_cursor_style(CursorStyle::PointingHand)
477 .on_click(move |cx| {
478 cx.dispatch_action(CloseItem(item_id))
479 })
480 .named("close-tab-icon")
481 } else {
482 Empty::new().boxed()
483 })
484 .with_width(style.icon_width)
485 .boxed(),
486 )
487 .boxed(),
488 )
489 .boxed(),
490 )
491 .with_style(style.container)
492 .boxed(),
493 )
494 .on_mouse_down(move |cx| {
495 cx.dispatch_action(ActivateItem(ix));
496 true
497 })
498 .boxed()
499 })
500 }
501
502 row.add_child(
503 Empty::new()
504 .contained()
505 .with_border(theme.workspace.tab.container.border)
506 .flexible(0., true)
507 .named("filler"),
508 );
509
510 row.boxed()
511 });
512
513 ConstrainedBox::new(tabs.boxed())
514 .with_height(theme.workspace.tab.height)
515 .named("tabs")
516 }
517}
518
519impl Entity for Pane {
520 type Event = Event;
521}
522
523impl View for Pane {
524 fn ui_name() -> &'static str {
525 "Pane"
526 }
527
528 fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
529 if let Some(active_item) = self.active_item() {
530 Flex::column()
531 .with_child(self.render_tabs(cx))
532 .with_child(ChildView::new(active_item.id()).flexible(1., true).boxed())
533 .named("pane")
534 } else {
535 Empty::new().named("pane")
536 }
537 }
538
539 fn on_focus(&mut self, cx: &mut ViewContext<Self>) {
540 self.focus_active_item(cx);
541 }
542}
543
544impl Navigation {
545 fn pop(&self, mode: NavigationMode) -> Option<NavigationEntry> {
546 match mode {
547 NavigationMode::Normal => None,
548 NavigationMode::GoingBack => self.0.borrow_mut().backward_stack.pop(),
549 NavigationMode::GoingForward => self.0.borrow_mut().forward_stack.pop(),
550 }
551 }
552
553 fn set_mode(&self, mode: NavigationMode) {
554 self.0.borrow_mut().mode = mode;
555 }
556
557 pub fn push<D: 'static + Any, T: ItemView>(&self, data: Option<D>, cx: &mut ViewContext<T>) {
558 let mut state = self.0.borrow_mut();
559 match state.mode {
560 NavigationMode::Normal => {
561 let mut insertion_time = Instant::now();
562 if let Some(prev_insertion_time) =
563 state.backward_stack.last().and_then(|e| e.insertion_time)
564 {
565 if insertion_time.duration_since(prev_insertion_time) <= Duration::from_secs(2)
566 {
567 state.backward_stack.pop();
568 insertion_time = prev_insertion_time;
569 }
570 }
571 state.backward_stack.push(NavigationEntry {
572 item_view: Box::new(cx.weak_handle()),
573 data: data.map(|data| Box::new(data) as Box<dyn Any>),
574 insertion_time: Some(insertion_time),
575 });
576 state.forward_stack.clear();
577 }
578 NavigationMode::GoingBack => {
579 state.forward_stack.push(NavigationEntry {
580 item_view: Box::new(cx.weak_handle()),
581 data: data.map(|data| Box::new(data) as Box<dyn Any>),
582 insertion_time: None,
583 });
584 }
585 NavigationMode::GoingForward => {
586 state.backward_stack.push(NavigationEntry {
587 item_view: Box::new(cx.weak_handle()),
588 data: data.map(|data| Box::new(data) as Box<dyn Any>),
589 insertion_time: None,
590 });
591 }
592 }
593 }
594}