project_tree_pane.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2012 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <stack>
#include <git/git_backend.h>
 
#include <wx/regex.h>
#include <wx/richmsgdlg.h>
#include <wx/stdpaths.h>
#include <wx/string.h>
#include <wx/msgdlg.h>
#include <wx/textdlg.h>
#include <wx/timer.h>
#include <wx/wupdlock.h>
#include <wx/log.h>
#include <wx/dcclient.h>
#include <wx/progdlg.h>
#include <wx/settings.h>
 
#include <frame_type.h>
#include <kiway.h>
#include <mail_type.h>
#include <settings/settings_manager.h>
 
#include <settings/common_settings.h>
#include <advanced_config.h>
#include <bitmaps.h>
#include <bitmap_store.h>
#include <confirm.h>
#include <dialogs/git/dialog_git_commit.h>
#include <dialogs/git/dialog_git_credentials.h>
#include <dialogs/git/dialog_git_switch.h>
#include <gestfich.h>
#include <macros.h>
#include <trace_helpers.h>
#include <wildcards_and_files_ext.h>
#include <kiplatform/environment.h>
#include <core/kicad_algo.h>
#include <paths.h>
#include <project/project_local_settings.h>
#include <scoped_set_reset.h>
#include <string_utils.h>
#include <thread_pool.h>
#include <launch_ext.h>
#include <wx_log_utils.h>
 
#include <git/git_commit_handler.h>
#include <git/git_config_handler.h>
#include <git/git_pull_handler.h>
#include <git/git_push_handler.h>
#include <git/git_resolve_conflict_handler.h>
#include <git/git_revert_handler.h>
#include <git/git_remove_from_index_handler.h>
#include <git/git_sync_handler.h>
#include <git/git_clone_handler.h>
#include <git/kicad_git_compat.h>
#include <git/git_init_handler.h>
#include <git/git_branch_handler.h>
#include <git/git_status_handler.h>
#include <git/kicad_git_common.h>
#include <git/kicad_git_memory.h>
#include <git/project_git_utils.h>
 
#include <dialogs/git/dialog_git_repository.h>
 
#include "project_tree_item.h"
#include "project_tree.h"
#include "pgm_kicad.h"
#include "kicad_id.h"
#include "kicad_manager_frame.h"
 
#include "project_tree_pane.h"
#include <widgets/kistatusbar.h>
 
#include <kiplatform/io.h>
#include <kiplatform/secrets.h>
 
 
/* Note about the project tree build process:
 * Building the project tree can be *very* long if there are a lot of subdirectories in the
 * working directory.  Unfortunately, this happens easily if the project file *.pro is in the
 * user's home directory.
 * So the tree project is built "on demand":
 * First the tree is built from the current directory and shows files and subdirs.
 *   > First level subdirs trees are built (i.e subdirs contents are not read)
 *   > When expanding a subdir, each subdir contains is read, and the corresponding sub tree is
 *     populated on the fly.
 */
 
// list of files extensions listed in the tree project window
// Add extensions in a compatible regex format to see others files types
static const wxChar* s_allowedExtensionsToList[] =
{
    wxT( "^.*\\.pro$" ),
    wxT( "^.*\\.kicad_pro$" ),
    wxT( "^.*\\.pdf$" ),
    wxT( "^.*\\.sch$" ),           // Legacy Eeschema files
    wxT( "^.*\\.kicad_sch$" ),     // S-expr Eeschema files
    wxT( "^[^$].*\\.brd$" ),       // Legacy Pcbnew files
    wxT( "^[^$].*\\.kicad_pcb$" ), // S format Pcbnew board files
    wxT( "^[^$].*\\.kicad_dru$" ), // Design rule files
    wxT( "^[^$].*\\.kicad_wks$" ), // S format kicad drawing sheet files
    wxT( "^[^$].*\\.kicad_mod$" ), // S format kicad footprint files, currently not listed
    wxT( "^.*\\.net$" ),           // pcbnew netlist file
    wxT( "^.*\\.cir$" ),           // Spice netlist file
    wxT( "^.*\\.lib$" ),           // Legacy schematic library file
    wxT( "^.*\\.kicad_sym$" ),     // S-expr symbol libraries
    wxT( "^.*\\.txt$" ),           // Text files
    wxT( "^.*\\.md$" ),            // Markdown files
    wxT( "^.*\\.pho$" ),           // Gerber file (Old Kicad extension)
    wxT( "^.*\\.gbr$" ),           // Gerber file
    wxT( "^.*\\.gbrjob$" ),        // Gerber job file
    wxT( "^.*\\.gb[alops]$" ),     // Gerber back (or bottom) layer file (deprecated Protel ext)
    wxT( "^.*\\.gt[alops]$" ),     // Gerber front (or top) layer file (deprecated Protel ext)
    wxT( "^.*\\.g[0-9]{1,2}$" ),   // Gerber inner layer file (deprecated Protel ext)
    wxT( "^.*\\.gm[0-9]{1,2}$" ),  // Gerber mechanical layer file (deprecated Protel ext)
    wxT( "^.*\\.gko$" ),           // Gerber keepout layer file (deprecated Protel ext)
    wxT( "^.*\\.odt$" ),
    wxT( "^.*\\.htm$" ),
    wxT( "^.*\\.html$" ),
    wxT( "^.*\\.rpt$" ),           // Report files
    wxT( "^.*\\.csv$" ),           // Report files in comma separated format
    wxT( "^.*\\.pos$" ),           // Footprint position files
    wxT( "^.*\\.cmp$" ),           // CvPcb cmp/footprint link files
    wxT( "^.*\\.drl$" ),           // Excellon drill files
    wxT( "^.*\\.nc$" ),            // Excellon NC drill files (alternate file ext)
    wxT( "^.*\\.xnc$" ),           // Excellon NC drill files (alternate file ext)
    wxT( "^.*\\.svg$" ),           // SVG print/plot files
    wxT( "^.*\\.ps$" ),            // PostScript plot files
    wxT( "^.*\\.zip$" ),           // Zip archive files
    wxT( "^.*\\.kicad_jobset" ),   // KiCad jobs file
    nullptr                        // end of list
};
 

 
 
enum project_tree_ids
{
    ID_PROJECT_TXTEDIT = 8700, // Start well above wxIDs
    ID_PROJECT_SWITCH_TO_OTHER,
    ID_PROJECT_NEWDIR,
    ID_PROJECT_OPEN_DIR,
    ID_PROJECT_DELETE,
    ID_PROJECT_RENAME,
 
    ID_GIT_INITIALIZE_PROJECT, // Initialize a new git repository in an existing project
    ID_GIT_REMOTE_SETTINGS,    // Configure (or set) the default remote on an existing repo
    ID_GIT_CLONE_PROJECT,      // Clone a project from a remote repository
    ID_GIT_COMMIT_PROJECT,     // Commit all files in the project
    ID_GIT_COMMIT_FILE,        // Commit a single file
    ID_GIT_AMEND_COMMIT,       // Amend the last commit on HEAD
    ID_GIT_SYNC_PROJECT,       // Sync the project with the remote repository (pull and push -- same as Update)
    ID_GIT_FETCH,              // Fetch the remote repository (without merging -- this is the same as Refresh)
    ID_GIT_PUSH,               // Push the local repository to the remote repository
    ID_GIT_PULL,               // Pull the remote repository to the local repository
    ID_GIT_RESOLVE_CONFLICT,   // Present the user with a resolve conflicts dialog (ours/theirs/merge)
    ID_GIT_REVERT_LOCAL,       // Revert the local repository to the last commit
    ID_GIT_COMPARE,            // Compare the current project to a different branch or commit in the git repository
    ID_GIT_REMOVE_VCS,         // Toggle Git integration for this project (preference in kicad_prl)
    ID_GIT_ADD_TO_INDEX,       // Add a file to the git index
    ID_GIT_REMOVE_FROM_INDEX,  // Remove a file from the git index
    ID_GIT_SWITCH_BRANCH,      // Switch the local repository to a different branch
    ID_GIT_SWITCH_QUICK1,      // Switch the local repository to the first quick branch
    ID_GIT_SWITCH_QUICK2,      // Switch the local repository to the second quick branch
    ID_GIT_SWITCH_QUICK3,      // Switch the local repository to the third quick branch
    ID_GIT_SWITCH_QUICK4,      // Switch the local repository to the fourth quick branch
    ID_GIT_SWITCH_QUICK5,      // Switch the local repository to the fifth quick branch
 
    ID_JOBS_RUN,
};
 
 
BEGIN_EVENT_TABLE( PROJECT_TREE_PANE, wxSashLayoutWindow )
    EVT_TREE_ITEM_ACTIVATED( ID_PROJECT_TREE, PROJECT_TREE_PANE::onSelect )
    EVT_TREE_ITEM_EXPANDED( ID_PROJECT_TREE, PROJECT_TREE_PANE::onExpand )
    EVT_TREE_ITEM_RIGHT_CLICK( ID_PROJECT_TREE, PROJECT_TREE_PANE::onRight )
    EVT_MENU( ID_PROJECT_TXTEDIT, PROJECT_TREE_PANE::onOpenSelectedFileWithTextEditor )
    EVT_MENU( ID_PROJECT_SWITCH_TO_OTHER, PROJECT_TREE_PANE::onSwitchToSelectedProject )
    EVT_MENU( ID_PROJECT_NEWDIR, PROJECT_TREE_PANE::onCreateNewDirectory )
    EVT_MENU( ID_PROJECT_OPEN_DIR, PROJECT_TREE_PANE::onOpenDirectory )
    EVT_MENU( ID_PROJECT_DELETE, PROJECT_TREE_PANE::onDeleteFile )
    EVT_MENU( ID_PROJECT_RENAME, PROJECT_TREE_PANE::onRenameFile )
 
    EVT_MENU( ID_GIT_INITIALIZE_PROJECT, PROJECT_TREE_PANE::onGitInitializeProject )
    EVT_MENU( ID_GIT_REMOTE_SETTINGS, PROJECT_TREE_PANE::onGitRemoteSettings )
    EVT_MENU( ID_GIT_COMMIT_PROJECT, PROJECT_TREE_PANE::onGitCommit )
    EVT_MENU( ID_GIT_COMMIT_FILE, PROJECT_TREE_PANE::onGitCommit )
    EVT_MENU( ID_GIT_AMEND_COMMIT, PROJECT_TREE_PANE::onGitAmendCommit )
    EVT_MENU( ID_GIT_SYNC_PROJECT, PROJECT_TREE_PANE::onGitSyncProject )
    EVT_MENU( ID_GIT_FETCH, PROJECT_TREE_PANE::onGitFetch )
    EVT_MENU( ID_GIT_PUSH, PROJECT_TREE_PANE::onGitPushProject )
    EVT_MENU( ID_GIT_PULL, PROJECT_TREE_PANE::onGitPullProject )
    EVT_MENU( ID_GIT_RESOLVE_CONFLICT, PROJECT_TREE_PANE::onGitResolveConflict )
    EVT_MENU( ID_GIT_REVERT_LOCAL, PROJECT_TREE_PANE::onGitRevertLocal )
    EVT_MENU( ID_GIT_SWITCH_BRANCH, PROJECT_TREE_PANE::onGitSwitchBranch )
    EVT_MENU_RANGE( ID_GIT_SWITCH_QUICK1, ID_GIT_SWITCH_QUICK5 + 1, PROJECT_TREE_PANE::onGitSwitchBranch )
    EVT_MENU( ID_GIT_COMPARE, PROJECT_TREE_PANE::onGitCompare )
    EVT_MENU( ID_GIT_REMOVE_VCS, PROJECT_TREE_PANE::onGitRemoveVCS )
    EVT_MENU( ID_GIT_ADD_TO_INDEX, PROJECT_TREE_PANE::onGitAddToIndex )
    EVT_MENU( ID_GIT_REMOVE_FROM_INDEX, PROJECT_TREE_PANE::onGitRemoveFromIndex )
 
    EVT_MENU( ID_JOBS_RUN, PROJECT_TREE_PANE::onRunSelectedJobsFile )
 
    EVT_IDLE( PROJECT_TREE_PANE::onIdle )
    EVT_PAINT( PROJECT_TREE_PANE::onPaint )
END_EVENT_TABLE()
 
 
wxDECLARE_EVENT( UPDATE_ICONS, wxCommandEvent );
 
