use crate::git_panel_settings::StatusStyle;use crate::{git_panel_settings::GitPanelSettings, git_status_icon};use anyhow::{Context as _, Result};use db::kvp::KEY_VALUE_STORE;use editor::actions::MoveToEnd;use editor::scroll::ScrollbarAutoHide;use editor::{Editor, EditorSettings, ShowScrollbar};use futures::channel::mpsc;use futures::StreamExt as _;use git::repository::{GitRepository, RepoPath};use git::status::FileStatus;use git::{CommitAllChanges, CommitChanges, RevertAll, StageAll, ToggleStaged, UnstageAll};use gpui::*;use language::Buffer;use menu::{SelectFirst, SelectLast, SelectNext, SelectPrev};use project::git::GitState;use project::{Fs, Project, ProjectPath, WorktreeId};use serde::{Deserialize, Serialize};use settings::Settings as _;use std::sync::atomic::{AtomicBool, Ordering};use std::{collections::HashSet, ops::Range, path::PathBuf, sync::Arc, time::Duration, usize};use theme::ThemeSettings;use ui::{    prelude::*, Checkbox, Divider, DividerColor, ElevationIndex, Scrollbar, ScrollbarState, Tooltip,};use util::{maybe, ResultExt, TryFutureExt};use workspace::notifications::{DetachAndPromptErr, NotificationId};use workspace::Toast;use workspace::{    dock::{DockPosition, Panel, PanelEvent},    Workspace,};use worktree::RepositoryEntry; actions!(    git_panel,    [        Close,        ToggleFocus,        OpenMenu,        OpenSelected,        FocusEditor,        FocusChanges,        FillCoAuthors,    ]); const GIT_PANEL_KEY: &str = "GitPanel"; const UPDATE_DEBOUNCE: Duration = Duration::from_millis(50); pub fn init(cx: &mut AppContext) {    cx.observe_new_views(        |workspace: &mut Workspace, _cx: &mut ViewContext<Workspace>| {            workspace.register_action(|workspace, _: &ToggleFocus, cx| {                workspace.toggle_panel_focus::<GitPanel>(cx);            });        },    )    .detach();} #[derive(Debug, Clone)]pub enum Event {    Focus,    OpenedEntry { path: ProjectPath },} #[derive(Serialize, Deserialize)]struct SerializedGitPanel {    width: Option<Pixels>,} #[derive(Debug, PartialEq, Eq, Clone)]pub struct GitListEntry {    depth: usize,    display_name: String,    repo_path: RepoPath,    status: FileStatus,    is_staged: Option<bool>,} pub struct GitPanel {    weak_workspace: WeakView<Workspace>,    current_modifiers: Modifiers,    focus_handle: FocusHandle,    fs: Arc<dyn Fs>,    hide_scrollbar_task: Option<Task<()>>,    pending_serialization: Task<Option<()>>,    workspace: WeakView<Workspace>,    project: Model<Project>,    scroll_handle: UniformListScrollHandle,    scrollbar_state: ScrollbarState,    selected_entry: Option<usize>,    show_scrollbar: bool,    rebuild_requested: Arc<AtomicBool>,    commit_editor: View<Editor>,    visible_entries: Vec<GitListEntry>,    all_staged: Option<bool>,    width: Option<Pixels>,    reveal_in_editor: Task<()>,    err_sender: mpsc::Sender<anyhow::Error>,} fn first_worktree_repository(    project: &Model<Project>,    worktree_id: WorktreeId,    cx: &mut AppContext,) -> Option<(RepositoryEntry, Arc<dyn GitRepository>)> {    project        .read(cx)        .worktree_for_id(worktree_id, cx)        .and_then(|worktree| {            let snapshot = worktree.read(cx).snapshot();            let repo = snapshot.repositories().iter().next()?.clone();            let git_repo = worktree                .read(cx)                .as_local()?                .get_local_repo(&repo)?                .repo()                .clone();            Some((repo, git_repo))        })} fn first_repository_in_project(    project: &Model<Project>,    cx: &mut AppContext,) -> Option<(WorktreeId, RepositoryEntry, Arc<dyn GitRepository>)> {    project.read(cx).worktrees(cx).next().and_then(|worktree| {        let snapshot = worktree.read(cx).snapshot();        let repo = snapshot.repositories().iter().next()?.clone();        let git_repo = worktree            .read(cx)            .as_local()?            .get_local_repo(&repo)?            .repo()            .clone();        Some((snapshot.id(), repo, git_repo))    })} impl GitPanel {    pub fn load(        workspace: WeakView<Workspace>,        cx: AsyncWindowContext,    ) -> Task<Result<View<Self>>> {        cx.spawn(|mut cx| async move { workspace.update(&mut cx, Self::new) })    }     pub fn new(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) -> View<Self> {        let fs = workspace.app_state().fs.clone();        let project = workspace.project().clone();        let weak_workspace = cx.view().downgrade();        let git_state = project.read(cx).git_state().cloned();        let language_registry = workspace.app_state().languages.clone();        let current_commit_message = git_state            .as_ref()            .map(|git_state| git_state.read(cx).commit_message.clone());        let (err_sender, mut err_receiver) = mpsc::channel(1);        let workspace = cx.view().downgrade();         let git_panel = cx.new_view(|cx: &mut ViewContext<Self>| {            let focus_handle = cx.focus_handle();            cx.on_focus(&focus_handle, Self::focus_in).detach();            cx.on_focus_out(&focus_handle, |this, _, cx| {                this.hide_scrollbar(cx);            })            .detach();            cx.subscribe(&project, move |this, project, event, cx| {                use project::Event;                 let first_worktree_id = project.read(cx).worktrees(cx).next().map(|worktree| {                    let snapshot = worktree.read(cx).snapshot();                    snapshot.id()                });                let first_repo_in_project = first_repository_in_project(&project, cx);                 let Some(git_state) = project.read(cx).git_state().cloned() else {                    return;                };                git_state.update(cx, |git_state, _| {                    match event {                        project::Event::WorktreeRemoved(id) => {                            let Some((worktree_id, _, _)) = git_state.active_repository.as_ref()                            else {                                return;                            };                            if worktree_id == id {                                git_state.active_repository = first_repo_in_project;                                this.schedule_update();                            }                        }                        project::Event::WorktreeOrderChanged => {                            // activate the new first worktree if the first was moved                            let Some(first_id) = first_worktree_id else {                                return;                            };                            if !git_state                                .active_repository                                .as_ref()                                .is_some_and(|(id, _, _)| id == &first_id)                            {                                git_state.active_repository = first_repo_in_project;                                this.schedule_update();                            }                        }                        Event::WorktreeAdded(_) => {                            let Some(first_id) = first_worktree_id else {                                return;                            };                            if !git_state                                .active_repository                                .as_ref()                                .is_some_and(|(id, _, _)| id == &first_id)                            {                                git_state.active_repository = first_repo_in_project;                                this.schedule_update();                            }                        }                        project::Event::WorktreeUpdatedEntries(id, _) => {                            if git_state                                .active_repository                                .as_ref()                                .is_some_and(|(active_id, _, _)| active_id == id)                            {                                git_state.active_repository = first_repo_in_project;                                this.schedule_update();                            }                        }                        project::Event::WorktreeUpdatedGitRepositories(_) => {                            let Some(first) = first_repo_in_project else {                                return;                            };                            git_state.active_repository = Some(first);                            this.schedule_update();                        }                        project::Event::Closed => {                            this.reveal_in_editor = Task::ready(());                            this.visible_entries.clear();                        }                        _ => {}                    };                });            })            .detach();             let commit_editor = cx.new_view(|cx| {                let theme = ThemeSettings::get_global(cx);                 let mut text_style = cx.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 = Editor::auto_height(10, cx);                if let Some(message) = current_commit_message {                    commit_editor.set_text(message, cx);                } else {                    commit_editor.set_text("", 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            });             let buffer = commit_editor                .read(cx)                .buffer()                .read(cx)                .as_singleton()                .expect("commit editor must be singleton");             cx.subscribe(&buffer, Self::on_buffer_event).detach();             let markdown = language_registry.language_for_name("Markdown");            cx.spawn(|_, mut cx| async move {                let markdown = markdown.await.context("failed to load Markdown language")?;                buffer.update(&mut cx, |buffer, cx| {                    buffer.set_language(Some(markdown), cx)                })            })            .detach_and_log_err(cx);             let scroll_handle = UniformListScrollHandle::new();             let mut visible_worktrees = project.read(cx).visible_worktrees(cx);            let first_worktree = visible_worktrees.next();            drop(visible_worktrees);            if let Some(first_worktree) = first_worktree {                let snapshot = first_worktree.read(cx).snapshot();                 if let Some(((repo, git_repo), git_state)) =                    first_worktree_repository(&project, snapshot.id(), cx).zip(git_state)                {                    git_state.update(cx, |git_state, _| {                        git_state.activate_repository(snapshot.id(), repo, git_repo);                    });                }            };             let rebuild_requested = Arc::new(AtomicBool::new(false));            let flag = rebuild_requested.clone();            let handle = cx.view().downgrade();            cx.spawn(|_, mut cx| async move {                loop {                    cx.background_executor().timer(UPDATE_DEBOUNCE).await;                    if flag.load(Ordering::Relaxed) {                        if let Some(this) = handle.upgrade() {                            this.update(&mut cx, |this, cx| {                                this.update_visible_entries(cx);                            })                            .ok();                        }                        flag.store(false, Ordering::Relaxed);                    }                }            })            .detach();             let mut git_panel = Self {                weak_workspace,                focus_handle: cx.focus_handle(),                fs,                pending_serialization: Task::ready(None),                visible_entries: Vec::new(),                all_staged: None,                current_modifiers: cx.modifiers(),                width: Some(px(360.)),                scrollbar_state: ScrollbarState::new(scroll_handle.clone()).parent_view(cx.view()),                scroll_handle,                selected_entry: None,                show_scrollbar: false,                hide_scrollbar_task: None,                rebuild_requested,                commit_editor,                project,                reveal_in_editor: Task::ready(()),                err_sender,                workspace,            };            git_panel.schedule_update();            git_panel.show_scrollbar = git_panel.should_show_scrollbar(cx);            git_panel        });         let handle = git_panel.downgrade();        cx.spawn(|_, mut cx| async move {            while let Some(e) = err_receiver.next().await {                let Some(this) = handle.upgrade() else {                    break;                };                if this                    .update(&mut cx, |this, cx| {                        this.show_err_toast("git operation error", e, cx);                    })                    .is_err()                {                    break;                }            }        })        .detach();         cx.subscribe(            &git_panel,            move |workspace, _, event: &Event, cx| match event.clone() {                Event::OpenedEntry { path } => {                    workspace                        .open_path_preview(path, None, false, false, cx)                        .detach_and_prompt_err("Failed to open file", cx, |e, _| {                            Some(format!("{e}"))                        });                }                Event::Focus => { /* TODO */ }            },        )        .detach();         git_panel    }     fn git_state(&self, cx: &AppContext) -> Option<Model<GitState>> {        self.project.read(cx).git_state().cloned()    }     fn active_repository<'a>(        &self,        cx: &'a AppContext,    ) -> Option<&'a (WorktreeId, RepositoryEntry, Arc<dyn GitRepository>)> {        let git_state = self.git_state(cx)?;        let active_repository = git_state.read(cx).active_repository.as_ref()?;        Some(active_repository)    }     fn serialize(&mut self, cx: &mut ViewContext<Self>) {        // TODO: we can store stage status here        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, cx: &ViewContext<Self>) -> KeyContext {        let mut dispatch_context = KeyContext::new_with_defaults();        dispatch_context.add("GitPanel");         if self.is_focused(cx) {            dispatch_context.add("menu");            dispatch_context.add("ChangesList");        }         if self.commit_editor.read(cx).is_focused(cx) {            dispatch_context.add("CommitEditor");        }         dispatch_context    }     fn is_focused(&self, cx: &ViewContext<Self>) -> bool {        cx.focused()            .map_or(false, |focused| self.focus_handle == focused)    }     fn close_panel(&mut self, _: &Close, cx: &mut ViewContext<Self>) {        cx.emit(PanelEvent::Close);    }     fn focus_in(&mut self, cx: &mut ViewContext<Self>) {        if !self.focus_handle.contains_focused(cx) {            cx.emit(Event::Focus);        }    }     fn show_scrollbar(&self, cx: &mut ViewContext<Self>) -> ShowScrollbar {        GitPanelSettings::get_global(cx)            .scrollbar            .show            .unwrap_or_else(|| EditorSettings::get_global(cx).scrollbar.show)    }     fn should_show_scrollbar(&self, cx: &mut ViewContext<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 ViewContext<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, cx: &mut ViewContext<Self>) {        const SCROLLBAR_SHOW_INTERVAL: Duration = Duration::from_secs(1);        if !self.should_autohide_scrollbar(cx) {            return;        }        self.hide_scrollbar_task = Some(cx.spawn(|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();        }))    }

Lines 1–500 of 1535. Load more