ca4e8043d4
This PR adds the branch selector to the git panel and fixes a few bugs in the repository selector. Release Notes: - N/A --------- Co-authored-by: ConradIrwin <conrad.irwin@gmail.com> Co-authored-by: Conrad <conrad@zed.dev>
1792 lines
62 KiB
Rust
1792 lines
62 KiB
Rust
use crate::git_panel_settings::StatusStyle;
|
|
use crate::repository_selector::RepositorySelectorPopoverMenu;
|
|
use crate::ProjectDiff;
|
|
use crate::{
|
|
git_panel_settings::GitPanelSettings, git_status_icon, repository_selector::RepositorySelector,
|
|
};
|
|
use collections::HashMap;
|
|
use db::kvp::KEY_VALUE_STORE;
|
|
use editor::actions::MoveToEnd;
|
|
use editor::scroll::ScrollbarAutoHide;
|
|
use editor::{Editor, EditorMode, EditorSettings, MultiBuffer, ShowScrollbar};
|
|
use git::repository::RepoPath;
|
|
use git::status::FileStatus;
|
|
use git::{Commit, ToggleStaged};
|
|
use gpui::*;
|
|
use language::{Buffer, File};
|
|
use menu::{SelectFirst, SelectLast, SelectNext, SelectPrev};
|
|
use multi_buffer::ExcerptInfo;
|
|
use panel::PanelHeader;
|
|
use project::git::{GitEvent, Repository};
|
|
use project::{Fs, Project, ProjectPath};
|
|
use serde::{Deserialize, Serialize};
|
|
use settings::Settings as _;
|
|
use std::{collections::HashSet, path::PathBuf, sync::Arc, time::Duration, usize};
|
|
use theme::ThemeSettings;
|
|
use ui::{
|
|
prelude::*, ButtonLike, Checkbox, Divider, DividerColor, ElevationIndex, IndentGuideColors,
|
|
ListItem, ListItemSpacing, Scrollbar, ScrollbarState, Tooltip,
|
|
};
|
|
use util::{maybe, ResultExt, TryFutureExt};
|
|
use workspace::notifications::{DetachAndPromptErr, NotificationId};
|
|
use workspace::Toast;
|
|
use workspace::{
|
|
dock::{DockPosition, Panel, PanelEvent},
|
|
Workspace,
|
|
};
|
|
|
|
actions!(
|
|
git_panel,
|
|
[
|
|
Close,
|
|
ToggleFocus,
|
|
OpenMenu,
|
|
FocusEditor,
|
|
FocusChanges,
|
|
FillCoAuthors,
|
|
]
|
|
);
|
|
|
|
const GIT_PANEL_KEY: &str = "GitPanel";
|
|
|
|
const UPDATE_DEBOUNCE: Duration = Duration::from_millis(50);
|
|
|
|
pub fn init(cx: &mut App) {
|
|
cx.observe_new(
|
|
|workspace: &mut Workspace, _window, _cx: &mut Context<Workspace>| {
|
|
workspace.register_action(|workspace, _: &ToggleFocus, window, cx| {
|
|
workspace.toggle_panel_focus::<GitPanel>(window, cx);
|
|
});
|
|
|
|
workspace.register_action(|workspace, _: &Commit, window, cx| {
|
|
workspace.open_panel::<GitPanel>(window, cx);
|
|
if let Some(git_panel) = workspace.panel::<GitPanel>(cx) {
|
|
git_panel
|
|
.read(cx)
|
|
.commit_editor
|
|
.focus_handle(cx)
|
|
.focus(window);
|
|
}
|
|
});
|
|
},
|
|
)
|
|
.detach();
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Event {
|
|
Focus,
|
|
OpenedEntry { path: ProjectPath },
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
struct SerializedGitPanel {
|
|
width: Option<Pixels>,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
|
enum Section {
|
|
Conflict,
|
|
Tracked,
|
|
New,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone)]
|
|
struct GitHeaderEntry {
|
|
header: Section,
|
|
}
|
|
|
|
impl GitHeaderEntry {
|
|
pub fn contains(&self, status_entry: &GitStatusEntry, repo: &Repository) -> bool {
|
|
let this = &self.header;
|
|
let status = status_entry.status;
|
|
match this {
|
|
Section::Conflict => repo.has_conflict(&status_entry.repo_path),
|
|
Section::Tracked => !status.is_created(),
|
|
Section::New => status.is_created(),
|
|
}
|
|
}
|
|
pub fn title(&self) -> &'static str {
|
|
match self.header {
|
|
Section::Conflict => "Conflicts",
|
|
Section::Tracked => "Changed",
|
|
Section::New => "New",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone)]
|
|
enum GitListEntry {
|
|
GitStatusEntry(GitStatusEntry),
|
|
Header(GitHeaderEntry),
|
|
}
|
|
|
|
impl GitListEntry {
|
|
fn status_entry(&self) -> Option<&GitStatusEntry> {
|
|
match self {
|
|
GitListEntry::GitStatusEntry(entry) => Some(entry),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone)]
|
|
pub struct GitStatusEntry {
|
|
pub(crate) depth: usize,
|
|
pub(crate) display_name: String,
|
|
pub(crate) repo_path: RepoPath,
|
|
pub(crate) status: FileStatus,
|
|
pub(crate) is_staged: Option<bool>,
|
|
}
|
|
|
|
struct PendingOperation {
|
|
finished: bool,
|
|
will_become_staged: bool,
|
|
repo_paths: HashSet<RepoPath>,
|
|
op_id: usize,
|
|
}
|
|
|
|
pub struct GitPanel {
|
|
current_modifiers: Modifiers,
|
|
focus_handle: FocusHandle,
|
|
fs: Arc<dyn Fs>,
|
|
hide_scrollbar_task: Option<Task<()>>,
|
|
pending_serialization: Task<Option<()>>,
|
|
workspace: WeakEntity<Workspace>,
|
|
project: Entity<Project>,
|
|
active_repository: Option<Entity<Repository>>,
|
|
scroll_handle: UniformListScrollHandle,
|
|
scrollbar_state: ScrollbarState,
|
|
selected_entry: Option<usize>,
|
|
show_scrollbar: bool,
|
|
update_visible_entries_task: Task<()>,
|
|
repository_selector: Entity<RepositorySelector>,
|
|
commit_editor: Entity<Editor>,
|
|
entries: Vec<GitListEntry>,
|
|
entries_by_path: collections::HashMap<RepoPath, usize>,
|
|
width: Option<Pixels>,
|
|
pending: Vec<PendingOperation>,
|
|
pending_commit: Option<Task<()>>,
|
|
|
|
conflicted_staged_count: usize,
|
|
conflicted_count: usize,
|
|
tracked_staged_count: usize,
|
|
tracked_count: usize,
|
|
new_staged_count: usize,
|
|
new_count: usize,
|
|
}
|
|
|
|
fn commit_message_editor(
|
|
commit_message_buffer: Option<Entity<Buffer>>,
|
|
window: &mut Window,
|
|
cx: &mut Context<'_, Editor>,
|
|
) -> Editor {
|
|
let theme = ThemeSettings::get_global(cx);
|
|
|
|
let mut text_style = window.text_style();
|
|
let refinement = TextStyleRefinement {
|
|
font_family: Some(theme.buffer_font.family.clone()),
|
|
font_features: Some(FontFeatures::disable_ligatures()),
|
|
font_size: Some(px(12.).into()),
|
|
color: Some(cx.theme().colors().editor_foreground),
|
|
background_color: Some(gpui::transparent_black()),
|
|
..Default::default()
|
|
};
|
|
text_style.refine(&refinement);
|
|
|
|
let mut commit_editor = if let Some(commit_message_buffer) = commit_message_buffer {
|
|
let buffer = cx.new(|cx| MultiBuffer::singleton(commit_message_buffer, cx));
|
|
Editor::new(
|
|
EditorMode::AutoHeight { max_lines: 10 },
|
|
buffer,
|
|
None,
|
|
false,
|
|
window,
|
|
cx,
|
|
)
|
|
} else {
|
|
Editor::auto_height(10, window, cx)
|
|
};
|
|
commit_editor.set_use_autoclose(false);
|
|
commit_editor.set_show_gutter(false, cx);
|
|
commit_editor.set_show_wrap_guides(false, cx);
|
|
commit_editor.set_show_indent_guides(false, cx);
|
|
commit_editor.set_text_style_refinement(refinement);
|
|
commit_editor.set_placeholder_text("Enter commit message", cx);
|
|
commit_editor
|
|
}
|
|
|
|
impl GitPanel {
|
|
pub fn new(
|
|
workspace: &mut Workspace,
|
|
window: &mut Window,
|
|
commit_message_buffer: Option<Entity<Buffer>>,
|
|
cx: &mut Context<Workspace>,
|
|
) -> Entity<Self> {
|
|
let fs = workspace.app_state().fs.clone();
|
|
let project = workspace.project().clone();
|
|
let git_state = project.read(cx).git_state().clone();
|
|
let active_repository = project.read(cx).active_repository(cx);
|
|
let workspace = cx.entity().downgrade();
|
|
|
|
let git_panel = cx.new(|cx| {
|
|
let focus_handle = cx.focus_handle();
|
|
cx.on_focus(&focus_handle, window, Self::focus_in).detach();
|
|
cx.on_focus_out(&focus_handle, window, |this, _, window, cx| {
|
|
this.hide_scrollbar(window, cx);
|
|
})
|
|
.detach();
|
|
|
|
let commit_editor =
|
|
cx.new(|cx| commit_message_editor(commit_message_buffer, window, cx));
|
|
commit_editor.update(cx, |editor, cx| {
|
|
editor.clear(window, cx);
|
|
});
|
|
|
|
let scroll_handle = UniformListScrollHandle::new();
|
|
|
|
cx.subscribe_in(
|
|
&git_state,
|
|
window,
|
|
move |this, git_state, event, window, cx| match event {
|
|
GitEvent::FileSystemUpdated => {
|
|
this.schedule_update(false, window, cx);
|
|
}
|
|
GitEvent::ActiveRepositoryChanged | GitEvent::GitStateUpdated => {
|
|
this.active_repository = git_state.read(cx).active_repository();
|
|
this.schedule_update(true, window, cx);
|
|
}
|
|
},
|
|
)
|
|
.detach();
|
|
|
|
let repository_selector =
|
|
cx.new(|cx| RepositorySelector::new(project.clone(), window, cx));
|
|
|
|
let mut git_panel = Self {
|
|
focus_handle: cx.focus_handle(),
|
|
pending_serialization: Task::ready(None),
|
|
entries: Vec::new(),
|
|
entries_by_path: HashMap::default(),
|
|
pending: Vec::new(),
|
|
current_modifiers: window.modifiers(),
|
|
width: Some(px(360.)),
|
|
scrollbar_state: ScrollbarState::new(scroll_handle.clone())
|
|
.parent_entity(&cx.entity()),
|
|
repository_selector,
|
|
selected_entry: None,
|
|
show_scrollbar: false,
|
|
hide_scrollbar_task: None,
|
|
update_visible_entries_task: Task::ready(()),
|
|
pending_commit: None,
|
|
active_repository,
|
|
scroll_handle,
|
|
fs,
|
|
commit_editor,
|
|
project,
|
|
workspace,
|
|
conflicted_count: 0,
|
|
conflicted_staged_count: 0,
|
|
tracked_staged_count: 0,
|
|
tracked_count: 0,
|
|
new_staged_count: 0,
|
|
new_count: 0,
|
|
};
|
|
git_panel.schedule_update(false, window, cx);
|
|
git_panel.show_scrollbar = git_panel.should_show_scrollbar(cx);
|
|
git_panel
|
|
});
|
|
|
|
cx.subscribe_in(
|
|
&git_panel,
|
|
window,
|
|
move |workspace, _, event: &Event, window, cx| match event.clone() {
|
|
Event::OpenedEntry { path } => {
|
|
workspace
|
|
.open_path_preview(path, None, false, false, window, cx)
|
|
.detach_and_prompt_err("Failed to open file", window, cx, |e, _, _| {
|
|
Some(format!("{e}"))
|
|
});
|
|
}
|
|
Event::Focus => { /* TODO */ }
|
|
},
|
|
)
|
|
.detach();
|
|
|
|
git_panel
|
|
}
|
|
|
|
pub fn select_entry_by_path(
|
|
&mut self,
|
|
path: ProjectPath,
|
|
_: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let Some(git_repo) = self.active_repository.as_ref() else {
|
|
return;
|
|
};
|
|
let Some(repo_path) = git_repo.read(cx).project_path_to_repo_path(&path) else {
|
|
return;
|
|
};
|
|
let Some(ix) = self.entries_by_path.get(&repo_path) else {
|
|
return;
|
|
};
|
|
self.selected_entry = Some(*ix);
|
|
cx.notify();
|
|
}
|
|
|
|
fn serialize(&mut self, cx: &mut Context<Self>) {
|
|
let width = self.width;
|
|
self.pending_serialization = cx.background_executor().spawn(
|
|
async move {
|
|
KEY_VALUE_STORE
|
|
.write_kvp(
|
|
GIT_PANEL_KEY.into(),
|
|
serde_json::to_string(&SerializedGitPanel { width })?,
|
|
)
|
|
.await?;
|
|
anyhow::Ok(())
|
|
}
|
|
.log_err(),
|
|
);
|
|
}
|
|
|
|
fn dispatch_context(&self, window: &mut Window, cx: &Context<Self>) -> KeyContext {
|
|
let mut dispatch_context = KeyContext::new_with_defaults();
|
|
dispatch_context.add("GitPanel");
|
|
|
|
if self.is_focused(window, cx) {
|
|
dispatch_context.add("menu");
|
|
dispatch_context.add("ChangesList");
|
|
}
|
|
|
|
if self.commit_editor.read(cx).is_focused(window) {
|
|
dispatch_context.add("CommitEditor");
|
|
}
|
|
|
|
dispatch_context
|
|
}
|
|
|
|
fn is_focused(&self, window: &Window, cx: &Context<Self>) -> bool {
|
|
window
|
|
.focused(cx)
|
|
.map_or(false, |focused| self.focus_handle == focused)
|
|
}
|
|
|
|
fn close_panel(&mut self, _: &Close, _window: &mut Window, cx: &mut Context<Self>) {
|
|
cx.emit(PanelEvent::Close);
|
|
}
|
|
|
|
fn focus_in(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
if !self.focus_handle.contains_focused(window, cx) {
|
|
cx.emit(Event::Focus);
|
|
}
|
|
}
|
|
|
|
fn show_scrollbar(&self, cx: &mut Context<Self>) -> ShowScrollbar {
|
|
GitPanelSettings::get_global(cx)
|
|
.scrollbar
|
|
.show
|
|
.unwrap_or_else(|| EditorSettings::get_global(cx).scrollbar.show)
|
|
}
|
|
|
|
fn should_show_scrollbar(&self, cx: &mut Context<Self>) -> bool {
|
|
let show = self.show_scrollbar(cx);
|
|
match show {
|
|
ShowScrollbar::Auto => true,
|
|
ShowScrollbar::System => true,
|
|
ShowScrollbar::Always => true,
|
|
ShowScrollbar::Never => false,
|
|
}
|
|
}
|
|
|
|
fn should_autohide_scrollbar(&self, cx: &mut Context<Self>) -> bool {
|
|
let show = self.show_scrollbar(cx);
|
|
match show {
|
|
ShowScrollbar::Auto => true,
|
|
ShowScrollbar::System => cx
|
|
.try_global::<ScrollbarAutoHide>()
|
|
.map_or_else(|| cx.should_auto_hide_scrollbars(), |autohide| autohide.0),
|
|
ShowScrollbar::Always => false,
|
|
ShowScrollbar::Never => true,
|
|
}
|
|
}
|
|
|
|
fn hide_scrollbar(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
const SCROLLBAR_SHOW_INTERVAL: Duration = Duration::from_secs(1);
|
|
if !self.should_autohide_scrollbar(cx) {
|
|
return;
|
|
}
|
|
self.hide_scrollbar_task = Some(cx.spawn_in(window, |panel, mut cx| async move {
|
|
cx.background_executor()
|
|
.timer(SCROLLBAR_SHOW_INTERVAL)
|
|
.await;
|
|
panel
|
|
.update(&mut cx, |panel, cx| {
|
|
panel.show_scrollbar = false;
|
|
cx.notify();
|
|
})
|
|
.log_err();
|
|
}))
|
|
}
|
|
|
|
fn handle_modifiers_changed(
|
|
&mut self,
|
|
event: &ModifiersChangedEvent,
|
|
_: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
self.current_modifiers = event.modifiers;
|
|
cx.notify();
|
|
}
|
|
|
|
fn calculate_depth_and_difference(
|
|
repo_path: &RepoPath,
|
|
visible_entries: &HashSet<RepoPath>,
|
|
) -> (usize, usize) {
|
|
let ancestors = repo_path.ancestors().skip(1);
|
|
for ancestor in ancestors {
|
|
if let Some(parent_entry) = visible_entries.get(ancestor) {
|
|
let entry_component_count = repo_path.components().count();
|
|
let parent_component_count = parent_entry.components().count();
|
|
|
|
let difference = entry_component_count - parent_component_count;
|
|
|
|
let parent_depth = parent_entry
|
|
.ancestors()
|
|
.skip(1) // Skip the parent itself
|
|
.filter(|ancestor| visible_entries.contains(*ancestor))
|
|
.count();
|
|
|
|
return (parent_depth + 1, difference);
|
|
}
|
|
}
|
|
|
|
(0, 0)
|
|
}
|
|
|
|
fn scroll_to_selected_entry(&mut self, cx: &mut Context<Self>) {
|
|
if let Some(selected_entry) = self.selected_entry {
|
|
self.scroll_handle
|
|
.scroll_to_item(selected_entry, ScrollStrategy::Center);
|
|
}
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
fn select_first(&mut self, _: &SelectFirst, _window: &mut Window, cx: &mut Context<Self>) {
|
|
if self.entries.first().is_some() {
|
|
self.selected_entry = Some(0);
|
|
self.scroll_to_selected_entry(cx);
|
|
}
|
|
}
|
|
|
|
fn select_prev(&mut self, _: &SelectPrev, _window: &mut Window, cx: &mut Context<Self>) {
|
|
let item_count = self.entries.len();
|
|
if item_count == 0 {
|
|
return;
|
|
}
|
|
|
|
if let Some(selected_entry) = self.selected_entry {
|
|
let new_selected_entry = if selected_entry > 0 {
|
|
selected_entry - 1
|
|
} else {
|
|
selected_entry
|
|
};
|
|
|
|
self.selected_entry = Some(new_selected_entry);
|
|
|
|
self.scroll_to_selected_entry(cx);
|
|
}
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
fn select_next(&mut self, _: &SelectNext, _window: &mut Window, cx: &mut Context<Self>) {
|
|
let item_count = self.entries.len();
|
|
if item_count == 0 {
|
|
return;
|
|
}
|
|
|
|
if let Some(selected_entry) = self.selected_entry {
|
|
let new_selected_entry = if selected_entry < item_count - 1 {
|
|
selected_entry + 1
|
|
} else {
|
|
selected_entry
|
|
};
|
|
|
|
self.selected_entry = Some(new_selected_entry);
|
|
|
|
self.scroll_to_selected_entry(cx);
|
|
}
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
fn select_last(&mut self, _: &SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
|
|
if self.entries.last().is_some() {
|
|
self.selected_entry = Some(self.entries.len() - 1);
|
|
self.scroll_to_selected_entry(cx);
|
|
}
|
|
}
|
|
|
|
fn focus_editor(&mut self, _: &FocusEditor, window: &mut Window, cx: &mut Context<Self>) {
|
|
self.commit_editor.update(cx, |editor, cx| {
|
|
window.focus(&editor.focus_handle(cx));
|
|
});
|
|
cx.notify();
|
|
}
|
|
|
|
fn select_first_entry_if_none(&mut self, cx: &mut Context<Self>) {
|
|
let have_entries = self
|
|
.active_repository
|
|
.as_ref()
|
|
.map_or(false, |active_repository| {
|
|
active_repository.read(cx).entry_count() > 0
|
|
});
|
|
if have_entries && self.selected_entry.is_none() {
|
|
self.selected_entry = Some(0);
|
|
self.scroll_to_selected_entry(cx);
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
fn focus_changes_list(
|
|
&mut self,
|
|
_: &FocusChanges,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
self.select_first_entry_if_none(cx);
|
|
|
|
cx.focus_self(window);
|
|
cx.notify();
|
|
}
|
|
|
|
fn get_selected_entry(&self) -> Option<&GitListEntry> {
|
|
self.selected_entry.and_then(|i| self.entries.get(i))
|
|
}
|
|
|
|
fn open_selected(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
|
|
maybe!({
|
|
let entry = self.entries.get(self.selected_entry?)?.status_entry()?;
|
|
|
|
self.workspace
|
|
.update(cx, |workspace, cx| {
|
|
ProjectDiff::deploy_at(workspace, Some(entry.clone()), window, cx);
|
|
})
|
|
.ok()
|
|
});
|
|
self.focus_handle.focus(window);
|
|
}
|
|
|
|
fn toggle_staged_for_entry(
|
|
&mut self,
|
|
entry: &GitListEntry,
|
|
_window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let Some(active_repository) = self.active_repository.as_ref() else {
|
|
return;
|
|
};
|
|
let (stage, repo_paths) = match entry {
|
|
GitListEntry::GitStatusEntry(status_entry) => {
|
|
if status_entry.status.is_staged().unwrap_or(false) {
|
|
(false, vec![status_entry.repo_path.clone()])
|
|
} else {
|
|
(true, vec![status_entry.repo_path.clone()])
|
|
}
|
|
}
|
|
GitListEntry::Header(section) => {
|
|
let goal_staged_state = !self.header_state(section.header).selected();
|
|
let repository = active_repository.read(cx);
|
|
let entries = self
|
|
.entries
|
|
.iter()
|
|
.filter_map(|entry| entry.status_entry())
|
|
.filter(|status_entry| {
|
|
section.contains(&status_entry, repository)
|
|
&& status_entry.is_staged != Some(goal_staged_state)
|
|
})
|
|
.map(|status_entry| status_entry.repo_path.clone())
|
|
.collect::<Vec<_>>();
|
|
|
|
(goal_staged_state, entries)
|
|
}
|
|
};
|
|
|
|
let op_id = self.pending.iter().map(|p| p.op_id).max().unwrap_or(0) + 1;
|
|
self.pending.push(PendingOperation {
|
|
op_id,
|
|
will_become_staged: stage,
|
|
repo_paths: repo_paths.iter().cloned().collect(),
|
|
finished: false,
|
|
});
|
|
let repo_paths = repo_paths.clone();
|
|
let active_repository = active_repository.clone();
|
|
let repository = active_repository.read(cx);
|
|
self.update_counts(repository);
|
|
cx.notify();
|
|
|
|
cx.spawn({
|
|
|this, mut cx| async move {
|
|
let result = cx
|
|
.update(|cx| {
|
|
if stage {
|
|
active_repository.read(cx).stage_entries(repo_paths.clone())
|
|
} else {
|
|
active_repository
|
|
.read(cx)
|
|
.unstage_entries(repo_paths.clone())
|
|
}
|
|
})?
|
|
.await?;
|
|
|
|
this.update(&mut cx, |this, cx| {
|
|
for pending in this.pending.iter_mut() {
|
|
if pending.op_id == op_id {
|
|
pending.finished = true
|
|
}
|
|
}
|
|
result
|
|
.map_err(|e| {
|
|
this.show_err_toast(e, cx);
|
|
})
|
|
.ok();
|
|
cx.notify();
|
|
})
|
|
}
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
fn toggle_staged_for_selected(
|
|
&mut self,
|
|
_: &git::ToggleStaged,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let Some(selected_entry) = self.get_selected_entry().cloned() {
|
|
self.toggle_staged_for_entry(&selected_entry, window, cx);
|
|
}
|
|
}
|
|
|
|
/// Commit all staged changes
|
|
fn commit(&mut self, _: &git::Commit, window: &mut Window, cx: &mut Context<Self>) {
|
|
let editor = self.commit_editor.read(cx);
|
|
if editor.is_empty(cx) {
|
|
if !editor.focus_handle(cx).contains_focused(window, cx) {
|
|
editor.focus_handle(cx).focus(window);
|
|
return;
|
|
}
|
|
}
|
|
|
|
self.commit_changes(window, cx)
|
|
}
|
|
|
|
fn commit_changes(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
let Some(active_repository) = self.active_repository.clone() else {
|
|
return;
|
|
};
|
|
let error_spawn = |message, window: &mut Window, cx: &mut App| {
|
|
let prompt = window.prompt(PromptLevel::Warning, message, None, &["Ok"], cx);
|
|
cx.spawn(|_| async move {
|
|
prompt.await.ok();
|
|
})
|
|
.detach();
|
|
};
|
|
|
|
if self.has_unstaged_conflicts() {
|
|
error_spawn(
|
|
"There are still conflicts. You must stage these before committing",
|
|
window,
|
|
cx,
|
|
);
|
|
return;
|
|
}
|
|
|
|
let message = self.commit_editor.read(cx).text(cx);
|
|
if message.trim().is_empty() {
|
|
self.commit_editor.read(cx).focus_handle(cx).focus(window);
|
|
return;
|
|
}
|
|
|
|
let task = if self.has_staged_changes() {
|
|
// Repository serializes all git operations, so we can just send a commit immediately
|
|
let commit_task = active_repository.read(cx).commit(message.into(), None);
|
|
cx.background_executor()
|
|
.spawn(async move { commit_task.await? })
|
|
} else {
|
|
let changed_files = self
|
|
.entries
|
|
.iter()
|
|
.filter_map(|entry| entry.status_entry())
|
|
.filter(|status_entry| !status_entry.status.is_created())
|
|
.map(|status_entry| status_entry.repo_path.clone())
|
|
.collect::<Vec<_>>();
|
|
|
|
if changed_files.is_empty() {
|
|
error_spawn("No changes to commit", window, cx);
|
|
return;
|
|
}
|
|
|
|
let stage_task = active_repository.read(cx).stage_entries(changed_files);
|
|
cx.spawn(|_, mut cx| async move {
|
|
stage_task.await??;
|
|
let commit_task = active_repository
|
|
.update(&mut cx, |repo, _| repo.commit(message.into(), None))?;
|
|
commit_task.await?
|
|
})
|
|
};
|
|
let task = cx.spawn_in(window, |this, mut cx| async move {
|
|
let result = task.await;
|
|
this.update_in(&mut cx, |this, window, cx| {
|
|
this.pending_commit.take();
|
|
match result {
|
|
Ok(()) => {
|
|
this.commit_editor
|
|
.update(cx, |editor, cx| editor.clear(window, cx));
|
|
}
|
|
Err(e) => this.show_err_toast(e, cx),
|
|
}
|
|
})
|
|
.ok();
|
|
});
|
|
|
|
self.pending_commit = Some(task);
|
|
}
|
|
|
|
fn fill_co_authors(&mut self, _: &FillCoAuthors, window: &mut Window, cx: &mut Context<Self>) {
|
|
const CO_AUTHOR_PREFIX: &str = "Co-authored-by: ";
|
|
|
|
let Some(room) = self
|
|
.workspace
|
|
.upgrade()
|
|
.and_then(|workspace| workspace.read(cx).active_call()?.read(cx).room().cloned())
|
|
else {
|
|
return;
|
|
};
|
|
|
|
let mut existing_text = self.commit_editor.read(cx).text(cx);
|
|
existing_text.make_ascii_lowercase();
|
|
let lowercase_co_author_prefix = CO_AUTHOR_PREFIX.to_lowercase();
|
|
let mut ends_with_co_authors = false;
|
|
let existing_co_authors = existing_text
|
|
.lines()
|
|
.filter_map(|line| {
|
|
let line = line.trim();
|
|
if line.starts_with(&lowercase_co_author_prefix) {
|
|
ends_with_co_authors = true;
|
|
Some(line)
|
|
} else {
|
|
ends_with_co_authors = false;
|
|
None
|
|
}
|
|
})
|
|
.collect::<HashSet<_>>();
|
|
|
|
let new_co_authors = room
|
|
.read(cx)
|
|
.remote_participants()
|
|
.values()
|
|
.filter(|participant| participant.can_write())
|
|
.map(|participant| participant.user.as_ref())
|
|
.filter_map(|user| {
|
|
let email = user.email.as_deref()?;
|
|
let name = user.name.as_deref().unwrap_or(&user.github_login);
|
|
Some(format!("{CO_AUTHOR_PREFIX}{name} <{email}>"))
|
|
})
|
|
.filter(|co_author| {
|
|
!existing_co_authors.contains(co_author.to_ascii_lowercase().as_str())
|
|
})
|
|
.collect::<Vec<_>>();
|
|
if new_co_authors.is_empty() {
|
|
return;
|
|
}
|
|
|
|
self.commit_editor.update(cx, |editor, cx| {
|
|
let editor_end = editor.buffer().read(cx).read(cx).len();
|
|
let mut edit = String::new();
|
|
if !ends_with_co_authors {
|
|
edit.push('\n');
|
|
}
|
|
for co_author in new_co_authors {
|
|
edit.push('\n');
|
|
edit.push_str(&co_author);
|
|
}
|
|
|
|
editor.edit(Some((editor_end..editor_end, edit)), cx);
|
|
editor.move_to_end(&MoveToEnd, window, cx);
|
|
editor.focus_handle(cx).focus(window);
|
|
});
|
|
}
|
|
|
|
fn schedule_update(
|
|
&mut self,
|
|
clear_pending: bool,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let handle = cx.entity().downgrade();
|
|
self.reopen_commit_buffer(window, cx);
|
|
self.update_visible_entries_task = cx.spawn_in(window, |_, mut cx| async move {
|
|
cx.background_executor().timer(UPDATE_DEBOUNCE).await;
|
|
if let Some(git_panel) = handle.upgrade() {
|
|
git_panel
|
|
.update_in(&mut cx, |git_panel, _, cx| {
|
|
if clear_pending {
|
|
git_panel.clear_pending();
|
|
}
|
|
git_panel.update_visible_entries(cx);
|
|
})
|
|
.ok();
|
|
}
|
|
});
|
|
}
|
|
|
|
fn reopen_commit_buffer(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
let Some(active_repo) = self.active_repository.as_ref() else {
|
|
return;
|
|
};
|
|
let load_buffer = active_repo.update(cx, |active_repo, cx| {
|
|
let project = self.project.read(cx);
|
|
active_repo.open_commit_buffer(
|
|
Some(project.languages().clone()),
|
|
project.buffer_store().clone(),
|
|
cx,
|
|
)
|
|
});
|
|
|
|
cx.spawn_in(window, |git_panel, mut cx| async move {
|
|
let buffer = load_buffer.await?;
|
|
git_panel.update_in(&mut cx, |git_panel, window, cx| {
|
|
if git_panel
|
|
.commit_editor
|
|
.read(cx)
|
|
.buffer()
|
|
.read(cx)
|
|
.as_singleton()
|
|
.as_ref()
|
|
!= Some(&buffer)
|
|
{
|
|
git_panel.commit_editor =
|
|
cx.new(|cx| commit_message_editor(Some(buffer), window, cx));
|
|
}
|
|
})
|
|
})
|
|
.detach_and_log_err(cx);
|
|
}
|
|
|
|
fn clear_pending(&mut self) {
|
|
self.pending.retain(|v| !v.finished)
|
|
}
|
|
|
|
fn update_visible_entries(&mut self, cx: &mut Context<Self>) {
|
|
self.entries.clear();
|
|
self.entries_by_path.clear();
|
|
let mut changed_entries = Vec::new();
|
|
let mut new_entries = Vec::new();
|
|
let mut conflict_entries = Vec::new();
|
|
|
|
let Some(repo) = self.active_repository.as_ref() else {
|
|
// Just clear entries if no repository is active.
|
|
cx.notify();
|
|
return;
|
|
};
|
|
|
|
// First pass - collect all paths
|
|
let repo = repo.read(cx);
|
|
let path_set = HashSet::from_iter(repo.status().map(|entry| entry.repo_path));
|
|
|
|
// Second pass - create entries with proper depth calculation
|
|
for entry in repo.status() {
|
|
let (depth, difference) =
|
|
Self::calculate_depth_and_difference(&entry.repo_path, &path_set);
|
|
|
|
let is_conflict = repo.has_conflict(&entry.repo_path);
|
|
let is_new = entry.status.is_created();
|
|
let is_staged = entry.status.is_staged();
|
|
|
|
let display_name = if difference > 1 {
|
|
// Show partial path for deeply nested files
|
|
entry
|
|
.repo_path
|
|
.as_ref()
|
|
.iter()
|
|
.skip(entry.repo_path.components().count() - difference)
|
|
.collect::<PathBuf>()
|
|
.to_string_lossy()
|
|
.into_owned()
|
|
} else {
|
|
// Just show filename
|
|
entry
|
|
.repo_path
|
|
.file_name()
|
|
.map(|name| name.to_string_lossy().into_owned())
|
|
.unwrap_or_default()
|
|
};
|
|
|
|
let entry = GitStatusEntry {
|
|
depth,
|
|
display_name,
|
|
repo_path: entry.repo_path.clone(),
|
|
status: entry.status,
|
|
is_staged,
|
|
};
|
|
|
|
if is_conflict {
|
|
conflict_entries.push(entry);
|
|
} else if is_new {
|
|
new_entries.push(entry);
|
|
} else {
|
|
changed_entries.push(entry);
|
|
}
|
|
}
|
|
|
|
// Sort entries by path to maintain consistent order
|
|
conflict_entries.sort_by(|a, b| a.repo_path.cmp(&b.repo_path));
|
|
changed_entries.sort_by(|a, b| a.repo_path.cmp(&b.repo_path));
|
|
new_entries.sort_by(|a, b| a.repo_path.cmp(&b.repo_path));
|
|
|
|
if conflict_entries.len() > 0 {
|
|
self.entries.push(GitListEntry::Header(GitHeaderEntry {
|
|
header: Section::Conflict,
|
|
}));
|
|
self.entries.extend(
|
|
conflict_entries
|
|
.into_iter()
|
|
.map(GitListEntry::GitStatusEntry),
|
|
);
|
|
}
|
|
|
|
if changed_entries.len() > 0 {
|
|
self.entries.push(GitListEntry::Header(GitHeaderEntry {
|
|
header: Section::Tracked,
|
|
}));
|
|
self.entries.extend(
|
|
changed_entries
|
|
.into_iter()
|
|
.map(GitListEntry::GitStatusEntry),
|
|
);
|
|
}
|
|
if new_entries.len() > 0 {
|
|
self.entries.push(GitListEntry::Header(GitHeaderEntry {
|
|
header: Section::New,
|
|
}));
|
|
self.entries
|
|
.extend(new_entries.into_iter().map(GitListEntry::GitStatusEntry));
|
|
}
|
|
|
|
for (ix, entry) in self.entries.iter().enumerate() {
|
|
if let Some(status_entry) = entry.status_entry() {
|
|
self.entries_by_path
|
|
.insert(status_entry.repo_path.clone(), ix);
|
|
}
|
|
}
|
|
self.update_counts(repo);
|
|
|
|
self.select_first_entry_if_none(cx);
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
fn update_counts(&mut self, repo: &Repository) {
|
|
self.conflicted_count = 0;
|
|
self.conflicted_staged_count = 0;
|
|
self.new_count = 0;
|
|
self.tracked_count = 0;
|
|
self.new_staged_count = 0;
|
|
self.tracked_staged_count = 0;
|
|
for entry in &self.entries {
|
|
let Some(status_entry) = entry.status_entry() else {
|
|
continue;
|
|
};
|
|
if repo.has_conflict(&status_entry.repo_path) {
|
|
self.conflicted_count += 1;
|
|
if self.entry_is_staged(status_entry) != Some(false) {
|
|
self.conflicted_staged_count += 1;
|
|
}
|
|
} else if status_entry.status.is_created() {
|
|
self.new_count += 1;
|
|
if self.entry_is_staged(status_entry) != Some(false) {
|
|
self.new_staged_count += 1;
|
|
}
|
|
} else {
|
|
self.tracked_count += 1;
|
|
if self.entry_is_staged(status_entry) != Some(false) {
|
|
self.tracked_staged_count += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn entry_is_staged(&self, entry: &GitStatusEntry) -> Option<bool> {
|
|
for pending in self.pending.iter().rev() {
|
|
if pending.repo_paths.contains(&entry.repo_path) {
|
|
return Some(pending.will_become_staged);
|
|
}
|
|
}
|
|
entry.is_staged
|
|
}
|
|
|
|
fn has_staged_changes(&self) -> bool {
|
|
self.tracked_staged_count > 0
|
|
|| self.new_staged_count > 0
|
|
|| self.conflicted_staged_count > 0
|
|
}
|
|
|
|
fn has_tracked_changes(&self) -> bool {
|
|
self.tracked_count > 0
|
|
}
|
|
|
|
fn has_unstaged_conflicts(&self) -> bool {
|
|
self.conflicted_count > 0 && self.conflicted_count != self.conflicted_staged_count
|
|
}
|
|
|
|
fn header_state(&self, header_type: Section) -> ToggleState {
|
|
let (staged_count, count) = match header_type {
|
|
Section::New => (self.new_staged_count, self.new_count),
|
|
Section::Tracked => (self.tracked_staged_count, self.tracked_count),
|
|
Section::Conflict => (self.conflicted_staged_count, self.conflicted_count),
|
|
};
|
|
if staged_count == 0 {
|
|
ToggleState::Unselected
|
|
} else if count == staged_count {
|
|
ToggleState::Selected
|
|
} else {
|
|
ToggleState::Indeterminate
|
|
}
|
|
}
|
|
|
|
fn show_err_toast(&self, e: anyhow::Error, cx: &mut App) {
|
|
let Some(workspace) = self.workspace.upgrade() else {
|
|
return;
|
|
};
|
|
let notif_id = NotificationId::Named("git-operation-error".into());
|
|
|
|
let message = e.to_string();
|
|
workspace.update(cx, |workspace, cx| {
|
|
let toast = Toast::new(notif_id, message).on_click("Open Zed Log", |window, cx| {
|
|
window.dispatch_action(workspace::OpenLog.boxed_clone(), cx);
|
|
});
|
|
workspace.show_toast(toast, cx);
|
|
});
|
|
}
|
|
|
|
pub fn panel_button(
|
|
&self,
|
|
id: impl Into<SharedString>,
|
|
label: impl Into<SharedString>,
|
|
) -> Button {
|
|
let id = id.into().clone();
|
|
let label = label.into().clone();
|
|
|
|
Button::new(id, label)
|
|
.label_size(LabelSize::Small)
|
|
.layer(ElevationIndex::ElevatedSurface)
|
|
.size(ButtonSize::Compact)
|
|
.style(ButtonStyle::Filled)
|
|
}
|
|
|
|
pub fn indent_size(&self, window: &Window, cx: &mut Context<Self>) -> Pixels {
|
|
Checkbox::container_size(cx).to_pixels(window.rem_size())
|
|
}
|
|
|
|
pub fn render_divider(&self, _cx: &mut Context<Self>) -> impl IntoElement {
|
|
h_flex()
|
|
.items_center()
|
|
.h(px(8.))
|
|
.child(Divider::horizontal_dashed().color(DividerColor::Border))
|
|
}
|
|
|
|
pub fn render_panel_header(
|
|
&self,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> impl IntoElement {
|
|
let all_repositories = self
|
|
.project
|
|
.read(cx)
|
|
.git_state()
|
|
.read(cx)
|
|
.all_repositories();
|
|
|
|
let branch = self
|
|
.active_repository
|
|
.as_ref()
|
|
.and_then(|repository| repository.read(cx).branch())
|
|
.unwrap_or_else(|| "(no current branch)".into());
|
|
|
|
let has_repo_above = all_repositories.iter().any(|repo| {
|
|
repo.read(cx)
|
|
.repository_entry
|
|
.work_directory
|
|
.is_above_project()
|
|
});
|
|
|
|
let icon_button = Button::new("branch-selector", branch)
|
|
.color(Color::Muted)
|
|
.style(ButtonStyle::Subtle)
|
|
.icon(IconName::GitBranch)
|
|
.icon_size(IconSize::Small)
|
|
.icon_color(Color::Muted)
|
|
.size(ButtonSize::Compact)
|
|
.icon_position(IconPosition::Start)
|
|
.tooltip(Tooltip::for_action_title(
|
|
"Switch Branch",
|
|
&zed_actions::git::Branch,
|
|
))
|
|
.on_click(cx.listener(|_, _, window, cx| {
|
|
window.dispatch_action(zed_actions::git::Branch.boxed_clone(), cx);
|
|
}))
|
|
.style(ButtonStyle::Transparent);
|
|
|
|
self.panel_header_container(window, cx)
|
|
.child(h_flex().pl_1().child(icon_button))
|
|
.child(div().flex_grow())
|
|
.when(all_repositories.len() > 1 || has_repo_above, |el| {
|
|
el.child(self.render_repository_selector(cx))
|
|
})
|
|
}
|
|
|
|
pub fn render_repository_selector(&self, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let active_repository = self.project.read(cx).active_repository(cx);
|
|
let repository_display_name = active_repository
|
|
.as_ref()
|
|
.map(|repo| repo.read(cx).display_name(self.project.read(cx), cx))
|
|
.unwrap_or_default();
|
|
|
|
RepositorySelectorPopoverMenu::new(
|
|
self.repository_selector.clone(),
|
|
ButtonLike::new("active-repository")
|
|
.style(ButtonStyle::Subtle)
|
|
.child(Label::new(repository_display_name).size(LabelSize::Small)),
|
|
)
|
|
}
|
|
|
|
pub fn render_commit_editor(&self, cx: &Context<Self>) -> impl IntoElement {
|
|
let editor = self.commit_editor.clone();
|
|
let can_commit = (self.has_staged_changes() || self.has_tracked_changes())
|
|
&& self.pending_commit.is_none()
|
|
&& !editor.read(cx).is_empty(cx)
|
|
&& !self.has_unstaged_conflicts()
|
|
&& self.has_write_access(cx);
|
|
let editor_focus_handle = editor.read(cx).focus_handle(cx).clone();
|
|
|
|
let focus_handle_1 = self.focus_handle(cx).clone();
|
|
let tooltip = if self.has_staged_changes() {
|
|
"Commit staged changes"
|
|
} else {
|
|
"Commit changes to tracked files"
|
|
};
|
|
let title = if self.has_staged_changes() {
|
|
"Commit"
|
|
} else {
|
|
"Commit All"
|
|
};
|
|
|
|
let commit_button = self
|
|
.panel_button("commit-changes", title)
|
|
.tooltip(move |window, cx| {
|
|
let focus_handle = focus_handle_1.clone();
|
|
Tooltip::for_action_in(tooltip, &Commit, &focus_handle, window, cx)
|
|
})
|
|
.disabled(!can_commit)
|
|
.on_click({
|
|
cx.listener(move |this, _: &ClickEvent, window, cx| this.commit_changes(window, cx))
|
|
});
|
|
|
|
div().w_full().h(px(140.)).px_2().pt_1().pb_2().child(
|
|
v_flex()
|
|
.id("commit-editor-container")
|
|
.relative()
|
|
.h_full()
|
|
.py_2p5()
|
|
.px_3()
|
|
.bg(cx.theme().colors().editor_background)
|
|
.on_click(cx.listener(move |_, _: &ClickEvent, window, _cx| {
|
|
window.focus(&editor_focus_handle);
|
|
}))
|
|
.child(self.commit_editor.clone())
|
|
.child(
|
|
h_flex()
|
|
.absolute()
|
|
.bottom_2p5()
|
|
.right_3()
|
|
.gap_1p5()
|
|
.child(div().gap_1().flex_grow())
|
|
.child(commit_button),
|
|
),
|
|
)
|
|
}
|
|
|
|
fn render_empty_state(&self, cx: &mut Context<Self>) -> impl IntoElement {
|
|
h_flex()
|
|
.h_full()
|
|
.flex_1()
|
|
.justify_center()
|
|
.items_center()
|
|
.child(
|
|
v_flex()
|
|
.gap_3()
|
|
.child(if self.active_repository.is_some() {
|
|
"No changes to commit"
|
|
} else {
|
|
"No Git repositories"
|
|
})
|
|
.text_ui_sm(cx)
|
|
.mx_auto()
|
|
.text_color(Color::Placeholder.color(cx)),
|
|
)
|
|
}
|
|
|
|
fn render_scrollbar(&self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
|
|
let scroll_bar_style = self.show_scrollbar(cx);
|
|
let show_container = matches!(scroll_bar_style, ShowScrollbar::Always);
|
|
|
|
if !self.should_show_scrollbar(cx)
|
|
|| !(self.show_scrollbar || self.scrollbar_state.is_dragging())
|
|
{
|
|
return None;
|
|
}
|
|
|
|
Some(
|
|
div()
|
|
.id("git-panel-vertical-scroll")
|
|
.occlude()
|
|
.flex_none()
|
|
.h_full()
|
|
.cursor_default()
|
|
.when(show_container, |this| this.pl_1().px_1p5())
|
|
.when(!show_container, |this| {
|
|
this.absolute().right_1().top_1().bottom_1().w(px(12.))
|
|
})
|
|
.on_mouse_move(cx.listener(|_, _, _, cx| {
|
|
cx.notify();
|
|
cx.stop_propagation()
|
|
}))
|
|
.on_hover(|_, _, cx| {
|
|
cx.stop_propagation();
|
|
})
|
|
.on_any_mouse_down(|_, _, cx| {
|
|
cx.stop_propagation();
|
|
})
|
|
.on_mouse_up(
|
|
MouseButton::Left,
|
|
cx.listener(|this, _, window, cx| {
|
|
if !this.scrollbar_state.is_dragging()
|
|
&& !this.focus_handle.contains_focused(window, cx)
|
|
{
|
|
this.hide_scrollbar(window, cx);
|
|
cx.notify();
|
|
}
|
|
|
|
cx.stop_propagation();
|
|
}),
|
|
)
|
|
.on_scroll_wheel(cx.listener(|_, _, _, cx| {
|
|
cx.notify();
|
|
}))
|
|
.children(Scrollbar::vertical(
|
|
// percentage as f32..end_offset as f32,
|
|
self.scrollbar_state.clone(),
|
|
)),
|
|
)
|
|
}
|
|
|
|
pub fn render_buffer_header_controls(
|
|
&self,
|
|
entity: &Entity<Self>,
|
|
file: &Arc<dyn File>,
|
|
_: &Window,
|
|
cx: &App,
|
|
) -> Option<AnyElement> {
|
|
let repo = self.active_repository.as_ref()?.read(cx);
|
|
let repo_path = repo.worktree_id_path_to_repo_path(file.worktree_id(cx), file.path())?;
|
|
let ix = self.entries_by_path.get(&repo_path)?;
|
|
let entry = self.entries.get(*ix)?;
|
|
|
|
let is_staged = self.entry_is_staged(entry.status_entry()?);
|
|
|
|
let checkbox = Checkbox::new("stage-file", is_staged.into())
|
|
.disabled(!self.has_write_access(cx))
|
|
.fill()
|
|
.elevation(ElevationIndex::Surface)
|
|
.on_click({
|
|
let entry = entry.clone();
|
|
let git_panel = entity.downgrade();
|
|
move |_, window, cx| {
|
|
git_panel
|
|
.update(cx, |this, cx| {
|
|
this.toggle_staged_for_entry(&entry, window, cx);
|
|
cx.stop_propagation();
|
|
})
|
|
.ok();
|
|
}
|
|
});
|
|
Some(
|
|
h_flex()
|
|
.id("start-slot")
|
|
.child(checkbox)
|
|
.child(git_status_icon(entry.status_entry()?.status, cx))
|
|
.on_mouse_down(MouseButton::Left, |_, _, cx| {
|
|
// prevent the list item active state triggering when toggling checkbox
|
|
cx.stop_propagation();
|
|
})
|
|
.into_any_element(),
|
|
)
|
|
}
|
|
|
|
fn render_entries(
|
|
&self,
|
|
has_write_access: bool,
|
|
window: &Window,
|
|
cx: &mut Context<Self>,
|
|
) -> impl IntoElement {
|
|
let entry_count = self.entries.len();
|
|
|
|
v_flex()
|
|
.size_full()
|
|
.overflow_hidden()
|
|
.child(
|
|
uniform_list(cx.entity().clone(), "entries", entry_count, {
|
|
move |this, range, window, cx| {
|
|
let mut items = Vec::with_capacity(range.end - range.start);
|
|
|
|
for ix in range {
|
|
match &this.entries.get(ix) {
|
|
Some(GitListEntry::GitStatusEntry(entry)) => {
|
|
items.push(this.render_entry(
|
|
ix,
|
|
entry,
|
|
has_write_access,
|
|
window,
|
|
cx,
|
|
));
|
|
}
|
|
Some(GitListEntry::Header(header)) => {
|
|
items.push(this.render_list_header(
|
|
ix,
|
|
header,
|
|
has_write_access,
|
|
window,
|
|
cx,
|
|
));
|
|
}
|
|
None => {}
|
|
}
|
|
}
|
|
|
|
items
|
|
}
|
|
})
|
|
.with_decoration(
|
|
ui::indent_guides(
|
|
cx.entity().clone(),
|
|
self.indent_size(window, cx),
|
|
IndentGuideColors::panel(cx),
|
|
|this, range, _windows, _cx| {
|
|
this.entries
|
|
.iter()
|
|
.skip(range.start)
|
|
.map(|entry| match entry {
|
|
GitListEntry::GitStatusEntry(_) => 1,
|
|
GitListEntry::Header(_) => 0,
|
|
})
|
|
.collect()
|
|
},
|
|
)
|
|
.with_render_fn(
|
|
cx.entity().clone(),
|
|
move |_, params, _, _| {
|
|
let indent_size = params.indent_size;
|
|
let left_offset = indent_size - px(3.0);
|
|
let item_height = params.item_height;
|
|
|
|
params
|
|
.indent_guides
|
|
.into_iter()
|
|
.enumerate()
|
|
.map(|(_, layout)| {
|
|
let offset = if layout.continues_offscreen {
|
|
px(0.)
|
|
} else {
|
|
px(4.0)
|
|
};
|
|
let bounds = Bounds::new(
|
|
point(
|
|
px(layout.offset.x as f32) * indent_size + left_offset,
|
|
px(layout.offset.y as f32) * item_height + offset,
|
|
),
|
|
size(
|
|
px(1.),
|
|
px(layout.length as f32) * item_height
|
|
- px(offset.0 * 2.),
|
|
),
|
|
);
|
|
ui::RenderedIndentGuide {
|
|
bounds,
|
|
layout,
|
|
is_active: false,
|
|
hitbox: None,
|
|
}
|
|
})
|
|
.collect()
|
|
},
|
|
),
|
|
)
|
|
.size_full()
|
|
.with_sizing_behavior(ListSizingBehavior::Infer)
|
|
.with_horizontal_sizing_behavior(ListHorizontalSizingBehavior::Unconstrained)
|
|
.track_scroll(self.scroll_handle.clone()),
|
|
)
|
|
.children(self.render_scrollbar(cx))
|
|
}
|
|
|
|
fn entry_label(&self, label: impl Into<SharedString>, color: Color) -> Label {
|
|
Label::new(label.into()).color(color).single_line()
|
|
}
|
|
|
|
fn render_list_header(
|
|
&self,
|
|
ix: usize,
|
|
header: &GitHeaderEntry,
|
|
has_write_access: bool,
|
|
window: &Window,
|
|
cx: &Context<Self>,
|
|
) -> AnyElement {
|
|
let selected = self.selected_entry == Some(ix);
|
|
let header_state = if self.has_staged_changes() {
|
|
self.header_state(header.header)
|
|
} else {
|
|
match header.header {
|
|
Section::Tracked | Section::Conflict => ToggleState::Selected,
|
|
Section::New => ToggleState::Unselected,
|
|
}
|
|
};
|
|
|
|
let checkbox = Checkbox::new(("checkbox", ix), header_state)
|
|
.disabled(!has_write_access)
|
|
.fill()
|
|
.placeholder(!self.has_staged_changes())
|
|
.elevation(ElevationIndex::Surface)
|
|
.on_click({
|
|
let header = header.clone();
|
|
cx.listener(move |this, _, window, cx| {
|
|
this.toggle_staged_for_entry(&GitListEntry::Header(header.clone()), window, cx);
|
|
cx.stop_propagation();
|
|
})
|
|
});
|
|
|
|
let start_slot = h_flex()
|
|
.id(("start-slot", ix))
|
|
.gap(DynamicSpacing::Base04.rems(cx))
|
|
.child(checkbox)
|
|
.tooltip(|window, cx| Tooltip::for_action("Stage File", &ToggleStaged, window, cx))
|
|
.on_mouse_down(MouseButton::Left, |_, _, cx| {
|
|
// prevent the list item active state triggering when toggling checkbox
|
|
cx.stop_propagation();
|
|
});
|
|
|
|
div()
|
|
.w_full()
|
|
.child(
|
|
ListItem::new(ix)
|
|
.spacing(ListItemSpacing::Sparse)
|
|
.start_slot(start_slot)
|
|
.toggle_state(selected)
|
|
.focused(selected && self.focus_handle.is_focused(window))
|
|
.disabled(!has_write_access)
|
|
.on_click({
|
|
cx.listener(move |this, _, _, cx| {
|
|
this.selected_entry = Some(ix);
|
|
cx.notify();
|
|
})
|
|
})
|
|
.child(h_flex().child(self.entry_label(header.title(), Color::Muted))),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
|
|
fn render_entry(
|
|
&self,
|
|
ix: usize,
|
|
entry: &GitStatusEntry,
|
|
has_write_access: bool,
|
|
window: &Window,
|
|
cx: &Context<Self>,
|
|
) -> AnyElement {
|
|
let display_name = entry
|
|
.repo_path
|
|
.file_name()
|
|
.map(|name| name.to_string_lossy().into_owned())
|
|
.unwrap_or_else(|| entry.repo_path.to_string_lossy().into_owned());
|
|
|
|
let repo_path = entry.repo_path.clone();
|
|
let selected = self.selected_entry == Some(ix);
|
|
let status_style = GitPanelSettings::get_global(cx).status_style;
|
|
let status = entry.status;
|
|
let has_conflict = status.is_conflicted();
|
|
let is_modified = status.is_modified();
|
|
let is_deleted = status.is_deleted();
|
|
|
|
let label_color = if status_style == StatusStyle::LabelColor {
|
|
if has_conflict {
|
|
Color::Conflict
|
|
} else if is_modified {
|
|
Color::Modified
|
|
} else if is_deleted {
|
|
// We don't want a bunch of red labels in the list
|
|
Color::Disabled
|
|
} else {
|
|
Color::Created
|
|
}
|
|
} else {
|
|
Color::Default
|
|
};
|
|
|
|
let path_color = if status.is_deleted() {
|
|
Color::Disabled
|
|
} else {
|
|
Color::Muted
|
|
};
|
|
|
|
let id: ElementId = ElementId::Name(format!("entry_{}", display_name).into());
|
|
|
|
let mut is_staged: ToggleState = self.entry_is_staged(entry).into();
|
|
|
|
if !self.has_staged_changes() && !entry.status.is_created() {
|
|
is_staged = ToggleState::Selected;
|
|
}
|
|
|
|
let checkbox = Checkbox::new(id, is_staged)
|
|
.disabled(!has_write_access)
|
|
.fill()
|
|
.placeholder(!self.has_staged_changes())
|
|
.elevation(ElevationIndex::Surface)
|
|
.on_click({
|
|
let entry = entry.clone();
|
|
cx.listener(move |this, _, window, cx| {
|
|
this.toggle_staged_for_entry(
|
|
&GitListEntry::GitStatusEntry(entry.clone()),
|
|
window,
|
|
cx,
|
|
);
|
|
cx.stop_propagation();
|
|
})
|
|
});
|
|
|
|
let start_slot = h_flex()
|
|
.id(("start-slot", ix))
|
|
.gap(DynamicSpacing::Base04.rems(cx))
|
|
.child(checkbox)
|
|
.tooltip(|window, cx| Tooltip::for_action("Stage File", &ToggleStaged, window, cx))
|
|
.child(git_status_icon(status, cx))
|
|
.on_mouse_down(MouseButton::Left, |_, _, cx| {
|
|
// prevent the list item active state triggering when toggling checkbox
|
|
cx.stop_propagation();
|
|
});
|
|
|
|
let id = ElementId::Name(format!("entry_{}", display_name).into());
|
|
|
|
div()
|
|
.w_full()
|
|
.child(
|
|
ListItem::new(id)
|
|
.indent_level(1)
|
|
.indent_step_size(Checkbox::container_size(cx).to_pixels(window.rem_size()))
|
|
.spacing(ListItemSpacing::Sparse)
|
|
.start_slot(start_slot)
|
|
.toggle_state(selected)
|
|
.focused(selected && self.focus_handle.is_focused(window))
|
|
.disabled(!has_write_access)
|
|
.on_click({
|
|
cx.listener(move |this, _, window, cx| {
|
|
this.selected_entry = Some(ix);
|
|
cx.notify();
|
|
this.open_selected(&Default::default(), window, cx);
|
|
})
|
|
})
|
|
.child(
|
|
h_flex()
|
|
.when_some(repo_path.parent(), |this, parent| {
|
|
let parent_str = parent.to_string_lossy();
|
|
if !parent_str.is_empty() {
|
|
this.child(
|
|
self.entry_label(format!("{}/", parent_str), path_color)
|
|
.when(status.is_deleted(), |this| {
|
|
this.strikethrough(true)
|
|
}),
|
|
)
|
|
} else {
|
|
this
|
|
}
|
|
})
|
|
.child(
|
|
self.entry_label(display_name.clone(), label_color)
|
|
.when(status.is_deleted(), |this| this.strikethrough(true)),
|
|
),
|
|
),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
|
|
fn has_write_access(&self, cx: &App) -> bool {
|
|
!self.project.read(cx).is_read_only(cx)
|
|
}
|
|
}
|
|
|
|
impl Render for GitPanel {
|
|
fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let project = self.project.read(cx);
|
|
let has_entries = self
|
|
.active_repository
|
|
.as_ref()
|
|
.map_or(false, |active_repository| {
|
|
active_repository.read(cx).entry_count() > 0
|
|
});
|
|
let room = self
|
|
.workspace
|
|
.upgrade()
|
|
.and_then(|workspace| workspace.read(cx).active_call()?.read(cx).room().cloned());
|
|
|
|
let has_write_access = self.has_write_access(cx);
|
|
|
|
let has_co_authors = room.map_or(false, |room| {
|
|
room.read(cx)
|
|
.remote_participants()
|
|
.values()
|
|
.any(|remote_participant| remote_participant.can_write())
|
|
});
|
|
|
|
v_flex()
|
|
.id("git_panel")
|
|
.key_context(self.dispatch_context(window, cx))
|
|
.track_focus(&self.focus_handle)
|
|
.on_modifiers_changed(cx.listener(Self::handle_modifiers_changed))
|
|
.when(has_write_access && !project.is_read_only(cx), |this| {
|
|
this.on_action(cx.listener(|this, &ToggleStaged, window, cx| {
|
|
this.toggle_staged_for_selected(&ToggleStaged, window, cx)
|
|
}))
|
|
.on_action(cx.listener(GitPanel::commit))
|
|
})
|
|
.when(self.is_focused(window, cx), |this| {
|
|
this.on_action(cx.listener(Self::select_first))
|
|
.on_action(cx.listener(Self::select_next))
|
|
.on_action(cx.listener(Self::select_prev))
|
|
.on_action(cx.listener(Self::select_last))
|
|
.on_action(cx.listener(Self::close_panel))
|
|
})
|
|
.on_action(cx.listener(Self::open_selected))
|
|
.on_action(cx.listener(Self::focus_changes_list))
|
|
.on_action(cx.listener(Self::focus_editor))
|
|
.on_action(cx.listener(Self::toggle_staged_for_selected))
|
|
.when(has_write_access && has_co_authors, |git_panel| {
|
|
git_panel.on_action(cx.listener(Self::fill_co_authors))
|
|
})
|
|
// .on_action(cx.listener(|this, &OpenSelected, cx| this.open_selected(&OpenSelected, cx)))
|
|
.on_hover(cx.listener(|this, hovered, window, cx| {
|
|
if *hovered {
|
|
this.show_scrollbar = true;
|
|
this.hide_scrollbar_task.take();
|
|
cx.notify();
|
|
} else if !this.focus_handle.contains_focused(window, cx) {
|
|
this.hide_scrollbar(window, cx);
|
|
}
|
|
}))
|
|
.size_full()
|
|
.overflow_hidden()
|
|
.bg(ElevationIndex::Surface.bg(cx))
|
|
.child(self.render_panel_header(window, cx))
|
|
.child(if has_entries {
|
|
self.render_entries(has_write_access, window, cx)
|
|
.into_any_element()
|
|
} else {
|
|
self.render_empty_state(cx).into_any_element()
|
|
})
|
|
.child(self.render_commit_editor(cx))
|
|
}
|
|
}
|
|
|
|
impl Focusable for GitPanel {
|
|
fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
|
|
self.focus_handle.clone()
|
|
}
|
|
}
|
|
|
|
impl EventEmitter<Event> for GitPanel {}
|
|
|
|
impl EventEmitter<PanelEvent> for GitPanel {}
|
|
|
|
pub(crate) struct GitPanelAddon {
|
|
pub(crate) git_panel: Entity<GitPanel>,
|
|
}
|
|
|
|
impl editor::Addon for GitPanelAddon {
|
|
fn to_any(&self) -> &dyn std::any::Any {
|
|
self
|
|
}
|
|
|
|
fn render_buffer_header_controls(
|
|
&self,
|
|
excerpt_info: &ExcerptInfo,
|
|
window: &Window,
|
|
cx: &App,
|
|
) -> Option<AnyElement> {
|
|
let file = excerpt_info.buffer.file()?;
|
|
let git_panel = self.git_panel.read(cx);
|
|
|
|
git_panel.render_buffer_header_controls(&self.git_panel, &file, window, cx)
|
|
}
|
|
}
|
|
|
|
impl Panel for GitPanel {
|
|
fn persistent_name() -> &'static str {
|
|
"GitPanel"
|
|
}
|
|
|
|
fn position(&self, _: &Window, cx: &App) -> DockPosition {
|
|
GitPanelSettings::get_global(cx).dock
|
|
}
|
|
|
|
fn position_is_valid(&self, position: DockPosition) -> bool {
|
|
matches!(position, DockPosition::Left | DockPosition::Right)
|
|
}
|
|
|
|
fn set_position(&mut self, position: DockPosition, _: &mut Window, cx: &mut Context<Self>) {
|
|
settings::update_settings_file::<GitPanelSettings>(
|
|
self.fs.clone(),
|
|
cx,
|
|
move |settings, _| settings.dock = Some(position),
|
|
);
|
|
}
|
|
|
|
fn size(&self, _: &Window, cx: &App) -> Pixels {
|
|
self.width
|
|
.unwrap_or_else(|| GitPanelSettings::get_global(cx).default_width)
|
|
}
|
|
|
|
fn set_size(&mut self, size: Option<Pixels>, _: &mut Window, cx: &mut Context<Self>) {
|
|
self.width = size;
|
|
self.serialize(cx);
|
|
cx.notify();
|
|
}
|
|
|
|
fn icon(&self, _: &Window, cx: &App) -> Option<ui::IconName> {
|
|
Some(ui::IconName::GitBranch).filter(|_| GitPanelSettings::get_global(cx).button)
|
|
}
|
|
|
|
fn icon_tooltip(&self, _window: &Window, _cx: &App) -> Option<&'static str> {
|
|
Some("Git Panel")
|
|
}
|
|
|
|
fn toggle_action(&self) -> Box<dyn Action> {
|
|
Box::new(ToggleFocus)
|
|
}
|
|
|
|
fn activation_priority(&self) -> u32 {
|
|
2
|
|
}
|
|
}
|
|
|
|
impl PanelHeader for GitPanel {}
|