PROJECT_TREE_PANE::PROJECT_TREE_PANE( KICAD_MANAGER_FRAME* parent ) :
        wxSashLayoutWindow( parent, ID_LEFT_FRAME, wxDefaultPosition, wxDefaultSize, wxNO_BORDER | wxTAB_TRAVERSAL )
{
    m_Parent = parent;
    m_TreeProject = nullptr;
    m_isRenaming = false;
    m_selectedItem = nullptr;
    m_watcherNeedReset = false;
    m_gitLastError = GIT_ERROR_NONE;
    m_watcher = nullptr;
    m_gitIconsInitialized = false;
 
    Bind( wxEVT_FSWATCHER,
             wxFileSystemWatcherEventHandler( PROJECT_TREE_PANE::onFileSystemEvent ), this );
 
    Bind( wxEVT_SYS_COLOUR_CHANGED,
          wxSysColourChangedEventHandler( PROJECT_TREE_PANE::onThemeChanged ), this );
 
    m_gitSyncTimer.SetOwner( this );
    m_gitStatusTimer.SetOwner( this );
    m_gitFeedbackTimer.SetOwner( this );
    Bind( wxEVT_TIMER, wxTimerEventHandler( PROJECT_TREE_PANE::onGitSyncTimer ), this, m_gitSyncTimer.GetId() );
    Bind( wxEVT_TIMER, wxTimerEventHandler( PROJECT_TREE_PANE::onGitStatusTimer ), this, m_gitStatusTimer.GetId() );
    Bind( wxEVT_TIMER, wxTimerEventHandler( PROJECT_TREE_PANE::onGitFeedbackTimer ), this, m_gitFeedbackTimer.GetId() );
    /*
     * Filtering is now inverted: the filters are actually used to _enable_ support
     * for a given file type.
     */
    for( int ii = 0; s_allowedExtensionsToList[ii] != nullptr; ii++ )
        m_filters.emplace_back( s_allowedExtensionsToList[ii] );
 
    m_filters.emplace_back( wxT( "^no KiCad files found" ) );
 
    ReCreateTreePrj();
}
 
 
PROJECT_TREE_PANE::~PROJECT_TREE_PANE()
{
    Unbind( wxEVT_FSWATCHER,
            wxFileSystemWatcherEventHandler( PROJECT_TREE_PANE::onFileSystemEvent ), this );
    Unbind( wxEVT_SYS_COLOUR_CHANGED,
            wxSysColourChangedEventHandler( PROJECT_TREE_PANE::onThemeChanged ), this );
 
    m_gitSyncTimer.Stop();
    m_gitStatusTimer.Stop();
    m_gitFeedbackTimer.Stop();
    Unbind( wxEVT_TIMER, wxTimerEventHandler( PROJECT_TREE_PANE::onGitSyncTimer ), this, m_gitSyncTimer.GetId() );
    Unbind( wxEVT_TIMER, wxTimerEventHandler( PROJECT_TREE_PANE::onGitStatusTimer ), this, m_gitStatusTimer.GetId() );
    Unbind( wxEVT_TIMER, wxTimerEventHandler( PROJECT_TREE_PANE::onGitFeedbackTimer ), this,
            m_gitFeedbackTimer.GetId() );
    shutdownFileWatcher();
 
    if( m_gitSyncTask.valid() )
        m_gitSyncTask.wait();
 
    if( m_gitStatusIconTask.valid() )
        m_gitStatusIconTask.wait();
}
 
 
void PROJECT_TREE_PANE::shutdownFileWatcher()
{
    if( m_watcher )
    {
        m_watcher->RemoveAll();
        m_watcher->SetOwner( nullptr );
        delete m_watcher;
        m_watcher = nullptr;
    }
}
 
 
void PROJECT_TREE_PANE::onSwitchToSelectedProject( wxCommandEvent& event )
{
    std::vector<PROJECT_TREE_ITEM*> tree_data = GetSelectedData();
 
    if( tree_data.size() != 1 )
        return;
 
    wxString prj_filename = tree_data[0]->GetFileName();
 
    m_Parent->LoadProject( prj_filename );
}
 
 
void PROJECT_TREE_PANE::onOpenDirectory( wxCommandEvent& event )
{
    // Get the root directory name:
    std::vector<PROJECT_TREE_ITEM*> tree_data = GetSelectedData();
 
    for( PROJECT_TREE_ITEM* item_data : tree_data )
    {
        // Ask for the new sub directory name
        wxString curr_dir = item_data->GetDir();
 
        if( curr_dir.IsEmpty() )
        {
            // Use project path if the tree view path was empty.
            curr_dir = wxPathOnly( m_Parent->GetProjectFileName() );
 
            // As a last resort use the user's documents folder.
            if( curr_dir.IsEmpty() || !wxFileName::DirExists( curr_dir ) )
                curr_dir = PATHS::GetDefaultUserProjectsPath();
 
            if( !curr_dir.IsEmpty() )
                curr_dir += wxFileName::GetPathSeparator();
        }
 
        LaunchExternal( curr_dir );
    }
}
 
 
void PROJECT_TREE_PANE::onCreateNewDirectory( wxCommandEvent& event )
{
    // Get the root directory name:
    std::vector<PROJECT_TREE_ITEM*> tree_data = GetSelectedData();
 
    for( PROJECT_TREE_ITEM* item_data : tree_data )
    {
        wxString prj_dir = wxPathOnly( m_Parent->GetProjectFileName() );
 
        // Ask for the new sub directory name
        wxString curr_dir = item_data->GetDir();
 
        if( curr_dir.IsEmpty() )
            curr_dir = prj_dir;
 
        wxString new_dir = wxGetTextFromUser( _( "Directory name:" ), _( "Create New Directory" ) );
 
        if( new_dir.IsEmpty() )
            return;
 
        wxString full_dirname = curr_dir + wxFileName::GetPathSeparator() + new_dir;
 
        if( !wxMkdir( full_dirname ) )
            return;
 
        addItemToProjectTree( full_dirname, item_data->GetId(), nullptr, false );
    }
}
 
 
wxString PROJECT_TREE_PANE::GetFileExt( TREE_FILE_TYPE type )
{
    switch( type )
    {
    case TREE_FILE_TYPE::LEGACY_PROJECT:        return FILEEXT::LegacyProjectFileExtension;
    case TREE_FILE_TYPE::JSON_PROJECT:          return FILEEXT::ProjectFileExtension;
    case TREE_FILE_TYPE::LEGACY_SCHEMATIC:      return FILEEXT::LegacySchematicFileExtension;
    case TREE_FILE_TYPE::SEXPR_SCHEMATIC:       return FILEEXT::KiCadSchematicFileExtension;
    case TREE_FILE_TYPE::LEGACY_PCB:            return FILEEXT::LegacyPcbFileExtension;
    case TREE_FILE_TYPE::SEXPR_PCB:             return FILEEXT::KiCadPcbFileExtension;
    case TREE_FILE_TYPE::GERBER:                return FILEEXT::GerberFileExtensionsRegex;
    case TREE_FILE_TYPE::GERBER_JOB_FILE:       return FILEEXT::GerberJobFileExtension;
    case TREE_FILE_TYPE::HTML:                  return FILEEXT::HtmlFileExtension;
    case TREE_FILE_TYPE::PDF:                   return FILEEXT::PdfFileExtension;
    case TREE_FILE_TYPE::TXT:                   return FILEEXT::TextFileExtension;
    case TREE_FILE_TYPE::MD:                    return FILEEXT::MarkdownFileExtension;
    case TREE_FILE_TYPE::NET:                   return FILEEXT::NetlistFileExtension;
    case TREE_FILE_TYPE::NET_SPICE:             return FILEEXT::SpiceFileExtension;
    case TREE_FILE_TYPE::CMP_LINK:              return FILEEXT::FootprintAssignmentFileExtension;
    case TREE_FILE_TYPE::REPORT:                return FILEEXT::ReportFileExtension;
    case TREE_FILE_TYPE::FP_PLACE:              return FILEEXT::FootprintPlaceFileExtension;
    case TREE_FILE_TYPE::DRILL:                 return FILEEXT::DrillFileExtension;
    case TREE_FILE_TYPE::DRILL_NC:              return "nc";
    case TREE_FILE_TYPE::DRILL_XNC:             return "xnc";
    case TREE_FILE_TYPE::SVG:                   return FILEEXT::SVGFileExtension;
    case TREE_FILE_TYPE::CSV:                   return FILEEXT::CsvFileExtension;
    case TREE_FILE_TYPE::DRAWING_SHEET:         return FILEEXT::DrawingSheetFileExtension;
    case TREE_FILE_TYPE::FOOTPRINT_FILE:        return FILEEXT::KiCadFootprintFileExtension;
    case TREE_FILE_TYPE::SCHEMATIC_LIBFILE:     return FILEEXT::LegacySymbolLibFileExtension;
    case TREE_FILE_TYPE::SEXPR_SYMBOL_LIB_FILE: return FILEEXT::KiCadSymbolLibFileExtension;
    case TREE_FILE_TYPE::DESIGN_RULES:          return FILEEXT::DesignRulesFileExtension;
    case TREE_FILE_TYPE::ZIP_ARCHIVE:           return FILEEXT::ArchiveFileExtension;
    case TREE_FILE_TYPE::JOBSET_FILE:           return FILEEXT::KiCadJobSetFileExtension;
 
    case TREE_FILE_TYPE::ROOT:
    case TREE_FILE_TYPE::UNKNOWN:
    case TREE_FILE_TYPE::MAX:
    case TREE_FILE_TYPE::DIRECTORY:             break;
    }
 
    return wxEmptyString;
}
 
 
std::vector<wxString> getProjects( const wxDir& dir )
{
    std::vector<wxString> projects;
    wxString              dir_filename;
    bool                  haveFile = dir.GetFirst( &dir_filename );
 
    while( haveFile  )
    {
        wxFileName file( dir_filename );
 
        if( file.GetExt() == FILEEXT::LegacyProjectFileExtension
            || file.GetExt() == FILEEXT::ProjectFileExtension )
            projects.push_back( file.GetName() );
 
        haveFile = dir.GetNext( &dir_filename );
    }
 
    return projects;
}
 
 
 
 
 
