409 lines
13 KiB
Rust
409 lines
13 KiB
Rust
use super::{ItemViewHandle, SplitDirection};
|
|
use crate::{settings::Settings, theme};
|
|
use gpui::{
|
|
color::Color,
|
|
elements::*,
|
|
geometry::{rect::RectF, vector::vec2f},
|
|
keymap::Binding,
|
|
AppContext, Border, Entity, MutableAppContext, Quad, RenderContext, View, ViewContext,
|
|
ViewHandle,
|
|
};
|
|
use postage::watch;
|
|
use std::{cmp, path::Path, sync::Arc};
|
|
|
|
pub fn init(cx: &mut MutableAppContext) {
|
|
cx.add_action(
|
|
"pane:activate_item",
|
|
|pane: &mut Pane, index: &usize, cx| {
|
|
pane.activate_item(*index, cx);
|
|
},
|
|
);
|
|
cx.add_action("pane:activate_prev_item", |pane: &mut Pane, _: &(), cx| {
|
|
pane.activate_prev_item(cx);
|
|
});
|
|
cx.add_action("pane:activate_next_item", |pane: &mut Pane, _: &(), cx| {
|
|
pane.activate_next_item(cx);
|
|
});
|
|
cx.add_action("pane:close_active_item", |pane: &mut Pane, _: &(), cx| {
|
|
pane.close_active_item(cx);
|
|
});
|
|
cx.add_action("pane:close_item", |pane: &mut Pane, item_id: &usize, cx| {
|
|
pane.close_item(*item_id, cx);
|
|
});
|
|
cx.add_action("pane:split_up", |pane: &mut Pane, _: &(), cx| {
|
|
pane.split(SplitDirection::Up, cx);
|
|
});
|
|
cx.add_action("pane:split_down", |pane: &mut Pane, _: &(), cx| {
|
|
pane.split(SplitDirection::Down, cx);
|
|
});
|
|
cx.add_action("pane:split_left", |pane: &mut Pane, _: &(), cx| {
|
|
pane.split(SplitDirection::Left, cx);
|
|
});
|
|
cx.add_action("pane:split_right", |pane: &mut Pane, _: &(), cx| {
|
|
pane.split(SplitDirection::Right, cx);
|
|
});
|
|
|
|
cx.add_bindings(vec![
|
|
Binding::new("shift-cmd-{", "pane:activate_prev_item", Some("Pane")),
|
|
Binding::new("shift-cmd-}", "pane:activate_next_item", Some("Pane")),
|
|
Binding::new("cmd-w", "pane:close_active_item", Some("Pane")),
|
|
Binding::new("cmd-k up", "pane:split_up", Some("Pane")),
|
|
Binding::new("cmd-k down", "pane:split_down", Some("Pane")),
|
|
Binding::new("cmd-k left", "pane:split_left", Some("Pane")),
|
|
Binding::new("cmd-k right", "pane:split_right", Some("Pane")),
|
|
]);
|
|
}
|
|
|
|
pub enum Event {
|
|
Activate,
|
|
Remove,
|
|
Split(SplitDirection),
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
pub struct State {
|
|
pub tabs: Vec<TabState>,
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
pub struct TabState {
|
|
pub title: String,
|
|
pub active: bool,
|
|
}
|
|
|
|
pub struct Pane {
|
|
items: Vec<Box<dyn ItemViewHandle>>,
|
|
active_item: usize,
|
|
settings: watch::Receiver<Settings>,
|
|
}
|
|
|
|
impl Pane {
|
|
pub fn new(settings: watch::Receiver<Settings>) -> Self {
|
|
Self {
|
|
items: Vec::new(),
|
|
active_item: 0,
|
|
settings,
|
|
}
|
|
}
|
|
|
|
pub fn activate(&self, cx: &mut ViewContext<Self>) {
|
|
cx.emit(Event::Activate);
|
|
}
|
|
|
|
pub fn add_item(&mut self, item: Box<dyn ItemViewHandle>, cx: &mut ViewContext<Self>) -> usize {
|
|
let item_idx = cmp::min(self.active_item + 1, self.items.len());
|
|
self.items.insert(item_idx, item);
|
|
cx.notify();
|
|
item_idx
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub fn items(&self) -> &[Box<dyn ItemViewHandle>] {
|
|
&self.items
|
|
}
|
|
|
|
pub fn active_item(&self) -> Option<Box<dyn ItemViewHandle>> {
|
|
self.items.get(self.active_item).cloned()
|
|
}
|
|
|
|
pub fn activate_entry(
|
|
&mut self,
|
|
entry_id: (usize, Arc<Path>),
|
|
cx: &mut ViewContext<Self>,
|
|
) -> bool {
|
|
if let Some(index) = self.items.iter().position(|item| {
|
|
item.entry_id(cx.as_ref())
|
|
.map_or(false, |id| id == entry_id)
|
|
}) {
|
|
self.activate_item(index, cx);
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
pub fn item_index(&self, item: &dyn ItemViewHandle) -> Option<usize> {
|
|
self.items.iter().position(|i| i.id() == item.id())
|
|
}
|
|
|
|
pub fn activate_item(&mut self, index: usize, cx: &mut ViewContext<Self>) {
|
|
if index < self.items.len() {
|
|
self.active_item = index;
|
|
self.focus_active_item(cx);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
pub fn activate_prev_item(&mut self, cx: &mut ViewContext<Self>) {
|
|
if self.active_item > 0 {
|
|
self.active_item -= 1;
|
|
} else if self.items.len() > 0 {
|
|
self.active_item = self.items.len() - 1;
|
|
}
|
|
self.focus_active_item(cx);
|
|
cx.notify();
|
|
}
|
|
|
|
pub fn activate_next_item(&mut self, cx: &mut ViewContext<Self>) {
|
|
if self.active_item + 1 < self.items.len() {
|
|
self.active_item += 1;
|
|
} else {
|
|
self.active_item = 0;
|
|
}
|
|
self.focus_active_item(cx);
|
|
cx.notify();
|
|
}
|
|
|
|
pub fn close_active_item(&mut self, cx: &mut ViewContext<Self>) {
|
|
if !self.items.is_empty() {
|
|
self.close_item(self.items[self.active_item].id(), cx)
|
|
}
|
|
}
|
|
|
|
pub fn close_item(&mut self, item_id: usize, cx: &mut ViewContext<Self>) {
|
|
self.items.retain(|item| item.id() != item_id);
|
|
self.active_item = cmp::min(self.active_item, self.items.len().saturating_sub(1));
|
|
if self.items.is_empty() {
|
|
cx.emit(Event::Remove);
|
|
}
|
|
cx.notify();
|
|
}
|
|
|
|
fn focus_active_item(&mut self, cx: &mut ViewContext<Self>) {
|
|
if let Some(active_item) = self.active_item() {
|
|
cx.focus(active_item.to_any());
|
|
}
|
|
}
|
|
|
|
pub fn split(&mut self, direction: SplitDirection, cx: &mut ViewContext<Self>) {
|
|
cx.emit(Event::Split(direction));
|
|
}
|
|
|
|
fn render_tabs(&self, cx: &AppContext) -> ElementBox {
|
|
let settings = self.settings.borrow();
|
|
let theme = &settings.theme.ui;
|
|
let line_height = cx.font_cache().line_height(
|
|
cx.font_cache().default_font(settings.ui_font_family),
|
|
settings.ui_font_size,
|
|
);
|
|
|
|
let mut row = Flex::row();
|
|
let last_item_ix = self.items.len() - 1;
|
|
for (ix, item) in self.items.iter().enumerate() {
|
|
let is_active = ix == self.active_item;
|
|
|
|
enum Tab {}
|
|
let border = &theme.tab.container.border;
|
|
|
|
row.add_child(
|
|
Expanded::new(
|
|
1.0,
|
|
MouseEventHandler::new::<Tab, _>(item.id(), cx, |mouse_state| {
|
|
let title = item.title(cx);
|
|
|
|
let mut border = border.clone();
|
|
border.left = ix > 0;
|
|
border.right = ix == last_item_ix;
|
|
border.bottom = !is_active;
|
|
|
|
let mut container = Container::new(
|
|
Stack::new()
|
|
.with_child(
|
|
Align::new(
|
|
Label::new(
|
|
title,
|
|
settings.ui_font_family,
|
|
settings.ui_font_size,
|
|
)
|
|
.with_style(if is_active {
|
|
&theme.active_tab.label
|
|
} else {
|
|
&theme.tab.label
|
|
})
|
|
.boxed(),
|
|
)
|
|
.boxed(),
|
|
)
|
|
.with_child(
|
|
Align::new(Self::render_tab_icon(
|
|
item.id(),
|
|
line_height - 2.,
|
|
mouse_state.hovered,
|
|
item.is_dirty(cx),
|
|
item.has_conflict(cx),
|
|
theme,
|
|
cx,
|
|
))
|
|
.right()
|
|
.boxed(),
|
|
)
|
|
.boxed(),
|
|
)
|
|
.with_style(if is_active {
|
|
&theme.active_tab.container
|
|
} else {
|
|
&theme.tab.container
|
|
})
|
|
.with_horizontal_padding(10.)
|
|
.with_border(border);
|
|
|
|
if is_active {
|
|
container = container.with_padding_bottom(border.width);
|
|
}
|
|
|
|
ConstrainedBox::new(
|
|
EventHandler::new(container.boxed())
|
|
.on_mouse_down(move |cx| {
|
|
cx.dispatch_action("pane:activate_item", ix);
|
|
true
|
|
})
|
|
.boxed(),
|
|
)
|
|
.with_min_width(80.0)
|
|
.with_max_width(264.0)
|
|
.boxed()
|
|
})
|
|
.boxed(),
|
|
)
|
|
.named("tab"),
|
|
);
|
|
}
|
|
|
|
// Ensure there's always a minimum amount of space after the last tab,
|
|
// so that the tab's border doesn't abut the window's border.
|
|
let mut border = Border::bottom(1.0, Color::default());
|
|
border.color = theme.tab.container.border.color;
|
|
|
|
row.add_child(
|
|
ConstrainedBox::new(
|
|
Container::new(Empty::new().boxed())
|
|
.with_border(border)
|
|
.boxed(),
|
|
)
|
|
.with_min_width(20.)
|
|
.named("fixed-filler"),
|
|
);
|
|
|
|
row.add_child(
|
|
Expanded::new(
|
|
0.0,
|
|
Container::new(Empty::new().boxed())
|
|
.with_border(border)
|
|
.boxed(),
|
|
)
|
|
.named("filler"),
|
|
);
|
|
|
|
ConstrainedBox::new(row.boxed())
|
|
.with_height(line_height + 16.)
|
|
.named("tabs")
|
|
}
|
|
|
|
fn render_tab_icon(
|
|
item_id: usize,
|
|
close_icon_size: f32,
|
|
tab_hovered: bool,
|
|
is_dirty: bool,
|
|
has_conflict: bool,
|
|
theme: &theme::Ui,
|
|
cx: &AppContext,
|
|
) -> ElementBox {
|
|
enum TabCloseButton {}
|
|
|
|
let mut clicked_color = theme.tab.icon_dirty;
|
|
clicked_color.a = 180;
|
|
|
|
let current_color = if has_conflict {
|
|
Some(theme.tab.icon_conflict)
|
|
} else if is_dirty {
|
|
Some(theme.tab.icon_dirty)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let icon = if tab_hovered {
|
|
let close_color = current_color.unwrap_or(theme.tab.icon_close);
|
|
let icon = Svg::new("icons/x.svg").with_color(close_color);
|
|
|
|
MouseEventHandler::new::<TabCloseButton, _>(item_id, cx, |mouse_state| {
|
|
if mouse_state.hovered {
|
|
Container::new(icon.with_color(Color::white()).boxed())
|
|
.with_background_color(if mouse_state.clicked {
|
|
clicked_color
|
|
} else {
|
|
theme.tab.icon_dirty
|
|
})
|
|
.with_corner_radius(close_icon_size / 2.)
|
|
.boxed()
|
|
} else {
|
|
icon.boxed()
|
|
}
|
|
})
|
|
.on_click(move |cx| cx.dispatch_action("pane:close_item", item_id))
|
|
.named("close-tab-icon")
|
|
} else {
|
|
let diameter = 8.;
|
|
ConstrainedBox::new(
|
|
Canvas::new(move |bounds, cx| {
|
|
if let Some(current_color) = current_color {
|
|
let square = RectF::new(bounds.origin(), vec2f(diameter, diameter));
|
|
cx.scene.push_quad(Quad {
|
|
bounds: square,
|
|
background: Some(current_color),
|
|
border: Default::default(),
|
|
corner_radius: diameter / 2.,
|
|
});
|
|
}
|
|
})
|
|
.boxed(),
|
|
)
|
|
.with_width(diameter)
|
|
.with_height(diameter)
|
|
.named("unsaved-tab-icon")
|
|
};
|
|
|
|
ConstrainedBox::new(Align::new(icon).boxed())
|
|
.with_width(close_icon_size)
|
|
.named("tab-icon")
|
|
}
|
|
}
|
|
|
|
impl Entity for Pane {
|
|
type Event = Event;
|
|
}
|
|
|
|
impl View for Pane {
|
|
fn ui_name() -> &'static str {
|
|
"Pane"
|
|
}
|
|
|
|
fn render<'a>(&self, cx: &RenderContext<Self>) -> ElementBox {
|
|
if let Some(active_item) = self.active_item() {
|
|
Flex::column()
|
|
.with_child(self.render_tabs(cx))
|
|
.with_child(Expanded::new(1.0, ChildView::new(active_item.id()).boxed()).boxed())
|
|
.named("pane")
|
|
} else {
|
|
Empty::new().named("pane")
|
|
}
|
|
}
|
|
|
|
fn on_focus(&mut self, cx: &mut ViewContext<Self>) {
|
|
self.focus_active_item(cx);
|
|
}
|
|
}
|
|
|
|
pub trait PaneHandle {
|
|
fn add_item_view(&self, item: Box<dyn ItemViewHandle>, cx: &mut MutableAppContext);
|
|
}
|
|
|
|
impl PaneHandle for ViewHandle<Pane> {
|
|
fn add_item_view(&self, item: Box<dyn ItemViewHandle>, cx: &mut MutableAppContext) {
|
|
item.set_parent_pane(self, cx);
|
|
self.update(cx, |pane, cx| {
|
|
let item_idx = pane.add_item(item, cx);
|
|
pane.activate_item(item_idx, cx);
|
|
});
|
|
}
|
|
}
|