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