wxTreeItemId PROJECT_TREE_PANE::addItemToProjectTree( const wxString& aName,
                                                      const wxTreeItemId& aParent,
                                                      std::vector<wxString>* aProjectNames,
                                                      bool aRecurse )
{
    TREE_FILE_TYPE type = TREE_FILE_TYPE::UNKNOWN;
    wxFileName     fn( aName );
 
    if( KIPLATFORM::IO::IsFileHidden( aName ) )
        return wxTreeItemId();
 
    if( wxDirExists( aName ) )
    {
        type = TREE_FILE_TYPE::DIRECTORY;
    }
    else
    {
        // Filter
        wxRegEx reg;
        bool    addFile = false;
 
        for( const wxString& m_filter : m_filters )
        {
            wxCHECK2_MSG( reg.Compile( m_filter, wxRE_ICASE ), continue,
                          wxString::Format( "Regex %s failed to compile.", m_filter ) );
 
            if( reg.Matches( aName ) )
            {
                addFile = true;
                break;
            }
        }
 
        if( !addFile )
            return wxTreeItemId();
 
        for( int i = static_cast<int>( TREE_FILE_TYPE::LEGACY_PROJECT );
                i < static_cast<int>( TREE_FILE_TYPE::MAX ); i++ )
        {
            wxString ext = GetFileExt( (TREE_FILE_TYPE) i );
 
            if( ext == wxT( "" ) )
                continue;
 
            if( reg.Compile( wxString::FromAscii( "^.*\\." ) + ext + wxString::FromAscii( "$" ), wxRE_ICASE )
                    && reg.Matches( aName ) )
            {
                type = (TREE_FILE_TYPE) i;
                break;
            }
        }
    }
 
    wxString   file = wxFileNameFromPath( aName );
    wxFileName currfile( file );
    wxFileName project( m_Parent->GetProjectFileName() );
    bool       showAllSchematics = m_TreeProject->GetGitRepo() != nullptr;
 
    // Ignore legacy projects with the same name as the current project
    if( ( type == TREE_FILE_TYPE::LEGACY_PROJECT )
            && ( currfile.GetName().CmpNoCase( project.GetName() ) == 0 ) )
    {
        return wxTreeItemId();
    }
 
    if( !showAllSchematics && ( currfile.GetExt() == GetFileExt( TREE_FILE_TYPE::LEGACY_SCHEMATIC )
                                || currfile.GetExt() == GetFileExt( TREE_FILE_TYPE::SEXPR_SCHEMATIC ) ) )
    {
        if( aProjectNames )
        {
            if( !alg::contains( *aProjectNames, currfile.GetName() ) )
                return wxTreeItemId();
        }
        else
        {
            PROJECT_TREE_ITEM* parentTreeItem = GetItemIdData( aParent );
 
            if( !parentTreeItem )
                return wxTreeItemId();
 
            wxDir                 parentDir( parentTreeItem->GetDir() );
            std::vector<wxString> projects = getProjects( parentDir );
 
            if( !alg::contains( projects, currfile.GetName() ) )
                return wxTreeItemId();
        }
    }
 
    // also check to see if it is already there.
    wxTreeItemIdValue cookie;
    wxTreeItemId      kid = m_TreeProject->GetFirstChild( aParent, cookie );
 
    while( kid.IsOk() )
    {
        PROJECT_TREE_ITEM* itemData = GetItemIdData( kid );
 
        if( itemData && itemData->GetFileName() == aName )
            return itemData->GetId();    // well, we would have added it, but it is already here!
 
        kid = m_TreeProject->GetNextChild( aParent, cookie );
    }
 
    // Only show current files if both legacy and current files are present
    if( type == TREE_FILE_TYPE::LEGACY_PROJECT
            || type == TREE_FILE_TYPE::JSON_PROJECT
            || type == TREE_FILE_TYPE::LEGACY_SCHEMATIC
            || type == TREE_FILE_TYPE::SEXPR_SCHEMATIC )
    {
        kid = m_TreeProject->GetFirstChild( aParent, cookie );
 
        while( kid.IsOk() )
        {
            PROJECT_TREE_ITEM* itemData = GetItemIdData( kid );
 
            if( itemData )
            {
                wxFileName fname( itemData->GetFileName() );
 
                if( fname.GetName().CmpNoCase( currfile.GetName() ) == 0 )
                {
                    switch( type )
                    {
                    case TREE_FILE_TYPE::LEGACY_PROJECT:
                        if( itemData->GetType() == TREE_FILE_TYPE::JSON_PROJECT )
                            return wxTreeItemId();
 
                        break;
 
                    case TREE_FILE_TYPE::LEGACY_SCHEMATIC:
                        if( itemData->GetType() == TREE_FILE_TYPE::SEXPR_SCHEMATIC )
                            return wxTreeItemId();
 
                        break;
 
                    case TREE_FILE_TYPE::JSON_PROJECT:
                        if( itemData->GetType() == TREE_FILE_TYPE::LEGACY_PROJECT )
                            m_TreeProject->Delete( kid );
 
                        break;
 
                    case TREE_FILE_TYPE::SEXPR_SCHEMATIC:
                        if( itemData->GetType() == TREE_FILE_TYPE::LEGACY_SCHEMATIC )
                            m_TreeProject->Delete( kid );
 
                        break;
 
                    default:
                        break;
                    }
                }
            }
 
            kid = m_TreeProject->GetNextChild( aParent, cookie );
        }
    }
 
    // Append the item (only appending the filename not the full path):
    wxTreeItemId       newItemId = m_TreeProject->AppendItem( aParent, file );
    PROJECT_TREE_ITEM* data = new PROJECT_TREE_ITEM( type, aName, m_TreeProject );
 
    m_TreeProject->SetItemData( newItemId, data );
    data->SetState( 0 );
 
    // Mark root files (files which have the same aName as the project)
    wxString fileName = currfile.GetName().Lower();
    wxString projName = project.GetName().Lower();
 
    if( fileName == projName || fileName.StartsWith( projName + "-" ) )
        data->SetRootFile( true );
 
#ifndef __WINDOWS__
    bool subdir_populated = false;
#endif
 
    // This section adds dirs and files found in the subdirs
    // in this case AddFile is recursive, but for the first level only.
    if( TREE_FILE_TYPE::DIRECTORY == type && aRecurse )
    {
        wxDir dir( aName );
 
        if( dir.IsOpened() )    // protected dirs will not open properly.
        {
            std::vector<wxString> projects = getProjects( dir );
            wxString              dir_filename;
            bool                  haveFile = dir.GetFirst( &dir_filename );
 
            data->SetPopulated( true );
 
#ifndef __WINDOWS__
            subdir_populated = aRecurse;
#endif
 
            while( haveFile  )
            {
                // Add name in tree, but do not recurse
                wxString path = aName + wxFileName::GetPathSeparator() + dir_filename;
                addItemToProjectTree( path, newItemId, &projects, false );
 
                haveFile = dir.GetNext( &dir_filename );
            }
        }
 
        // Sort filenames by alphabetic order
        m_TreeProject->SortChildren( newItemId );
    }
 
#ifndef __WINDOWS__
    if( subdir_populated )
        m_watcherNeedReset = true;
#endif
 
    return newItemId;
}
 
 
void PROJECT_TREE_PANE::ReCreateTreePrj()
{
    std::lock_guard<std::mutex> lock1( m_gitStatusMutex );
    std::lock_guard<std::mutex> lock2( m_gitTreeCacheMutex );
 
    m_gitStatusTimer.Stop();
    m_gitSyncTimer.Stop();
 
    if( m_TreeProject && m_TreeProject->GetGitRepo() )
        m_TreeProject->GitCommon()->SetCancelled( true );
 
    m_gitTreeCache.clear();
    m_gitStatusIcons.clear();
 
    wxString pro_dir = m_Parent->GetProjectFileName();
 
    if( !m_TreeProject )
        m_TreeProject = new PROJECT_TREE( this );
    else
        m_TreeProject->DeleteAllItems();
 
    if( !pro_dir )  // This is empty from PROJECT_TREE_PANE constructor
        return;
 
    if( m_TreeProject->GetGitRepo() )
    {
        releaseGitRepo();
        m_gitIconsInitialized = false;
    }
 
    wxFileName fn = pro_dir;
    bool prjReset = false;
 
    if( !fn.IsOk() )
    {
        fn.Clear();
        fn.SetPath( PATHS::GetDefaultUserProjectsPath() );
        fn.SetName( NAMELESS_PROJECT );
        fn.SetExt( FILEEXT::ProjectFileExtension );
        prjReset = true;
    }
 
    bool prjOpened = fn.FileExists();
 
    // Bind the git repository to the project tree (if it exists and not disabled for this project)
    if( Pgm().GetCommonSettings()->m_Git.enableGit
        && !Prj().GetLocalSettings().m_GitIntegrationDisabled )
    {
        m_TreeProject->SetGitRepo( KIGIT::PROJECT_GIT_UTILS::GetRepositoryForFile( fn.GetPath().c_str() ) );
 
        if( m_TreeProject->GetGitRepo() )
        {
            // Reset the cancel flag so git operations work after project switches.
            // EmptyTreePrj() sets this to true during shutdown.
            m_TreeProject->GitCommon()->SetCancelled( false );
 
            const char* canonicalWorkDir = git_repository_workdir( m_TreeProject->GetGitRepo() );
 
            if( canonicalWorkDir )
            {
                wxString symlinkWorkDir = KIGIT::PROJECT_GIT_UTILS::ComputeSymlinkPreservingWorkDir(
                        fn.GetPath(), wxString::FromUTF8( canonicalWorkDir ) );
                m_TreeProject->GitCommon()->SetProjectDir( symlinkWorkDir );
            }
 
            m_TreeProject->GitCommon()->SetUsername( Prj().GetLocalSettings().m_GitRepoUsername );
            m_TreeProject->GitCommon()->SetSSHKey( Prj().GetLocalSettings().m_GitSSHKey );
            m_TreeProject->GitCommon()->UpdateCurrentBranchInfo();
        }
    }
 
    // We may have opened a legacy project, in which case GetProjectFileName will return the
    // name of the migrated (new format) file, which may not have been saved to disk yet.
    if( !prjOpened && !prjReset )
    {
        fn.SetExt( FILEEXT::LegacyProjectFileExtension );
        prjOpened = fn.FileExists();
 
        // Set the ext back so that in the tree view we see the (not-yet-saved) new file
        fn.SetExt( FILEEXT::ProjectFileExtension );
    }
 
    // root tree:
    m_root = m_TreeProject->AddRoot( fn.GetFullName(), static_cast<int>( TREE_FILE_TYPE::ROOT ),
                                     static_cast<int>( TREE_FILE_TYPE::ROOT ) );
    m_TreeProject->SetItemBold( m_root, true );
 
    // The main project file is now a JSON file
    PROJECT_TREE_ITEM* data = new PROJECT_TREE_ITEM( TREE_FILE_TYPE::JSON_PROJECT, fn.GetFullPath(),
                                                     m_TreeProject );
 
    m_TreeProject->SetItemData( m_root, data );
 
    // Now adding all current files if available
    if( prjOpened )
    {
        pro_dir = wxPathOnly( m_Parent->GetProjectFileName() );
        wxDir dir( pro_dir );
 
        if( dir.IsOpened() )    // protected dirs will not open, see "man opendir()"
        {
            std::vector<wxString> projects = getProjects( dir );
            wxString              filename;
            bool                  haveFile = dir.GetFirst( &filename );
 
            while( haveFile )
            {
                if( filename != fn.GetFullName() )
                {
                    wxString name = dir.GetName() + wxFileName::GetPathSeparator() + filename;
 
                    // Add items living in the project directory, and populate the item
                    // if it is a directory (sub directories will be not populated)
                    addItemToProjectTree( name, m_root, &projects, true );
                }
 
                haveFile = dir.GetNext( &filename );
            }
        }
    }
    else
    {
        m_TreeProject->AppendItem( m_root, wxT( "Empty project" ) );
    }
 
    m_TreeProject->Expand( m_root );
 
    // Sort filenames by alphabetic order
    m_TreeProject->SortChildren( m_root );
 
    CallAfter(
            [this] ()
            {
                wxLogTrace( traceGit, "PROJECT_TREE_PANE::ReCreateTreePrj: starting timers" );
                m_gitSyncTimer.Start( 100, wxTIMER_ONE_SHOT );
                m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
            } );
}
 
 
bool PROJECT_TREE_PANE::hasChangedFiles()
{
    if( !m_TreeProject->GetGitRepo() )
        return false;
 
    GIT_STATUS_HANDLER statusHandler( m_TreeProject->GitCommon() );
    return statusHandler.HasChangedFiles();
}
 
 
void PROJECT_TREE_PANE::onRight( wxTreeEvent& Event )
{
    wxTreeItemId curr_item = Event.GetItem();
 
    // Ensure item is selected (Under Windows right click does not select the item)
    m_TreeProject->SelectItem( curr_item );
 
    std::vector<PROJECT_TREE_ITEM*> selection = GetSelectedData();
    KIGIT_COMMON* git = m_TreeProject->GitCommon();
 
    bool can_switch_to_project = true;
    bool can_create_new_directory = true;
    bool can_open_this_directory = true;
    bool can_edit = true;
    bool can_rename = true;
    bool can_delete = true;
    bool run_jobs = false;
 
    bool vcs_has_repo    = m_TreeProject->GetGitRepo() != nullptr;
    bool vcs_can_commit  = hasChangedFiles();
    bool vcs_can_init    = !vcs_has_repo;
    bool vcs_can_set_remote = vcs_has_repo;
    bool vcs_can_amend = vcs_has_repo && git_repository_head_unborn( m_TreeProject->GetGitRepo() ) == 0;
    bool gitIntegrationDisabled = Prj().GetLocalSettings().m_GitIntegrationDisabled;
    // Disable/Enable is a per-project preference toggle, so it's available whenever we
    // detected a repository for this project or integration is currently disabled.
    bool vcs_can_remove = vcs_has_repo || gitIntegrationDisabled;
    bool vcs_can_fetch   = vcs_has_repo && git->HasPushAndPullRemote();
    bool vcs_can_push    = vcs_can_fetch && git->HasLocalCommits();
    bool vcs_can_pull    = vcs_can_fetch;
    bool vcs_can_switch  = vcs_has_repo;
    bool vcs_menu        = Pgm().GetCommonSettings()->m_Git.enableGit;
 
    // Check if the libgit2 library is available via backend
    bool libgit_init = GetGitBackend() && GetGitBackend()->IsLibraryAvailable();
 
    vcs_menu &= libgit_init;
 
    if( selection.size() == 0 )
        return;
 
    // Remove things that don't make sense for multiple selections
    if( selection.size() != 1 )
    {
        can_switch_to_project = false;
        can_create_new_directory = false;
        can_rename = false;
    }
 
    for( PROJECT_TREE_ITEM* item : selection )
    {
        // Check for empty project
        if( !item )
        {
            can_switch_to_project = false;
            can_edit = false;
            can_rename = false;
            continue;
        }
 
        can_delete = item->CanDelete();
        can_rename = item->CanRename();
 
        switch( item->GetType() )
        {
        case TREE_FILE_TYPE::JSON_PROJECT:
        case TREE_FILE_TYPE::LEGACY_PROJECT:
            can_rename = false;
 
            if( item->GetId() == m_TreeProject->GetRootItem() )
            {
                can_switch_to_project = false;
            }
            else
            {
                can_create_new_directory = false;
                can_open_this_directory = false;
            }
            break;
 
        case TREE_FILE_TYPE::DIRECTORY:
            can_switch_to_project = false;
            can_edit = false;
            break;
 
        case TREE_FILE_TYPE::ZIP_ARCHIVE:
        case TREE_FILE_TYPE::PDF:
            can_edit = false;
            can_switch_to_project = false;
            can_create_new_directory = false;
            can_open_this_directory = false;
            break;
 
        case TREE_FILE_TYPE::JOBSET_FILE:
            run_jobs = true;
            can_edit = false;
            KI_FALLTHROUGH;
 
        case TREE_FILE_TYPE::SEXPR_SCHEMATIC:
        case TREE_FILE_TYPE::SEXPR_PCB:
            KI_FALLTHROUGH;
 
        default:
            can_switch_to_project = false;
            can_create_new_directory = false;
            can_open_this_directory = false;
 
            break;
        }
    }
 
    wxMenu   popup_menu;
    wxString text;
    wxString help_text;
 
    if( can_switch_to_project )
    {
        KIUI::AddMenuItem( &popup_menu, ID_PROJECT_SWITCH_TO_OTHER, _( "Switch to this Project" ),
                           _( "Close all editors, and switch to the selected project" ),
                           KiBitmap( BITMAPS::open_project ) );
        popup_menu.AppendSeparator();
    }
 
    if( can_create_new_directory )
    {
        KIUI::AddMenuItem( &popup_menu, ID_PROJECT_NEWDIR, _( "New Directory..." ),
                           _( "Create a New Directory" ), KiBitmap( BITMAPS::directory ) );
    }
 
    if( can_open_this_directory )
    {
        if( selection.size() == 1 )
        {
#ifdef __APPLE__
            text = _( "Reveal in Finder" );
            help_text = _( "Reveals the directory in a Finder window" );
#else
            text = _( "Open Directory in File Explorer" );
            help_text = _( "Opens the directory in the default system file manager" );
#endif
        }
        else
        {
#ifdef __APPLE__
            text = _( "Reveal in Finder" );
            help_text = _( "Reveals the directories in a Finder window" );
#else
            text = _( "Open Directories in File Explorer" );
            help_text = _( "Opens the directories in the default system file manager" );
#endif
        }
 
        KIUI::AddMenuItem( &popup_menu, ID_PROJECT_OPEN_DIR, text, help_text,
                           KiBitmap( BITMAPS::directory_browser ) );
    }
 
    if( can_edit )
    {
        if( selection.size() == 1 )
            help_text = _( "Open the file in a Text Editor" );
        else
            help_text = _( "Open files in a Text Editor" );
 
        KIUI::AddMenuItem( &popup_menu, ID_PROJECT_TXTEDIT, _( "Edit in a Text Editor" ), help_text,
                           KiBitmap( BITMAPS::editor ) );
    }
 
    if( run_jobs && selection.size() == 1 )
    {
        KIUI::AddMenuItem( &popup_menu, ID_JOBS_RUN, _( "Run Jobs" ), help_text,
                           KiBitmap( BITMAPS::exchange ) );
    }
 
    if( can_rename )
    {
        if( selection.size() == 1 )
        {
            text = _( "Rename File..." );
            help_text = _( "Rename file" );
        }
        else
        {
            text = _( "Rename Files..." );
            help_text = _( "Rename files" );
        }
 
        KIUI::AddMenuItem( &popup_menu, ID_PROJECT_RENAME, text, help_text,
                           KiBitmap( BITMAPS::right ) );
    }
 
    if( can_delete )
    {
        if( selection.size() == 1 )
            help_text = _( "Delete the file and its content" );
        else
            help_text = _( "Delete the files and their contents" );
 
        if( can_switch_to_project
                || can_create_new_directory
                || can_open_this_directory
                || can_edit
                || can_rename )
        {
            popup_menu.AppendSeparator();
        }
 
#ifdef __WINDOWS__
        KIUI::AddMenuItem( &popup_menu, ID_PROJECT_DELETE, _( "Delete" ), help_text,
                           KiBitmap( BITMAPS::trash ) );
#else
        KIUI::AddMenuItem( &popup_menu, ID_PROJECT_DELETE, _( "Move to Trash" ), help_text,
                           KiBitmap( BITMAPS::trash ) );
#endif
    }
 
    if( vcs_menu )
    {
        wxMenu*     vcs_submenu = new wxMenu();
        wxMenu*     branch_submenu = new wxMenu();
        wxMenuItem* vcs_menuitem = nullptr;
 
        vcs_menuitem = vcs_submenu->Append( ID_GIT_INITIALIZE_PROJECT,
                                            _( "Add Project to Version Control..." ),
                                            _( "Initialize a new repository" ) );
        vcs_menuitem->Enable( vcs_can_init );
 
        vcs_menuitem = vcs_submenu->Append( ID_GIT_REMOTE_SETTINGS, _( "Configure Default Remote..." ),
                                            _( "Set or change the default remote URL and credentials" ) );
        vcs_menuitem->Enable( vcs_can_set_remote );
 
        vcs_menuitem = vcs_submenu->Append( ID_GIT_COMMIT_PROJECT, _( "Commit Project..." ),
                                            _( "Commit changes to the local repository" ) );
        vcs_menuitem->Enable( vcs_can_commit );
 
        vcs_menuitem = vcs_submenu->Append( ID_GIT_AMEND_COMMIT, _( "Amend Last Commit..." ),
                                            _( "Rewrite the most recent commit on the current branch" ) );
        vcs_menuitem->Enable( vcs_can_amend );
 
        wxString pushLabel = _( "Push" );
        wxString pullLabel = _( "Pull" );
 
        if( !m_gitCurrentUpstream.empty() && !m_gitCurrentBranchName.empty() )
        {
            pushLabel = wxString::Format( _( "Push %s to %s" ), m_gitCurrentBranchName, m_gitCurrentUpstream );
            pullLabel = wxString::Format( _( "Pull from %s" ), m_gitCurrentUpstream );
        }
 
        vcs_menuitem =
                vcs_submenu->Append( ID_GIT_PUSH, pushLabel, _( "Push committed local changes to remote repository" ) );
        vcs_menuitem->Enable( vcs_can_push );
 
        vcs_menuitem =
                vcs_submenu->Append( ID_GIT_PULL, pullLabel, _( "Pull changes from remote repository into local" ) );
        vcs_menuitem->Enable( vcs_can_pull );
 
        vcs_submenu->AppendSeparator();
 
        vcs_menuitem = vcs_submenu->Append( ID_GIT_COMMIT_FILE, _( "Commit File..." ),
                                            _( "Commit changes to the local repository" ) );
        vcs_menuitem->Enable( vcs_can_commit );
 
        vcs_submenu->AppendSeparator();
 
        // vcs_menuitem = vcs_submenu->Append( ID_GIT_COMPARE, _( "Diff" ),
        //                              _( "Show changes between the repository and working tree" ) );
        // vcs_menuitem->Enable( vcs_can_diff );
 
        std::vector<wxString> branchNames = m_TreeProject->GitCommon()->GetBranchNames();
 
        // Skip the first one (that is the current branch)
        for( size_t ii = 1; ii < branchNames.size() && ii < 6; ++ii )
        {
            wxString msg = _( "Switch to branch " ) + branchNames[ii];
            vcs_menuitem = branch_submenu->Append( ID_GIT_SWITCH_BRANCH + ii, branchNames[ii], msg );
            vcs_menuitem->Enable( vcs_can_switch );
        }
 
        vcs_menuitem = branch_submenu->Append( ID_GIT_SWITCH_BRANCH, _( "Other..." ),
                                     _( "Switch to a different branch" ) );
        vcs_menuitem->Enable( vcs_can_switch );
 
        vcs_submenu->Append( ID_GIT_SWITCH_BRANCH, _( "Switch to Branch" ), branch_submenu );
 
        vcs_submenu->AppendSeparator();
 
        if( gitIntegrationDisabled )
        {
            vcs_menuitem = vcs_submenu->Append( ID_GIT_REMOVE_VCS, _( "Enable Git Integration" ),
                                 _( "Re-enable Git integration for this project" ) );
        }
        else
        {
            vcs_menuitem = vcs_submenu->Append( ID_GIT_REMOVE_VCS, _( "Disable Git Integration" ),
                                 _( "Disable Git integration for this project" ) );
        }
 
        vcs_menuitem->Enable( vcs_can_remove );
 
        popup_menu.AppendSeparator();
        popup_menu.AppendSubMenu( vcs_submenu, _( "Version Control" ) );
    }
 
    if( popup_menu.GetMenuItemCount() > 0 )
        PopupMenu( &popup_menu );
}
 
 
void PROJECT_TREE_PANE::onOpenSelectedFileWithTextEditor( wxCommandEvent& event )
{
    wxString editorname = Pgm().GetTextEditor();
 
    if( editorname.IsEmpty() )
    {
        wxMessageBox( _( "No text editor selected in KiCad.  Please choose one." ) );
        return;
    }
 
    std::vector<PROJECT_TREE_ITEM*> tree_data = GetSelectedData();
 
    for( PROJECT_TREE_ITEM* item_data : tree_data )
    {
        wxString fullFileName = item_data->GetFileName();
 
        if( !fullFileName.IsEmpty() )
        {
            ExecuteFile( editorname, fullFileName.wc_str(), nullptr, false );
        }
    }
}
 
 
void PROJECT_TREE_PANE::onDeleteFile( wxCommandEvent& event )
{
    std::vector<PROJECT_TREE_ITEM*> tree_data = GetSelectedData();
 
    for( PROJECT_TREE_ITEM* item_data : tree_data )
        item_data->Delete();
}
 
 
void PROJECT_TREE_PANE::onRenameFile( wxCommandEvent& event )
{
    wxTreeItemId                    curr_item = m_TreeProject->GetFocusedItem();
    std::vector<PROJECT_TREE_ITEM*> tree_data = GetSelectedData();
 
    // XXX: Unnecessary?
    if( tree_data.size() != 1 )
        return;
 
    wxString buffer = m_TreeProject->GetItemText( curr_item );
    wxString msg = wxString::Format( _( "Change filename: '%s'" ),
                                     tree_data[0]->GetFileName() );
    wxTextEntryDialog dlg( wxGetTopLevelParent( this ), msg, _( "Change filename" ), buffer );
 
    if( dlg.ShowModal() != wxID_OK )
        return; // canceled by user
 
    buffer = dlg.GetValue();
    buffer.Trim( true );
    buffer.Trim( false );
 
    if( buffer.IsEmpty() )
        return; // empty file name not allowed
 
    tree_data[0]->Rename( buffer, true );
    m_isRenaming = true;
}
 
 
void PROJECT_TREE_PANE::onSelect( wxTreeEvent& Event )
{
    std::vector<PROJECT_TREE_ITEM*> tree_data = GetSelectedData();
 
    if( tree_data.size() != 1 )
        return;
 
    // Bookmark the selected item but don't try and activate it until later.  If we do it now,
    // there will be more events at least on Windows in this frame that will steal focus from
    // any newly launched windows
    m_selectedItem = tree_data[0];
}
 
 
void PROJECT_TREE_PANE::onIdle( wxIdleEvent& aEvent )
{
    // Idle executes once all other events finished processing.  This makes it ideal to launch
    // a new window without starting Focus wars.
    if( m_watcherNeedReset )
    {
        m_selectedItem = nullptr;
        FileWatcherReset();
    }
 
    if( m_selectedItem != nullptr && m_TreeProject->GetRootItem().IsOk() )
    {
        // Make sure m_selectedItem still exists in the tree before activating it.
        std::vector<wxTreeItemId> validItemIds;
        m_TreeProject->GetItemsRecursively( m_TreeProject->GetRootItem(), validItemIds );
 
        for( wxTreeItemId id : validItemIds )
        {
            if( GetItemIdData( id ) == m_selectedItem )
            {
                // Activate launches a window which may run the event loop on top of us and cause
                // onIdle to get called again, so be sure to null out m_selectedItem first.
                PROJECT_TREE_ITEM* item = m_selectedItem;
                m_selectedItem          = nullptr;
 
                item->Activate( this );
                break;
            }
        }
    }
}
 
 
void PROJECT_TREE_PANE::onExpand( wxTreeEvent& Event )
{
    wxTreeItemId       itemId    = Event.GetItem();
    PROJECT_TREE_ITEM* tree_data = GetItemIdData( itemId );
 
    if( !tree_data )
        return;
 
    if( tree_data->GetType() != TREE_FILE_TYPE::DIRECTORY )
        return;
 
    // explore list of non populated subdirs, and populate them
    wxTreeItemIdValue   cookie;
    wxTreeItemId        kid = m_TreeProject->GetFirstChild( itemId, cookie );
 
#ifndef __WINDOWS__
    bool subdir_populated = false;
#endif
 
    for( ; kid.IsOk(); kid = m_TreeProject->GetNextChild( itemId, cookie ) )
    {
        PROJECT_TREE_ITEM* itemData = GetItemIdData( kid );
 
        if( !itemData || itemData->GetType() != TREE_FILE_TYPE::DIRECTORY )
            continue;
 
        if( itemData->IsPopulated() )
            continue;
 
        wxString    fileName = itemData->GetFileName();
        wxDir       dir( fileName );
 
        if( dir.IsOpened() )
        {
            std::vector<wxString> projects = getProjects( dir );
            wxString              dir_filename;
            bool                  haveFile = dir.GetFirst( &dir_filename );
 
            while( haveFile )
            {
                // Add name to tree item, but do not recurse in subdirs:
                wxString name = fileName + wxFileName::GetPathSeparator() + dir_filename;
                addItemToProjectTree( name, kid, &projects, false );
 
                haveFile = dir.GetNext( &dir_filename );
            }
 
            itemData->SetPopulated( true );       // set state to populated
 
#ifndef __WINDOWS__
            subdir_populated = true;
#endif
        }
 
        // Sort filenames by alphabetic order
        m_TreeProject->SortChildren( kid );
    }
 
#ifndef __WINDOWS__
    if( subdir_populated )
        m_watcherNeedReset = true;
#endif
}
 
 
std::vector<PROJECT_TREE_ITEM*> PROJECT_TREE_PANE::GetSelectedData()
{
    wxArrayTreeItemIds              selection;
    std::vector<PROJECT_TREE_ITEM*> data;
 
    m_TreeProject->GetSelections( selection );
 
    for( const wxTreeItemId itemId : selection )
    {
        PROJECT_TREE_ITEM* item = GetItemIdData( itemId );
 
        if( !item )
        {
            wxLogTrace( traceGit, wxS( "Null tree item returned for selection, dynamic_cast failed?" ) );
            continue;
        }
 
        data.push_back( item );
    }
 
    return data;
}
 
 
PROJECT_TREE_ITEM* PROJECT_TREE_PANE::GetItemIdData( wxTreeItemId aId )
{
    return dynamic_cast<PROJECT_TREE_ITEM*>( m_TreeProject->GetItemData( aId ) );
}
 
 
wxTreeItemId PROJECT_TREE_PANE::findSubdirTreeItem( const wxString& aSubDir )
{
    wxString prj_dir = wxPathOnly( m_Parent->GetProjectFileName() );
 
    // If the subdir is the current working directory, return m_root
    // in main list:
    if( prj_dir == aSubDir )
        return m_root;
 
    // The subdir is in the main tree or in a subdir: Locate it
    wxTreeItemIdValue        cookie;
    wxTreeItemId             root_id = m_root;
    std::stack<wxTreeItemId> subdirs_id;
 
    wxTreeItemId child = m_TreeProject->GetFirstChild( root_id, cookie );
 
    while( true )
    {
        if( ! child.IsOk() )
        {
            if( subdirs_id.empty() )    // all items were explored
            {
                root_id = child;          // Not found: return an invalid wxTreeItemId
                break;
            }
            else
            {
                root_id = subdirs_id.top();
                subdirs_id.pop();
                child = m_TreeProject->GetFirstChild( root_id, cookie );
 
                if( !child.IsOk() )
                    continue;
            }
        }
 
        PROJECT_TREE_ITEM* itemData = GetItemIdData( child );
 
        if( itemData && ( itemData->GetType() == TREE_FILE_TYPE::DIRECTORY ) )
        {
            if( itemData->GetFileName() == aSubDir )    // Found!
            {
                root_id = child;
                break;
            }
 
            // child is a subdir, push in list to explore it later
            if( itemData->IsPopulated() )
                subdirs_id.push( child );
        }
 
        child = m_TreeProject->GetNextChild( root_id, cookie );
    }
 
    return root_id;
}
 
 
void PROJECT_TREE_PANE::onFileSystemEvent( wxFileSystemWatcherEvent& event )
{
    // No need to process events when we're shutting down
    if( !m_watcher )
        return;
 
    // Ignore events that are not file creation, deletion, renaming or modification because
    // they are not relevant to the project tree.
    if( !( event.GetChangeType() & ( wxFSW_EVENT_CREATE |
                                     wxFSW_EVENT_DELETE |
                                     wxFSW_EVENT_RENAME |
                                     wxFSW_EVENT_MODIFY ) ) )
    {
        return;
    }
 
    const wxFileName& pathModified = event.GetPath();
 
    // Ignore events from .history directory (local backup)
    if( pathModified.GetFullPath().Contains( wxS( ".history" ) ) )
        return;
 
    wxString subdir = pathModified.GetPath();
    wxString fn = pathModified.GetFullPath();
 
    // Adjust directories to look like a file item (path and name).
    if( pathModified.GetFullName().IsEmpty() )
    {
        subdir = subdir.BeforeLast( '/' );
        fn = fn.BeforeLast( '/' );
    }
 
    wxTreeItemId root_id = findSubdirTreeItem( subdir );
 
    if( !root_id.IsOk() )
        return;
 
    CallAfter( [this] ()
    {
        wxLogTrace( traceGit, wxS( "File system event detected, updating tree cache" ) );
        m_gitStatusTimer.Start( 1500, wxTIMER_ONE_SHOT );
    } );
 
    wxTreeItemIdValue  cookie;  // dummy variable needed by GetFirstChild()
    wxTreeItemId kid = m_TreeProject->GetFirstChild( root_id, cookie );
 
    switch( event.GetChangeType() )
    {
    case wxFSW_EVENT_CREATE:
    {
        wxTreeItemId newitem = addItemToProjectTree( fn, root_id, nullptr, true );
 
        // If we are in the process of renaming a file, select the new one
        // This is needed for MSW and OSX, since we don't get RENAME events from them, just a
        // pair of DELETE and CREATE events.
        if( m_isRenaming && newitem.IsOk() )
        {
            m_TreeProject->SelectItem( newitem );
            m_isRenaming = false;
        }
    }
        break;
 
    case wxFSW_EVENT_DELETE:
        while( kid.IsOk() )
        {
            PROJECT_TREE_ITEM* itemData = GetItemIdData( kid );
 
            if( itemData && itemData->GetFileName() == fn )
            {
                m_TreeProject->Delete( kid );
                return;
            }
            kid = m_TreeProject->GetNextChild( root_id, cookie );
        }
        break;
 
    case wxFSW_EVENT_RENAME :
    {
        const wxFileName& newpath = event.GetNewPath();
        wxString newdir = newpath.GetPath();
        wxString newfn = newpath.GetFullPath();
 
        while( kid.IsOk() )
        {
            PROJECT_TREE_ITEM* itemData = GetItemIdData( kid );
 
            if( itemData && itemData->GetFileName() == fn )
            {
                m_TreeProject->Delete( kid );
                break;
            }
 
            kid = m_TreeProject->GetNextChild( root_id, cookie );
        }
 
        // Add the new item only if it is not the current project file (root item).
        // Remember: this code is called by a wxFileSystemWatcherEvent event, and not always
        // called after an actual file rename, and the cleanup code does not explore the
        // root item, because it cannot be renamed by the user. Also, ensure the new file
        // actually exists on the file system before it is readded. On Linux, moving a file
        // to the trash can cause the same path to be returned in both the old and new paths
        // of the event, even though the file isn't there anymore.
        PROJECT_TREE_ITEM* rootData = GetItemIdData( root_id );
 
        if( rootData && newpath.Exists() && ( newfn != rootData->GetFileName() ) )
        {
            wxTreeItemId newroot_id = findSubdirTreeItem( newdir );
            wxTreeItemId newitem = addItemToProjectTree( newfn, newroot_id, nullptr, true );
 
            // If the item exists, select it
            if( newitem.IsOk() )
                m_TreeProject->SelectItem( newitem );
        }
 
        m_isRenaming = false;
    }
        break;
 
    default:
        return;
    }
 
    // Sort filenames by alphabetic order
    m_TreeProject->SortChildren( root_id );
}
 
 
void PROJECT_TREE_PANE::FileWatcherReset()
{
    m_watcherNeedReset = false;
 
    wxString prj_dir = wxPathOnly( m_Parent->GetProjectFileName() );
 
#if defined( _WIN32 )
    if( KIPLATFORM::ENV::IsNetworkPath( prj_dir ) )
    {
        // Due to a combination of a bug in SAMBA sending bad change event IDs and wxWidgets
        // choosing to fault on an invalid event ID instead of sanely ignoring them we need to
        // avoid spawning a filewatcher. Unfortunately this punishes corporate environments with
        // Windows Server shares :/
        m_Parent->m_FileWatcherInfo = _( "Network path: not monitoring folder changes" );
        m_Parent->SetStatusText( m_Parent->m_FileWatcherInfo, 1 );
        return;
    }
    else
    {
        m_Parent->m_FileWatcherInfo = _( "Local path: monitoring folder changes" );
        m_Parent->SetStatusText( m_Parent->m_FileWatcherInfo, 1 );
    }
#endif
 
    // Prepare file watcher:
    if( m_watcher )
    {
        m_watcher->RemoveAll();
    }
    else
    {
        // Create a wxWidgets log handler to catch errors during watcher creation
        // We need to to this because we cannot get error codes from the wxFileSystemWatcher
        // constructor.  On Linux, if inotify cannot be initialized (usually due to resource limits),
        // wxWidgets will throw a system error and then, we throw another error below, trying to
        // add paths to a null watcher.  We skip this by installing a temporary log handler that
        // catches errors during watcher creation and aborts if any error is detected.
        class WatcherLogHandler : public wxLog
        {
        public:
            explicit WatcherLogHandler( bool* err ) :
                    m_err( err )
            {
                if( m_err )
                    *m_err = false;
            }
 
        protected:
            void DoLogTextAtLevel( wxLogLevel level, const wxString& text ) override
            {
                if( m_err && ( level == wxLOG_Error || level == wxLOG_FatalError ) )
                    *m_err = true;
            }
 
        private:
            bool* m_err;
        };
 
        bool watcherHasError = false;
        WatcherLogHandler tmpLog( &watcherHasError );
 
        {
            SCOPED_WXLOG_TARGET logOverride( &tmpLog );
 
            m_watcher = new wxFileSystemWatcher();
            m_watcher->SetOwner( this );
        }
 
        if( watcherHasError )
        {
            return;
        }
    }
 
    // We can see wxString under a debugger, not a wxFileName
    wxFileName fn;
    fn.AssignDir( prj_dir );
    fn.DontFollowLink();
 
    // Add directories which should be monitored.
    // under windows, we add the curr dir and all subdirs
    // under unix, we add only the curr dir and the populated subdirs
    // see  http://docs.wxwidgets.org/trunk/classwx_file_system_watcher.htm
    // under unix, the file watcher needs more work to be efficient
    // moreover, under wxWidgets 2.9.4, AddTree does not work properly.
    {
        wxLogNull logNo;    // avoid log messages
#ifdef __WINDOWS__
        if( ! m_watcher->AddTree( fn ) )
        {
            wxLogTrace( tracePathsAndFiles, "%s: failed to add '%s'\n", __func__,
                        TO_UTF8( fn.GetFullPath() ) );
            return;
        }
    }
#else
        if( !m_watcher->Add( fn ) )
        {
            wxLogTrace( tracePathsAndFiles, "%s: failed to add '%s'\n", __func__,
                        TO_UTF8( fn.GetFullPath() ) );
            return;
        }
    }
 
    if( m_TreeProject->IsEmpty() )
        return;
 
    // Add subdirs
    wxTreeItemIdValue  cookie;
    wxTreeItemId       root_id = m_root;
 
    std::stack < wxTreeItemId > subdirs_id;
 
    wxTreeItemId kid = m_TreeProject->GetFirstChild( root_id, cookie );
    int total_watch_count = 0;
 
    while( total_watch_count < ADVANCED_CFG::GetCfg().m_MaxFilesystemWatchers )
    {
        if( !kid.IsOk() )
        {
            if( subdirs_id.empty() )    // all items were explored
            {
                break;
            }
            else
            {
                root_id = subdirs_id.top();
                subdirs_id.pop();
                kid = m_TreeProject->GetFirstChild( root_id, cookie );
 
                if( !kid.IsOk() )
                    continue;
            }
        }
 
        PROJECT_TREE_ITEM* itemData = GetItemIdData( kid );
 
        if( itemData && itemData->GetType() == TREE_FILE_TYPE::DIRECTORY )
        {
            // we can see wxString under a debugger, not a wxFileName
            const wxString& path = itemData->GetFileName();
 
            // Skip .history directory and its descendants (local backup)
            if( path.Contains( wxS( ".history" ) ) )
            {
                kid = m_TreeProject->GetNextChild( root_id, cookie );
                continue;
            }
 
            wxLogTrace( tracePathsAndFiles, "%s: add '%s'\n", __func__, TO_UTF8( path ) );
 
            if( wxFileName::IsDirReadable( path ) )   // linux whines about watching protected dir
            {
                {
                    // Silence OS errors that come from the watcher
                    wxLogNull silence;
                    fn.AssignDir( path );
                    m_watcher->Add( fn );
                    total_watch_count++;
                }
 
                // if kid is a subdir, push in list to explore it later
                if( itemData->IsPopulated() && m_TreeProject->GetChildrenCount( kid ) )
                    subdirs_id.push( kid );
            }
        }
 
        kid = m_TreeProject->GetNextChild( root_id, cookie );
    }
 
    if( total_watch_count >= ADVANCED_CFG::GetCfg().m_MaxFilesystemWatchers )
        wxLogTrace( tracePathsAndFiles, "%s: too many directories to watch\n", __func__ );
#endif
 
#if defined(DEBUG) && 1
    wxArrayString paths;
    m_watcher->GetWatchedPaths( &paths );
    wxLogTrace( tracePathsAndFiles, "%s: watched paths:", __func__ );
 
    for( unsigned ii = 0; ii < paths.GetCount(); ii++ )
        wxLogTrace( tracePathsAndFiles, " %s\n", TO_UTF8( paths[ii] ) );
#endif
    }
 
 
void PROJECT_TREE_PANE::EmptyTreePrj()
{
    // Make sure we don't try to inspect the tree after we've deleted its items.
    shutdownFileWatcher();
 
    m_TreeProject->DeleteAllItems();
 
    if( m_TreeProject->GetGitRepo() )
    {
        KIGIT_COMMON* common = m_TreeProject->GitCommon();
        common->SetCancelled( true );
 
        std::unique_lock<std::mutex> lock( common->m_gitActionMutex, std::try_to_lock );
 
        constexpr auto kGraceMs = std::chrono::seconds( 2 );
        auto           graceEnd = std::chrono::steady_clock::now() + kGraceMs;
 
        while( !lock.owns_lock() && std::chrono::steady_clock::now() < graceEnd )
        {
            if( lock.try_lock() )
                break;
            std::this_thread::sleep_for( std::chrono::milliseconds( 50 ) );
        }
 
        constexpr auto kCheckInterval = std::chrono::seconds( 30 );
        bool           userAbandoned  = false;
 
        while( !lock.owns_lock() && !userAbandoned )
        {
            auto intervalEnd = std::chrono::steady_clock::now() + kCheckInterval;
 
            {
                wxProgressDialog progress( _( "Please wait" ),
                                           _( "Closing project..." ),
                                           100, this,
                                           wxPD_APP_MODAL | wxPD_SMOOTH );
 
                while( !lock.try_lock()
                       && std::chrono::steady_clock::now() < intervalEnd )
                {
                    progress.Pulse();
                    std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
                    wxYield();
                }
            }
 
            if( lock.owns_lock() )
                break;
 
            wxMessageDialog ask( this,
                                 _( "A Git operation is still running.\n"
                                    "Keep waiting, or abandon?" ),
                                 _( "Git Operation Delayed" ),
                                 wxYES_NO | wxICON_QUESTION );
            ask.SetYesNoLabels( _( "Keep Waiting" ), _( "Abandon" ) );
 
            if( ask.ShowModal() == wxID_NO )
                userAbandoned = true;
        }
 
        if( userAbandoned )
        {
            git_repository*               orphan    = m_TreeProject->GetGitRepo();
            std::shared_ptr<KIGIT_COMMON> oldCommon = m_TreeProject->TakeGitCommon();
            m_TreeProject->SetGitRepo( nullptr );
 
            // Register the cleanup thread with the orphan registry so the
            // shutdown path can wait for it before tearing down libgit2.
            // Cancellation has already been requested via SetCancelled() above,
            // and progress_cb/transfer_progress_cb honour it so long-running
            // fetches will exit with GIT_EUSER as soon as they hit a callback.
 
            GIT_BACKEND* backend = GetGitBackend();
            wxString     projectDir = oldCommon ? oldCommon->GetProjectDir() : wxString();
 
            auto cleanup = [orphan, old = std::move( oldCommon )]() mutable
                           {
                               std::lock_guard<std::mutex> g( old->m_gitActionMutex );
                               git_repository_free( orphan );
                           };
 
            bool registered = false;
 
            if( backend )
            {
                std::string label = "abandon close " + projectDir.ToStdString();
                registered = backend->OrphanRegistry().Register( label, std::move( cleanup ) );
            }
 
            if( !registered )
            {
                // Either no backend is available, or the registry has already
                // entered shutdown.  Fall back to freeing synchronously so the
                // repository handle is not leaked; this blocks on the git
                // action mutex but is safe because libgit2 shutdown is gated
                // on the same registry.
 
                cleanup();
            }
        }
        else
        {
            git_repository* repo = m_TreeProject->GetGitRepo();
            KIGIT::PROJECT_GIT_UTILS::RemoveVCS( repo );
            m_TreeProject->SetGitRepo( nullptr );
        }
    }
}
 
 
void PROJECT_TREE_PANE::releaseGitRepo()
{
    git_repository* repo = m_TreeProject ? m_TreeProject->GetGitRepo() : nullptr;
 
    if( !repo )
        return;
 
    KIGIT_COMMON* common = m_TreeProject->GitCommon();
    common->SetCancelled( true );
 
    std::unique_lock<std::mutex> gitLock( common->m_gitActionMutex, std::try_to_lock );
 
    if( gitLock.owns_lock() )
    {
        m_TreeProject->SetGitRepo( nullptr );
        git_repository_free( repo );
        return;
    }
 
    // A background fetch or status update still holds the git action mutex, so freeing the
    // repository here would pull it out from under a running libgit2 call.  Hand the handle
    // and its KIGIT_COMMON to the orphan registry, which frees it once the mutex is released.
    // Any worker pinning the common keeps it alive until it drops its own shared handle.
    std::shared_ptr<KIGIT_COMMON> oldCommon = m_TreeProject->TakeGitCommon();
 
    GIT_BACKEND* backend = GetGitBackend();
    wxString     projectDir = oldCommon ? oldCommon->GetProjectDir() : wxString();
 
    auto cleanup = [repo, old = std::move( oldCommon )]() mutable
                   {
                       std::lock_guard<std::mutex> g( old->m_gitActionMutex );
                       git_repository_free( repo );
                   };
 
    bool registered = false;
 
    if( backend )
    {
        std::string label = "release repo " + projectDir.ToStdString();
        registered = backend->OrphanRegistry().Register( label, std::move( cleanup ) );
    }
 
    if( !registered )
    {
        // The registry is unavailable or shutting down, so block on the mutex here rather
        // than leak the handle.
        cleanup();
    }
}
 
 
void PROJECT_TREE_PANE::onThemeChanged( wxSysColourChangedEvent &aEvent )
{
    GetBitmapStore()->ThemeChanged();
    m_TreeProject->LoadIcons();
    m_TreeProject->Refresh();
 
    aEvent.Skip();
}
 
 
void PROJECT_TREE_PANE::onPaint( wxPaintEvent& event )
{
    wxRect    rect( wxPoint( 0, 0 ), GetClientSize() );
    wxPaintDC dc( this );
 
    dc.SetBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_FRAMEBK ) );
    dc.SetPen( wxPen( wxSystemSettings::GetColour( wxSYS_COLOUR_ACTIVEBORDER ), 1 ) );
 
    dc.DrawLine( rect.GetLeft(), rect.GetTop(), rect.GetLeft(), rect.GetBottom() );
    dc.DrawLine( rect.GetRight(), rect.GetTop(), rect.GetRight(), rect.GetBottom() );
}
 
 
void KICAD_MANAGER_FRAME::OnChangeWatchedPaths( wxCommandEvent& aEvent )
{
    m_projectTreePane->FileWatcherReset();
}
 
 
// Prompts for git credentials after an auth failure. Returns false if cancelled.
static bool promptForGitCredentials( wxWindow* aParent, KIGIT_COMMON* aCommon )
{
    DIALOG_GIT_CREDENTIALS dlg( aParent, aCommon->GetRemote(), aCommon->GetConnType(), aCommon->GetUsername(),
                                wxEmptyString );
 
    if( dlg.ShowModal() != wxID_OK )
        return false;
 
    aCommon->SetUsername( dlg.GetUsername() );
    aCommon->SetPassword( dlg.GetPassword() );
 
    if( dlg.GetConnType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH && !dlg.GetSSHKey().IsEmpty() )
    {
        aCommon->SetSSHKey( dlg.GetSSHKey() );
    }
 
    if( dlg.SaveCredentials() )
    {
        KIPLATFORM::SECRETS::StoreSecret( aCommon->GetRemote(), aCommon->GetUsername(), dlg.GetPassword() );
    }
 
    aCommon->ClearAuthFailure();
    aCommon->TestedTypes() = 0;
    aCommon->ResetNextKey();
    return true;
}
 
 
void PROJECT_TREE_PANE::onGitInitializeProject( wxCommandEvent& aEvent )
{
    PROJECT_TREE_ITEM* tree_data = GetItemIdData( m_TreeProject->GetRootItem() );
 
    wxString dir = tree_data->GetDir();
 
    if( dir.empty() )
    {
        wxLogError( "Failed to initialize git project: project directory is empty." );
        return;
    }
 
    GIT_INIT_HANDLER initHandler( m_TreeProject->GitCommon() );
    wxWindow*        topLevelParent = wxGetTopLevelParent( this );
 
    if( initHandler.IsRepository( dir ) )
    {
        DisplayInfoMessage( topLevelParent,
                            _( "The selected directory is already a Git project." ) );
        return;
    }
 
    InitResult result = initHandler.InitializeRepository( dir );
    if( result != InitResult::Success )
    {
        DisplayErrorMessage( m_parent, _( "Failed to initialize Git project." ),
                             initHandler.GetErrorString() );
        return;
    }
 
    m_gitLastError = GIT_ERROR_NONE;
 
    m_TreeProject->GitCommon()->SetCancelled( false );
 
    const char* canonicalWorkDir = git_repository_workdir( initHandler.GetRepo() );
 
    if( canonicalWorkDir )
    {
        wxString symlinkWorkDir = KIGIT::PROJECT_GIT_UTILS::ComputeSymlinkPreservingWorkDir(
                dir, wxString::FromUTF8( canonicalWorkDir ) );
        m_TreeProject->GitCommon()->SetProjectDir( symlinkWorkDir );
    }
 
    DIALOG_GIT_REPOSITORY dlg( topLevelParent, initHandler.GetRepo() );
    dlg.SetTitle( _( "Set default remote" ) );
    dlg.SetSkipButtonLabel( _( "Skip" ) );
 
    if( dlg.ShowModal() != wxID_OK )
        return;
 
    // Set up the remote
    RemoteConfig remoteConfig;
    remoteConfig.url = dlg.GetRepoURL();
    remoteConfig.username = dlg.GetUsername();
    remoteConfig.password = dlg.GetPassword();
    remoteConfig.sshKey = dlg.GetRepoSSHPath();
    remoteConfig.connType = dlg.GetRepoType();
 
    if( !initHandler.SetupRemote( remoteConfig ) )
    {
        DisplayErrorMessage( m_parent, _( "Failed to set default remote." ),
                             initHandler.GetErrorString() );
        return;
    }
 
    m_gitLastError = GIT_ERROR_NONE;
 
    KIGIT_COMMON* common = m_TreeProject->GitCommon();
 
    while( true )
    {
        common->ClearAuthFailure();
 
        GIT_PULL_HANDLER handler( common );
        handler.SetProgressReporter(
                std::make_unique<WX_PROGRESS_REPORTER>( this, _( "Fetch Remote" ), 1, PR_NO_ABORT ) );
 
        if( handler.PerformFetch() )
            break;
 
        if( common->WasAuthFailure() && promptForGitCredentials( m_parent, common ) )
            continue;
 
        break;
    }
 
    KIPLATFORM::SECRETS::StoreSecret( dlg.GetRepoURL(), dlg.GetUsername(), dlg.GetPassword() );
    Prj().GetLocalSettings().m_GitRepoUsername = dlg.GetUsername();
    Prj().GetLocalSettings().m_GitSSHKey = dlg.GetRepoSSHPath();
 
    if( dlg.GetRepoType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH )
        Prj().GetLocalSettings().m_GitRepoType = "ssh";
    else if( dlg.GetRepoType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_HTTPS )
        Prj().GetLocalSettings().m_GitRepoType = "https";
    else
        Prj().GetLocalSettings().m_GitRepoType = "local";
}
 
 
void PROJECT_TREE_PANE::onGitRemoteSettings( wxCommandEvent& aEvent )
{
    KIGIT_COMMON*   common = m_TreeProject->GitCommon();
    git_repository* repo = common ? common->GetRepo() : nullptr;
 
    if( !repo )
        return;
 
    wxString    existingURL;
    git_remote* remote = nullptr;
 
    if( git_remote_lookup( &remote, repo, "origin" ) == GIT_OK )
    {
        KIGIT::GitRemotePtr remotePtr( remote );
 
        if( const char* url = git_remote_url( remote ) )
            existingURL = wxString::FromUTF8( url );
    }
 
    wxWindow*             topLevelParent = wxGetTopLevelParent( this );
    DIALOG_GIT_REPOSITORY dlg( topLevelParent, repo, existingURL );
    dlg.SetTitle( _( "Configure Default Remote" ) );
 
    if( dlg.ShowModal() != wxID_OK )
        return;
 
    GIT_INIT_HANDLER initHandler( common );
 
    RemoteConfig remoteConfig;
    remoteConfig.url = dlg.GetRepoURL();
    remoteConfig.username = dlg.GetUsername();
    remoteConfig.password = dlg.GetPassword();
    remoteConfig.sshKey = dlg.GetRepoSSHPath();
    remoteConfig.connType = dlg.GetRepoType();
 
    if( !initHandler.SetupRemote( remoteConfig ) )
    {
        DisplayErrorMessage( topLevelParent, _( "Failed to configure remote." ), initHandler.GetErrorString() );
        return;
    }
 
    KIPLATFORM::SECRETS::StoreSecret( dlg.GetRepoURL(), dlg.GetUsername(), dlg.GetPassword() );
    Prj().GetLocalSettings().m_GitRepoUsername = dlg.GetUsername();
    Prj().GetLocalSettings().m_GitSSHKey = dlg.GetRepoSSHPath();
 
    if( dlg.GetRepoType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH )
        Prj().GetLocalSettings().m_GitRepoType = "ssh";
    else if( dlg.GetRepoType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_HTTPS )
        Prj().GetLocalSettings().m_GitRepoType = "https";
    else
        Prj().GetLocalSettings().m_GitRepoType = "local";
 
    common->UpdateCurrentBranchInfo();
    m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
}
 
 
void PROJECT_TREE_PANE::onGitCompare( wxCommandEvent& aEvent )
{
 
}
 
 
void PROJECT_TREE_PANE::onGitPullProject( wxCommandEvent& aEvent )
{
    git_repository* repo = m_TreeProject->GetGitRepo();
 
    if( !repo )
        return;
 
    KIGIT_COMMON* common = m_TreeProject->GitCommon();
 
    while( true )
    {
        common->ClearAuthFailure();
 
        GIT_PULL_HANDLER handler( common );
        handler.SetProgressReporter(
                std::make_unique<WX_PROGRESS_REPORTER>( this, _( "Fetch Remote" ), 1, PR_NO_ABORT ) );
 
        PullResult pullResult = handler.PerformPull();
 
        if( pullResult >= PullResult::Success )
        {
            wxString upstream = common->GetUpstreamShorthand();
            wxString branch = common->GetCurrentBranchName();
 
            switch( pullResult )
            {
            case PullResult::UpToDate:
                showGitFeedback( upstream.empty() ? _( "Already up to date." )
                                                  : wxString::Format( _( "Already up to date with %s." ), upstream ) );
                break;
 
            case PullResult::FastForward:
                showGitFeedback(
                        upstream.empty() || branch.empty()
                                ? _( "Pulled changes (fast-forward)." )
                                : wxString::Format( _( "Pulled %s into %s (fast-forward)." ), upstream, branch ) );
                break;
 
            default:
                showGitFeedback( upstream.empty() || branch.empty()
                                         ? _( "Pulled changes." )
                                         : wxString::Format( _( "Pulled %s into %s." ), upstream, branch ) );
                break;
            }
 
            break;
        }
 
        if( pullResult == PullResult::Conflict )
        {
            wxRichMessageDialog dlg( wxGetTopLevelParent( this ),
                                     _( "Your local changes and the remote changes conflict, so the pull was "
                                        "cancelled and nothing was changed.\n\n"
                                        "You can discard your local commits and use the remote version, or "
                                        "rebase your commits on top of the remote." ),
                                     _( "Pull Conflict" ),
                                     wxYES_NO | wxCANCEL | wxCANCEL_DEFAULT | wxICON_WARNING | wxCENTER );
 
            dlg.SetYesNoCancelLabels( _( "&Use Remote (discard my changes)" ), _( "&Rebase" ), _( "Cancel" ) );
 
            int choice = dlg.ShowModal();
 
            if( choice == wxID_YES )
            {
                if( handler.ResetToUpstream() )
                    showGitFeedback( _( "Reset to the remote version." ) );
                else
                    DisplayErrorMessage( m_parent, _( "Failed to reset to remote" ), handler.GetErrorString() );
            }
            else if( choice == wxID_NO )
            {
                PullResult rebaseResult = handler.RebaseOntoUpstream();
 
                if( rebaseResult == PullResult::Success )
                    showGitFeedback( _( "Rebased your changes onto the remote." ) );
                else
                    DisplayErrorMessage( m_parent, _( "Could not rebase" ), handler.GetErrorString() );
            }
            else
            {
                showGitFeedback( _( "Pull cancelled." ) );
            }
 
            break;
        }
 
        if( common->WasAuthFailure() && promptForGitCredentials( m_parent, common ) )
            continue;
 
        showGitFeedback( _( "Pull failed." ) );
        DisplayErrorMessage( m_parent, _( "Failed to pull project" ), handler.GetErrorString() );
        break;
    }
 
    m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
}
 
 
void PROJECT_TREE_PANE::onGitPushProject( wxCommandEvent& aEvent )
{
    git_repository* repo = m_TreeProject->GetGitRepo();
 
    if( !repo )
        return;
 
    KIGIT_COMMON* common = m_TreeProject->GitCommon();
    bool          force = false;
 
    while( true )
    {
        common->ClearAuthFailure();
 
        GIT_PUSH_HANDLER handler( common );
        handler.SetProgressReporter(
                std::make_unique<WX_PROGRESS_REPORTER>( this, _( "Fetch Remote" ), 1, PR_NO_ABORT ) );
 
        PushResult pushResult = handler.PerformPush( force );
 
        if( pushResult == PushResult::Success )
        {
            wxString upstream = common->GetUpstreamShorthand();
            wxString branch = common->GetCurrentBranchName();
 
            showGitFeedback( upstream.empty() || branch.empty()
                                     ? _( "Pushed to remote." )
                                     : wxString::Format( _( "Pushed %s to %s." ), branch, upstream ) );
            break;
        }
 
        if( common->WasAuthFailure() && promptForGitCredentials( m_parent, common ) )
            continue;
 
        if( pushResult == PushResult::NonFastForward && !force )
        {
            wxString upstream = common->GetUpstreamShorthand();
 
            wxRichMessageDialog dlg(
                    wxGetTopLevelParent( this ),
                    wxString::Format( _( "Push rejected: your local branch and %s have diverged.\n\n"
                                         "This usually happens after amending or rewriting a commit "
                                         "that was already pushed.  Force push to overwrite the remote?\n\n"
                                         "Anyone who already pulled the previous version will need to "
                                         "reset their copy." ),
                                      upstream.empty() ? wxString( "the remote" ) : upstream ),
                    _( "Force Push?" ), wxYES_NO | wxNO_DEFAULT | wxICON_WARNING | wxCENTER );
 
            dlg.SetYesNoLabels( _( "&Force Push" ), _( "Cancel" ) );
 
            if( dlg.ShowModal() == wxID_YES )
            {
                force = true;
                continue;
            }
        }
 
        showGitFeedback( _( "Push failed." ) );
        DisplayErrorMessage( m_parent, _( "Failed to push project" ), handler.GetErrorString() );
        break;
    }
 
    m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
}
 
 
void PROJECT_TREE_PANE::onGitSwitchBranch( wxCommandEvent& aEvent )
{
    if( !m_TreeProject->GetGitRepo() )
        return;
 
    GIT_BRANCH_HANDLER branchHandler( m_TreeProject->GitCommon() );
    wxString branchName;
 
    if( aEvent.GetId() == ID_GIT_SWITCH_BRANCH )
    {
        DIALOG_GIT_SWITCH dlg( wxGetTopLevelParent( this ), m_TreeProject->GetGitRepo() );
 
        int retval = dlg.ShowModal();
        branchName = dlg.GetBranchName();
 
        if( retval == wxID_ADD )
            KIGIT::PROJECT_GIT_UTILS::CreateBranch( m_TreeProject->GetGitRepo(), branchName );
        else if( retval != wxID_OK )
            return;
    }
    else
    {
        std::vector<wxString> branches = m_TreeProject->GitCommon()->GetBranchNames();
        int branchIndex = aEvent.GetId() - ID_GIT_SWITCH_BRANCH;
 
        if( branchIndex < 0 || static_cast<size_t>( branchIndex ) >= branches.size() )
            return;
 
        branchName = branches[branchIndex];
    }
 
    wxLogTrace( traceGit, wxS( "onGitSwitchBranch: Switching to branch '%s'" ), branchName );
    if( branchHandler.SwitchToBranch( branchName ) != BranchResult::Success )
    {
        DisplayError( m_parent, branchHandler.GetErrorString() );
        return;
    }
 
    m_TreeProject->GitCommon()->UpdateCurrentBranchInfo();
    m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
}
 
 
void PROJECT_TREE_PANE::onGitRemoveVCS( wxCommandEvent& aEvent )
{
    PROJECT_LOCAL_SETTINGS& localSettings = Prj().GetLocalSettings();
 
    // Toggle the Git integration disabled preference
    localSettings.m_GitIntegrationDisabled = !localSettings.m_GitIntegrationDisabled;
 
    wxLogTrace( traceGit, wxS( "onGitRemoveVCS: Git integration %s" ),
                localSettings.m_GitIntegrationDisabled ? wxS( "disabled" ) : wxS( "enabled" ) );
 
    if( localSettings.m_GitIntegrationDisabled )
    {
        // Disabling Git integration - release the repo and clear item states
        releaseGitRepo();
        m_gitIconsInitialized = false;
 
        // Clear all item states to remove git status icons
        std::stack<wxTreeItemId> items;
        items.push( m_TreeProject->GetRootItem() );
 
        while( !items.empty() )
        {
            wxTreeItemId current = items.top();
            items.pop();
 
            m_TreeProject->SetItemState( current, wxTREE_ITEMSTATE_NONE );
 
            wxTreeItemIdValue cookie;
            wxTreeItemId      child = m_TreeProject->GetFirstChild( current, cookie );
 
            while( child.IsOk() )
            {
                items.push( child );
                child = m_TreeProject->GetNextChild( current, cookie );
            }
        }
    }
    else
    {
        // Re-enabling Git integration - try to find and connect to the repository
        wxFileName fn( Prj().GetProjectPath() );
        m_TreeProject->SetGitRepo( KIGIT::PROJECT_GIT_UTILS::GetRepositoryForFile( fn.GetPath().c_str() ) );
 
        if( m_TreeProject->GetGitRepo() )
        {
            m_TreeProject->GitCommon()->SetCancelled( false );
 
            const char* canonicalWorkDir = git_repository_workdir( m_TreeProject->GetGitRepo() );
 
            if( canonicalWorkDir )
            {
                wxString symlinkWorkDir = KIGIT::PROJECT_GIT_UTILS::ComputeSymlinkPreservingWorkDir(
                        fn.GetPath(), wxString::FromUTF8( canonicalWorkDir ) );
                m_TreeProject->GitCommon()->SetProjectDir( symlinkWorkDir );
            }
 
            m_TreeProject->GitCommon()->SetUsername( localSettings.m_GitRepoUsername );
            m_TreeProject->GitCommon()->SetSSHKey( localSettings.m_GitSSHKey );
        }
    }
 
    // Save the preference to the project local settings file
    localSettings.SaveToFile( Prj().GetProjectPath() );
}
 
 
void PROJECT_TREE_PANE::updateGitStatusIcons()
{
    wxLogTrace( traceGit, wxS( "updateGitStatusIcons: Updating git status icons" ) );
    std::unique_lock<std::mutex> lock( m_gitStatusMutex, std::try_to_lock );
 
    if( !lock.owns_lock() )
    {
        wxLogTrace( traceGit, wxS( "updateGitStatusIcons: Failed to acquire lock for git status icon update" ) );
        m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
        return;
    }
 
    if( !Pgm().GetCommonSettings()->m_Git.enableGit || !m_TreeProject )
    {
        wxLogTrace( traceGit, wxS( "updateGitStatusIcons: Git is disabled or tree control is null" ) );
        return;
    }
 
    std::stack<wxTreeItemId> items;
    items.push(m_TreeProject->GetRootItem());
 
    while( !items.empty() )
    {
        wxTreeItemId current = items.top();
        items.pop();
 
        if( current.IsOk() && m_TreeProject->ItemHasChildren( current ) )
        {
            wxTreeItemIdValue cookie;
            wxTreeItemId      child = m_TreeProject->GetFirstChild( current, cookie );
 
            while( child.IsOk() )
            {
                items.push( child );
 
                if( auto it = m_gitStatusIcons.find( child ); it != m_gitStatusIcons.end() )
                    m_TreeProject->SetItemState( child, static_cast<int>( it->second ) );
 
                child = m_TreeProject->GetNextChild( current, cookie );
            }
        }
    }
 
    if( !m_gitCurrentBranchName.empty() )
    {
        wxTreeItemId       kid = m_TreeProject->GetRootItem();
        PROJECT_TREE_ITEM* rootItem = kid.IsOk() ? GetItemIdData( kid ) : nullptr;
 
        if( rootItem )
        {
            wxString filename = wxFileNameFromPath( rootItem->GetFileName() );
            m_TreeProject->SetItemText( kid, filename + " [" + m_gitCurrentBranchName + "]" );
            m_gitIconsInitialized = true;
        }
    }
 
    wxLogTrace( traceGit, wxS( "updateGitStatusIcons: Git status icons updated" ) );
}
 
 
void PROJECT_TREE_PANE::updateTreeCache()
{
    wxLogTrace( traceGit, wxS( "updateTreeCache: Updating tree cache" ) );
 
    std::unique_lock<std::mutex> lock( m_gitTreeCacheMutex, std::try_to_lock );
 
    if( !lock.owns_lock() )
    {
        wxLogTrace( traceGit, wxS( "updateTreeCache: Failed to acquire lock for tree cache update" ) );
        return;
    }
 
    if( !m_TreeProject )
    {
        wxLogTrace( traceGit, wxS( "updateTreeCache: Tree control is null" ) );
        return;
    }
 
    wxTreeItemId kid = m_TreeProject->GetRootItem();
 
    if( !kid.IsOk() )
        return;
 
    // Collect a map to easily set the state of each item
    m_gitTreeCache.clear();
    std::stack<wxTreeItemId> items;
    items.push( kid );
 
    while( !items.empty() )
    {
        kid = items.top();
        items.pop();
 
        PROJECT_TREE_ITEM* nextItem = GetItemIdData( kid );
 
        if( !nextItem )
            continue;
 
        wxString gitAbsPath = nextItem->GetFileName();
#ifdef _WIN32
        gitAbsPath.Replace( wxS( "\\" ), wxS( "/" ) );
#endif
        m_gitTreeCache[gitAbsPath] = kid;
 
        wxTreeItemIdValue cookie;
        wxTreeItemId      child = m_TreeProject->GetFirstChild( kid, cookie );
 
        while( child.IsOk() )
        {
            items.push( child );
            child = m_TreeProject->GetNextChild( kid, cookie );
        }
    }
}
 
 
void PROJECT_TREE_PANE::updateGitStatusIconMap()
{
    wxLogTrace( traceGit, wxS( "updateGitStatusIconMap: Updating git status icons" ) );
#if defined( _WIN32 )
    int refresh = ADVANCED_CFG::GetCfg().m_GitIconRefreshInterval;
 
    if( refresh != 0
        && KIPLATFORM::ENV::IsNetworkPath( wxPathOnly( m_Parent->GetProjectFileName() ) ) )
    {
        // Need to treat windows network paths special here until we get the samba bug fixed
        // https://github.com/wxWidgets/wxWidgets/issues/18953
        CallAfter(
                [this, refresh]()
                {
                    m_gitStatusTimer.Start( refresh, wxTIMER_ONE_SHOT );
                } );
    }
 
#endif
 
    if( !Pgm().GetCommonSettings()->m_Git.enableGit || !m_TreeProject )
        return;
 
    std::unique_lock<std::mutex> lock1( m_gitStatusMutex, std::try_to_lock );
    std::unique_lock<std::mutex> lock2( m_gitTreeCacheMutex, std::try_to_lock );
 
    if( !lock1.owns_lock() || !lock2.owns_lock() )
    {
        wxLogTrace( traceGit, wxS( "updateGitStatusIconMap: Failed to acquire locks for git status icon update" ) );
        return;
    }
 
    // Pin a shared handle so a concurrent releaseGitRepo()/TakeGitCommon() on the UI thread
    // cannot free the common while we dereference the repo or hold its action mutex.  The
    // embedded action mutex can only guard the repo, not the object that owns the mutex, so
    // ownership has to be pinned before anything else is touched.
    std::shared_ptr<KIGIT_COMMON> gitCommon = m_TreeProject->GitCommonPtr();
 
    if( !gitCommon || !gitCommon->GetRepo() )
    {
        wxLogTrace( traceGit, wxS( "updateGitStatusIconMap: No git repository found" ) );
        return;
    }
 
    // Acquire the git action mutex to synchronize with EmptyTreePrj() shutdown.
    // This ensures the repository isn't freed while we're using it.
    std::unique_lock<std::mutex> gitLock( gitCommon->m_gitActionMutex, std::try_to_lock );
 
    if( !gitLock.owns_lock() )
    {
        wxLogTrace( traceGit, wxS( "updateGitStatusIconMap: Failed to acquire git action mutex" ) );
        return;
    }
 
    // Check if cancellation was requested (e.g., during shutdown)
    if( gitCommon->IsCancelled() )
    {
        wxLogTrace( traceGit, wxS( "updateGitStatusIconMap: Cancelled" ) );
        return;
    }
 
    GIT_STATUS_HANDLER statusHandler( gitCommon.get() );
 
    // Set up pathspec for project files
    wxFileName         rootFilename( Prj().GetProjectFullName() );
    wxString           repoWorkDir = statusHandler.GetWorkingDirectory();
 
    wxFileName relative = rootFilename;
    relative.MakeRelativeTo( repoWorkDir );
    wxString pathspecStr = relative.GetPath( wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR );
 
#ifdef _WIN32
    pathspecStr.Replace( wxS( "\\" ), wxS( "/" ) );
#endif
 
    // Get file status
    auto fileStatusMap = statusHandler.GetFileStatus( pathspecStr );
    auto [localChanges, remoteChanges] = gitCommon->GetDifferentFiles();
    statusHandler.UpdateRemoteStatus( localChanges, remoteChanges, fileStatusMap );
 
    bool updated = false;
 
    // Update status icons based on file status
    for( const auto& [absPath, fileStatus] : fileStatusMap )
    {
        auto iter = m_gitTreeCache.find( absPath );
        if( iter == m_gitTreeCache.end() )
        {
            wxLogTrace( traceGit, wxS( "File '%s' not found in tree cache" ), absPath );
            continue;
        }
 
        auto [it, inserted] = m_gitStatusIcons.try_emplace( iter->second, fileStatus.status );
        if( inserted || it->second != fileStatus.status )
            updated = true;
        it->second = fileStatus.status;
    }
 
    // Get the current branch name
    wxString branchName = statusHandler.GetCurrentBranchName();
 
    if( branchName != m_gitCurrentBranchName )
        updated = true;
 
    m_gitCurrentBranchName = branchName;
    m_gitCurrentUpstream = gitCommon->GetUpstreamShorthand();
 
    wxLogTrace( traceGit, wxS( "updateGitStatusIconMap: Updated git status icons" ) );
 
    // Update UI if icons changed
    if( updated || !m_gitIconsInitialized )
    {
        CallAfter(
                [this]()
                {
                    updateGitStatusIcons();
                } );
    }
}
 
 
void PROJECT_TREE_PANE::onGitCommit( wxCommandEvent& aEvent )
{
    std::vector<PROJECT_TREE_ITEM*> tree_data = GetSelectedData();
 
    git_repository* repo = m_TreeProject->GetGitRepo();
 
    if( repo == nullptr )
    {
        wxMessageBox( _( "The selected directory is not a Git project." ) );
        return;
    }
 
    // Flush in-memory editor and project state so the index snapshots the user's
    // actual work instead of a stale on-disk version.
    {
        struct DirtyEditor
        {
            FRAME_T  frameType;
            MAIL_T   saveMail;
            wxString label;
        };
 
        const DirtyEditor candidates[] = {
            { FRAME_SCH, MAIL_SCH_SAVE, _( "Schematic Editor" ) },
            { FRAME_PCB_EDITOR, MAIL_PCB_SAVE, _( "PCB Editor" ) },
        };
 
        std::vector<const DirtyEditor*> dirty;
 
        for( const DirtyEditor& d : candidates )
        {
            KIWAY_PLAYER* frame = m_Parent->Kiway().Player( d.frameType, false );
 
            if( frame && frame->IsContentModified() )
                dirty.push_back( &d );
        }
 
        if( !dirty.empty() )
        {
            wxString listed;
 
            for( const DirtyEditor* d : dirty )
                listed += wxString::Format( wxS( "\n    • %s" ), d->label );
 
            wxRichMessageDialog dlg( wxGetTopLevelParent( this ),
                                     wxString::Format( _( "The following editors have unsaved changes:%s\n\n"
                                                          "Save them before committing?" ),
                                                       listed ),
                                     _( "Unsaved Changes" ),
                                     wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxICON_WARNING | wxCENTER );
 
            dlg.SetYesNoCancelLabels( _( "&Save and Commit" ), _( "Commit &Anyway" ), _( "Cancel" ) );
 
            int answer = dlg.ShowModal();
 
            if( answer == wxID_CANCEL )
                return;
 
            if( answer == wxID_YES )
            {
                for( const DirtyEditor* d : dirty )
                {
                    std::string payload;
                    m_Parent->Kiway().ExpressMail( d->frameType, d->saveMail, payload );
 
                    if( payload != "success" )
                    {
                        DisplayErrorMessage( wxGetTopLevelParent( this ),
                                             wxString::Format( _( "Could not save %s." ), d->label ) );
                        return;
                    }
                }
            }
        }
 
        m_Parent->GetSettingsManager()->SaveProject();
    }
 
    // Get git configuration
    GIT_CONFIG_HANDLER configHandler( m_TreeProject->GitCommon() );
    GitUserConfig userConfig = configHandler.GetUserConfig();
 
    // Collect modified files in the repository
    GIT_STATUS_HANDLER             statusHandler( m_TreeProject->GitCommon() );
    std::map<wxString, FileStatus> fileStatusMap = statusHandler.GetFileStatus();
 
    std::map<wxString, int> modifiedFiles;
    std::set<wxString> selected_files;
 
    for( PROJECT_TREE_ITEM* item : tree_data )
    {
        if( item->GetType() == TREE_FILE_TYPE::DIRECTORY )
            continue;
 
        wxString itemPath = item->GetFileName();
#ifdef _WIN32
        itemPath.Replace( wxS( "\\" ), wxS( "/" ) );
#endif
        selected_files.emplace( itemPath );
    }
 
    wxString repoWorkDir = statusHandler.GetWorkingDirectory();
 
    wxString projectPath = Prj().GetProjectPath();
#ifdef _WIN32
    projectPath.Replace( wxS( "\\" ), wxS( "/" ) );
#endif
 
    for( const auto& [absPath, fileStatus] : fileStatusMap )
    {
        // Skip current, conflicted, or ignored files
        if( fileStatus.status == KIGIT_COMMON::GIT_STATUS::GIT_STATUS_CURRENT
            || fileStatus.status == KIGIT_COMMON::GIT_STATUS::GIT_STATUS_CONFLICTED
            || fileStatus.status == KIGIT_COMMON::GIT_STATUS::GIT_STATUS_IGNORED )
        {
            continue;
        }
 
        wxFileName fn( absPath );
 
        // Convert to relative path for the modifiedFiles map
        wxString relativePath = absPath;
 
        if( relativePath.StartsWith( repoWorkDir ) )
        {
            relativePath = relativePath.Mid( repoWorkDir.length() );
#ifdef _WIN32
            relativePath.Replace( wxS( "\\" ), wxS( "/" ) );
#endif
        }
 
        // Do not commit files outside the project directory
        if( !KIGIT::PROJECT_GIT_UTILS::IsWithinProjectPath( absPath, projectPath ) )
            continue;
 
        // Skip lock files
        if( fn.GetExt().CmpNoCase( FILEEXT::LockFileExtension ) == 0 )
            continue;
 
        // Skip autosave, lock, and backup files
        if( fn.GetName().StartsWith( FILEEXT::LockFilePrefix )
            || fn.GetName().EndsWith( FILEEXT::BackupFileSuffix ) )
        {
            continue;
        }
 
        // Skip archived project backups
        if( fn.GetPath().Contains( Prj().GetProjectName() + wxT( "-backups" ) ) )
            continue;
 
        // Skip local project history (which is also a submodule, we don't support for the time)
        if( fn.IsDir() && fn.GetDirs().Last().StartsWith( wxS( ".history" ) ) )
        {
            continue;
        }
 
        if( aEvent.GetId() == ID_GIT_COMMIT_PROJECT )
        {
            // Don't add an untracked project-local settings file to the repo on its own
            // Only commit it if it's already tracked, or if the user selects it explicitly.
            if( fn.GetExt().CmpNoCase( FILEEXT::ProjectLocalSettingsFileExtension ) == 0
                && fileStatus.status == KIGIT_COMMON::GIT_STATUS::GIT_STATUS_UNTRACKED )
            {
                continue;
            }
 
            modifiedFiles.emplace( relativePath, fileStatus.gitStatus );
        }
        else if( selected_files.count( absPath ) )
        {
            modifiedFiles.emplace( relativePath, fileStatus.gitStatus );
        }
    }
 
    // Create a commit dialog
    DIALOG_GIT_COMMIT dlg( wxGetTopLevelParent( this ), repo, userConfig.authorName, userConfig.authorEmail,
                           modifiedFiles );
    int               ret = dlg.ShowModal();
 
    if( ret != wxID_OK )
        return;
 
    std::vector<wxString> files = dlg.GetSelectedFiles();
 
    if( dlg.GetCommitMessage().IsEmpty() )
    {
        wxMessageBox( _( "Discarding commit due to empty commit message." ) );
        return;
    }
 
    if( files.empty() )
    {
        wxMessageBox( _( "Discarding commit due to empty file selection." ) );
        return;
    }
 
    GIT_COMMIT_HANDLER commitHandler( repo );
    CommitResult       result = commitHandler.PerformCommit( files, dlg.GetCommitMessage(), dlg.GetAuthorName(),
                                                             dlg.GetAuthorEmail() );
 
    if( result != CommitResult::Success )
    {
        wxMessageBox( wxString::Format( _( "Failed to create commit: %s" ), commitHandler.GetErrorString() ) );
        return;
    }
 
    wxLogTrace( traceGit, wxS( "Created commit" ) );
    m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
}
 
 
void PROJECT_TREE_PANE::onGitAmendCommit( wxCommandEvent& aEvent )
{
    git_repository* repo = m_TreeProject->GetGitRepo();
 
    if( repo == nullptr )
    {
        wxMessageBox( _( "The selected directory is not a Git project." ) );
        return;
    }
 
    wxString reopenPath = Prj().GetProjectPath();
 
    if( git_repository* fresh = KIGIT::PROJECT_GIT_UTILS::GetRepositoryForFile( reopenPath.c_str() ) )
    {
        // Swapping the handle is only safe when no background fetch or status update holds
        // the old one, so keep the existing handle if the mutex is busy.
        std::unique_lock<std::mutex> gitLock( m_TreeProject->GitCommon()->m_gitActionMutex, std::try_to_lock );
 
        if( gitLock.owns_lock() )
        {
            m_TreeProject->SetGitRepo( fresh );
            git_repository_free( repo );
            repo = fresh;
        }
        else
        {
            git_repository_free( fresh );
        }
    }
 
    if( git_repository_head_unborn( repo ) != 0 )
    {
        DisplayErrorMessage( wxGetTopLevelParent( this ), _( "Cannot amend: the branch has no commits yet." ) );
        return;
    }
 
    // Look up HEAD commit so we can pre-fill the message and check whether HEAD has
    // already been published to the upstream branch.
    git_reference* headRef = nullptr;
 
    if( git_repository_head( &headRef, repo ) != GIT_OK )
        return;
 
    KIGIT::GitReferencePtr headRefPtr( headRef );
    git_commit*            headCommit = nullptr;
 
    if( git_reference_peel( (git_object**) &headCommit, headRef, GIT_OBJECT_COMMIT ) != GIT_OK )
        return;
 
    KIGIT::GitCommitPtr headCommitPtr( headCommit );
    wxString            headMessage = wxString::FromUTF8( git_commit_message( headCommit ) );
    const git_oid*      headOid = git_commit_id( headCommit );
 
    // Detect whether HEAD has already been pushed: head is published when it is the
    // upstream OID or an ancestor of it.
    bool           headIsPublished = false;
    git_reference* upstreamRef = nullptr;
 
    if( git_branch_upstream( &upstreamRef, headRef ) == GIT_OK )
    {
        KIGIT::GitReferencePtr upstreamRefPtr( upstreamRef );
        git_oid                upstreamOid;
 
        if( git_reference_name_to_id( &upstreamOid, repo, git_reference_name( upstreamRef ) ) == GIT_OK )
        {
            headIsPublished = git_oid_equal( headOid, &upstreamOid )
                              || git_graph_descendant_of( repo, &upstreamOid, headOid ) == 1;
        }
    }
 
    if( headIsPublished )
    {
        wxString upstreamName = m_TreeProject->GitCommon()->GetUpstreamShorthand();
 
        wxRichMessageDialog dlg( wxGetTopLevelParent( this ),
                                 wxString::Format( _( "The last commit has already been pushed to %s.\n\n"
                                                      "Amending rewrites public history.  Anyone who pulled "
                                                      "this commit will need to reset their copy." ),
                                                   upstreamName ),
                                 _( "Amend Published Commit?" ), wxYES_NO | wxNO_DEFAULT | wxICON_WARNING | wxCENTER );
 
        dlg.SetYesNoLabels( _( "Amend &Anyway" ), _( "Cancel" ) );
 
        if( dlg.ShowModal() != wxID_YES )
            return;
    }
 
    // Flush in-memory editor and project state so the amend captures the user's actual
    // work instead of a stale on-disk version.
    {
        struct DirtyEditor
        {
            FRAME_T  frameType;
            MAIL_T   saveMail;
            wxString label;
        };
 
        const DirtyEditor candidates[] = {
            { FRAME_SCH, MAIL_SCH_SAVE, _( "Schematic Editor" ) },
            { FRAME_PCB_EDITOR, MAIL_PCB_SAVE, _( "PCB Editor" ) },
        };
 
        std::vector<const DirtyEditor*> dirty;
 
        for( const DirtyEditor& d : candidates )
        {
            KIWAY_PLAYER* frame = m_Parent->Kiway().Player( d.frameType, false );
 
            if( frame && frame->IsContentModified() )
                dirty.push_back( &d );
        }
 
        if( !dirty.empty() )
        {
            wxString listed;
 
            for( const DirtyEditor* d : dirty )
                listed += wxString::Format( wxS( "\n    • %s" ), d->label );
 
            wxRichMessageDialog dlg( wxGetTopLevelParent( this ),
                                     wxString::Format( _( "The following editors have unsaved changes:%s\n\n"
                                                          "Save them before amending?" ),
                                                       listed ),
                                     _( "Unsaved Changes" ),
                                     wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxICON_WARNING | wxCENTER );
 
            dlg.SetYesNoCancelLabels( _( "&Save and Amend" ), _( "Amend &Anyway" ), _( "Cancel" ) );
 
            int answer = dlg.ShowModal();
 
            if( answer == wxID_CANCEL )
                return;
 
            if( answer == wxID_YES )
            {
                for( const DirtyEditor* d : dirty )
                {
                    std::string payload;
                    m_Parent->Kiway().ExpressMail( d->frameType, d->saveMail, payload );
 
                    if( payload != "success" )
                    {
                        DisplayErrorMessage( wxGetTopLevelParent( this ),
                                             wxString::Format( _( "Could not save %s." ), d->label ) );
                        return;
                    }
                }
            }
        }
 
        m_Parent->GetSettingsManager()->SaveProject();
    }
 
    // Collect modified files for the dialog's checklist.
    GIT_CONFIG_HANDLER configHandler( m_TreeProject->GitCommon() );
    GitUserConfig      userConfig = configHandler.GetUserConfig();
 
    GIT_STATUS_HANDLER             statusHandler( m_TreeProject->GitCommon() );
    std::map<wxString, FileStatus> fileStatusMap = statusHandler.GetFileStatus();
    wxString                       repoWorkDir = statusHandler.GetWorkingDirectory();
    wxString                       projectPath = Prj().GetProjectPath();
 
#ifdef _WIN32
    projectPath.Replace( wxS( "\\" ), wxS( "/" ) );
#endif
 
    std::map<wxString, int> modifiedFiles;
 
    for( const auto& [absPath, fileStatus] : fileStatusMap )
    {
        if( fileStatus.status == KIGIT_COMMON::GIT_STATUS::GIT_STATUS_CURRENT
            || fileStatus.status == KIGIT_COMMON::GIT_STATUS::GIT_STATUS_CONFLICTED
            || fileStatus.status == KIGIT_COMMON::GIT_STATUS::GIT_STATUS_IGNORED )
        {
            continue;
        }
 
        wxFileName fn( absPath );
        wxString   relativePath = absPath;
 
        if( relativePath.StartsWith( repoWorkDir ) )
        {
            relativePath = relativePath.Mid( repoWorkDir.length() );
#ifdef _WIN32
            relativePath.Replace( wxS( "\\" ), wxS( "/" ) );
#endif
        }
 
        if( !KIGIT::PROJECT_GIT_UTILS::IsWithinProjectPath( absPath, projectPath ) )
            continue;
 
        if( fn.GetExt().CmpNoCase( FILEEXT::LockFileExtension ) == 0 )
            continue;
 
        if( fn.GetName().StartsWith( FILEEXT::LockFilePrefix ) || fn.GetName().EndsWith( FILEEXT::BackupFileSuffix ) )
            continue;
 
        if( fn.GetPath().Contains( Prj().GetProjectName() + wxT( "-backups" ) ) )
            continue;
 
        modifiedFiles.emplace( relativePath, fileStatus.gitStatus );
    }
 
    if( git_reference* headRefForDiff = nullptr; git_repository_head( &headRefForDiff, repo ) == GIT_OK )
    {
        KIGIT::GitReferencePtr headRefForDiffPtr( headRefForDiff );
        git_commit*            lastCommit = nullptr;
 
        if( git_reference_peel( (git_object**) &lastCommit, headRefForDiff, GIT_OBJECT_COMMIT ) == GIT_OK )
        {
            KIGIT::GitCommitPtr lastCommitPtr( lastCommit );
            git_commit*         parentCommit = nullptr;
            git_tree*           parentTree = nullptr;
            git_tree*           lastTree = nullptr;
 
            if( git_commit_parentcount( lastCommit ) > 0
                && git_commit_parent( &parentCommit, lastCommit, 0 ) == GIT_OK )
            {
                git_commit_tree( &parentTree, parentCommit );
            }
 
            KIGIT::GitCommitPtr parentCommitPtr( parentCommit );
            KIGIT::GitTreePtr   parentTreePtr( parentTree );
 
            if( git_commit_tree( &lastTree, lastCommit ) == GIT_OK )
            {
                KIGIT::GitTreePtr lastTreePtr( lastTree );
                git_diff*         diff = nullptr;
 
                if( git_diff_tree_to_tree( &diff, repo, parentTree, lastTree, nullptr ) == GIT_OK )
                {
                    KIGIT::GitDiffPtr diffPtr( diff );
 
                    KIGIT::CollectDiffDeltas( diff,
                            [&modifiedFiles, &repoWorkDir, &projectPath]( const git_diff_delta& aDelta )
                            {
                                const char* path = aDelta.new_file.path ? aDelta.new_file.path
                                                                        : aDelta.old_file.path;
 
                                if( !path )
                                    return;
 
                                // Skip files from the previous commit that live outside the
                                // current project directory (issue #15910).
                                wxString absPath = repoWorkDir + wxString::FromUTF8( path );
 
                                if( !KIGIT::PROJECT_GIT_UTILS::IsWithinProjectPath( absPath, projectPath ) )
                                    return;
 
                                int flag = GIT_STATUS_INDEX_MODIFIED;
 
                                if( aDelta.status == GIT_DELTA_ADDED )
                                    flag = GIT_STATUS_INDEX_NEW;
                                else if( aDelta.status == GIT_DELTA_DELETED )
                                    flag = GIT_STATUS_INDEX_DELETED;
 
                                modifiedFiles[wxString::FromUTF8( path )] |= flag;
                            } );
                }
            }
        }
    }
 
    DIALOG_GIT_COMMIT dlg( wxGetTopLevelParent( this ), repo, userConfig.authorName, userConfig.authorEmail,
                           modifiedFiles );
    dlg.SetTitle( _( "Amend Last Commit" ) );
    dlg.SetCommitMessage( headMessage );
    dlg.SetFileSelectionRequired( false );
 
    if( dlg.ShowModal() != wxID_OK )
        return;
 
    if( dlg.GetCommitMessage().IsEmpty() )
    {
        wxMessageBox( _( "Discarding amend due to empty commit message." ) );
        return;
    }
 
    GIT_COMMIT_HANDLER commitHandler( repo );
    CommitResult       result = commitHandler.PerformAmend( dlg.GetSelectedFiles(), dlg.GetCommitMessage(),
                                                            dlg.GetAuthorName(), dlg.GetAuthorEmail() );
 
    if( result != CommitResult::Success )
    {
        wxMessageBox( wxString::Format( _( "Failed to amend commit: %s" ), commitHandler.GetErrorString() ) );
        return;
    }
 
    wxLogTrace( traceGit, wxS( "Amended commit" ) );
    m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
}
 
 
void PROJECT_TREE_PANE::onGitAddToIndex( wxCommandEvent& aEvent )
{
 
}
 
 
bool PROJECT_TREE_PANE::canFileBeAddedToVCS( const wxString& aFile )
{
    if( !m_TreeProject->GetGitRepo() )
        return false;
 
    GIT_STATUS_HANDLER             statusHandler( m_TreeProject->GitCommon() );
    std::map<wxString, FileStatus> fileStatusMap = statusHandler.GetFileStatus();
 
    // Check if file is already tracked or staged
    for( const auto& [filePath, fileStatus] : fileStatusMap )
    {
        if( filePath.EndsWith( aFile ) || filePath == aFile )
        {
            // File can be added if it's untracked
            return fileStatus.status == KIGIT_COMMON::GIT_STATUS::GIT_STATUS_UNTRACKED;
        }
    }
 
    // If file not found in status, it might be addable
    return true;
}
 
 
void PROJECT_TREE_PANE::onGitSyncProject( wxCommandEvent& aEvent )
{
    wxLogTrace( traceGit, "Syncing project" );
    git_repository* repo = m_TreeProject->GetGitRepo();
 
    if( !repo )
    {
        wxLogTrace( traceGit, "sync: No git repository found" );
        return;
    }
 
    GIT_SYNC_HANDLER handler( repo );
    handler.PerformSync();
}
 
 
void PROJECT_TREE_PANE::onGitFetch( wxCommandEvent& aEvent )
{
    KIGIT_COMMON* gitCommon = m_TreeProject->GitCommon();
 
    if( !gitCommon )
        return;
 
    while( true )
    {
        gitCommon->ClearAuthFailure();
 
        GIT_PULL_HANDLER handler( gitCommon );
 
        if( handler.PerformFetch() )
        {
            wxString remoteName = gitCommon->GetRemoteNameOrDefault();
 
            showGitFeedback( remoteName.empty() ? _( "Fetched from remote." )
                                                : wxString::Format( _( "Fetched from %s." ), remoteName ) );
            break;
        }
 
        if( gitCommon->WasAuthFailure() && promptForGitCredentials( m_parent, gitCommon ) )
            continue;
 
        showGitFeedback( _( "Fetch failed." ) );
        break;
    }
 
    m_gitStatusTimer.Start( 500, wxTIMER_ONE_SHOT );
}
 
 
void PROJECT_TREE_PANE::onGitResolveConflict( wxCommandEvent& aEvent )
{
    git_repository* repo = m_TreeProject->GetGitRepo();
 
    if( !repo )
        return;
 
    GIT_RESOLVE_CONFLICT_HANDLER handler( repo );
    handler.PerformResolveConflict();
}
 
 
void PROJECT_TREE_PANE::onGitRevertLocal( wxCommandEvent& aEvent )
{
    git_repository* repo = m_TreeProject->GetGitRepo();
 
    if( !repo )
        return;
 
    GIT_REVERT_HANDLER handler( repo );
    handler.PerformRevert();
}
 
 
void PROJECT_TREE_PANE::onGitRemoveFromIndex( wxCommandEvent& aEvent )
{
    git_repository* repo = m_TreeProject->GetGitRepo();
 
    if( !repo )
        return;
 
    GIT_REMOVE_FROM_INDEX_HANDLER handler( repo );
    handler.PerformRemoveFromIndex();
}
 
 
void PROJECT_TREE_PANE::onRunSelectedJobsFile(wxCommandEvent& event)
{
 
}
 
 
void PROJECT_TREE_PANE::onGitSyncTimer( wxTimerEvent& aEvent )
{
    wxLogTrace( traceGit, "onGitSyncTimer" );
    COMMON_SETTINGS::GIT& gitSettings = Pgm().GetCommonSettings()->m_Git;
 
    if( !gitSettings.enableGit || gitSettings.updatInterval <= 0 || !m_TreeProject )
        return;
 
    // Skip the tick rather than stack a second fetch; assigning over a running std::async
    // future blocks in its destructor, here on the UI thread.
    if( m_gitSyncTask.valid()
            && m_gitSyncTask.wait_for( std::chrono::seconds( 0 ) ) != std::future_status::ready )
    {
        wxLogTrace( traceGit, "onGitSyncTimer: previous fetch still running, skipping" );
        m_gitSyncTimer.Start( gitSettings.updatInterval * 60 * 1000, wxTIMER_ONE_SHOT );
        return;
    }
 
    if( std::shared_ptr<KIGIT_COMMON> gitCommon = m_TreeProject->GitCommonPtr() )
        gitCommon->SetCancelled( false );
 
    // Never the shared compute pool; a libgit2 network read parked there stalls DRC, zone
    // filling and library loading.
    m_gitSyncTask = std::async( std::launch::async, [this]()
    {
        // Pin a shared handle so a concurrent releaseGitRepo() cannot free the common while
        // PerformFetch() is inside it holding the action mutex.
        std::shared_ptr<KIGIT_COMMON> gitCommon = m_TreeProject->GitCommonPtr();
 
        if( !gitCommon || !gitCommon->GetRepo() )
        {
            wxLogTrace( traceGit, "onGitSyncTimer: No git repository found" );
            return;
        }
 
        // Check if cancellation was requested (e.g., during shutdown)
        if( gitCommon->IsCancelled() )
        {
            wxLogTrace( traceGit, "onGitSyncTimer: Cancelled" );
            return;
        }
 
        GIT_PULL_HANDLER handler( gitCommon.get() );
        handler.PerformFetch();
 
        // Only schedule the follow-up work if not cancelled
        if( !gitCommon->IsCancelled() )
            CallAfter( [this]() { gitStatusTimerHandler(); } );
    } );
 
    wxLogTrace( traceGit, "onGitSyncTimer: Restarting git sync timer" );
    // We store the timer interval in minutes but wxTimer uses milliseconds
    m_gitSyncTimer.Start( gitSettings.updatInterval * 60 * 1000, wxTIMER_ONE_SHOT );
}
 
 
void PROJECT_TREE_PANE::gitStatusTimerHandler()
{
    // Check if git is still available and not cancelled before spawning background work
    KIGIT_COMMON* gitCommon = m_TreeProject ? m_TreeProject->GitCommon() : nullptr;
 
    if( !gitCommon || gitCommon->IsCancelled() )
        return;
 
    updateTreeCache();
    thread_pool& tp = GetKiCadThreadPool();
 
    m_gitStatusIconTask = tp.submit_task( [this]() { updateGitStatusIconMap(); } );
}
 
void PROJECT_TREE_PANE::onGitStatusTimer( wxTimerEvent& aEvent )
{
    wxLogTrace( traceGit, "onGitStatusTimer" );
 
    if( !Pgm().GetCommonSettings()->m_Git.enableGit || !m_TreeProject )
        return;
 
    gitStatusTimerHandler();
}
 
 
void PROJECT_TREE_PANE::showGitFeedback( const wxString& aText )
{
    if( m_Parent )
    {
        m_Parent->SetStatusText( aText, 0 );
        m_gitFeedbackTimer.Start( 8000, wxTIMER_ONE_SHOT );
    }
}
 
 
void PROJECT_TREE_PANE::onGitFeedbackTimer( wxTimerEvent& aEvent )
{
    if( m_Parent )
        m_Parent->PrintPrjInfo();
}