private void OnEditorUpdateInternal()
{
//Only initialize if the editor Window is focused
if (HasFocus && initilized == null && gitManager.Repository != null)
{
var gitManagerStatus = gitManager.GetCachedStatus();
if (gitManagerStatus != null)
{
cachedStatus = gitManagerStatus;
initilized = true;
if (!gitManager.IsValidRepo)
{
return;
}
OnInitialize();
OnGitManagerUpdateRepositoryInternal(gitManagerStatus, null);
//simulate repository loading for first initialization
OnRepositoryLoad(gitManager.Repository);
Repaint();
}
}
if (HasFocus)
{
OnEditorUpdate();
}
}
public void IssueUpdateRepository(GitRepoStatus repoStatus, string[] paths)
{
if (UpdateRepository != null)
{
UpdateRepository.Invoke(repoStatus, paths);
}
}
private void CreateStatusListInternal(GitRepoStatus status, string[] paths, bool threaded)
{
if (status == null)
{
logger.Log(LogType.Assert, "Trying to create status list from empty status");
return;
}
try
{
var newStatusList = new DiffWindowStatusList(gitSettings, gitManager, lfsHelper);
if (paths == null || paths.Length <= 0)
{
lock (diffWindowStatusList.LockObj)
{
lock (status.LockObj)
{
foreach (var entry in status.Where(e => settings.showFileStatusTypeFilter.IsFlagSet(e.Status)))
{
newStatusList.Add(entry, null);
}
newStatusList.Sort(sorter);
diffWindowStatusList = newStatusList;
}
}
}
else
{
lock (diffWindowStatusList.LockObj)
{
newStatusList.Copy(diffWindowStatusList);
newStatusList.RemoveRange(paths);
List <GitAsyncOperation> operations = new List <GitAsyncOperation>();
foreach (var path in paths)
{
operations.Add(asyncManager.QueueWorkerWithLock((p) =>
{
GitStatusEntry entry;
if (status.Get(p, out entry) && settings.showFileStatusTypeFilter.IsFlagSet(entry.Status))
{
newStatusList.Add(entry, sorter);
}
}, path, newStatusList.LockObj, threaded));
}
while (operations.Any(o => !o.IsDone))
{
//spin wait
}
diffWindowStatusList = newStatusList;
}
}
//statusList.Sort();
}
catch (Exception e)
{
logger.LogException(e);
}
}
protected virtual void OnLostFocus()
{
//the window is docked and has become hidden reset the initialization
if (!HasFocus)
{
initilized = null;
cachedStatus = null;
}
}
public override void OnGitUpdate(GitRepoStatus status, string[] paths)
{
base.OnGitUpdate(status, paths);
if (gitManager.Repository == null)
{
return;
}
UpdateRemotes();
}
protected override void OnGitUpdate(GitRepoStatus status, string[] paths)
{
if (GitManager.Repository == null)
{
return;
}
UpdateRemotes();
UpdateBranches();
}
private void UpdateStatusTreeThreaded(GitRepoStatus status)
{
asyncManager.QueueWorkerWithLock(() =>
{
lock (status.LockObj)
{
UpdateStatusTree(status, true);
}
}, statusTreeLock, true);
}
private void OnGitManagerUpdateInternal(GitRepoStatus status, string[] paths)
{
//only update the window if it is initialized. That means opened and visible.
//the editor window will initialize itself once it's focused
if (!initilized || !gitManager.IsValidRepo)
{
return;
}
OnGitUpdate(status, paths);
}
protected override void OnGitUpdate(GitRepoStatus status, string[] paths)
{
if (gitManager.Threading.IsFlagSet(GitSettingsJson.ThreadingType.StatusListGui))
{
CreateStatusListThreaded(status, paths);
}
else
{
CreateStatusList(status, paths);
}
}
private void UpdateStatusTree(GitRepoStatus status, bool threaded = false)
{
try
{
var newStatusTree = new StatusTreeClass(gitSettings, status);
statusTree = newStatusTree;
gitManager.ExecuteAction(RepaintProjectWidnow, threaded);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
private void OnGitManagerUpdateInternal(GitRepoStatus status, string[] paths)
{
titleContent.image = GitManager.GetGitStatusIcon();
//only update the window if it is initialized. That means opened and visible.
//the editor window will initialize itself once it's focused
if (initilized == null || !GitManager.IsValidRepo)
{
return;
}
OnGitUpdate(status, paths);
Repaint();
}
private static void RebuildStatus(string[] paths)
{
if (paths != null && paths.Length > 0 && status != null)
{
foreach (var path in paths)
{
status.Update(path, repository.RetrieveStatus(path));
}
}
else
{
status = new GitRepoStatus(repository.RetrieveStatus());
}
}
private void StartUpdateChaches(GitRepoStatus status)
{
if (gitManager.Threading.IsFlagSet(GitSettingsJson.ThreadingType.CommitListGui))
{
loadingCommits = asyncManager.QueueWorkerWithLock(UpdateChaches, status, "Loading Commits", (o) =>
{
OnCachesUpdated();
}, commitCachesLock);
}
else
{
UpdateChaches(status);
OnCachesUpdated();
}
}
private void OnEnable()
{
if (repositoryStatus == null)
{
repositoryStatus = new GitRepoStatus();
}
if (dirtyFilesQueue == null)
{
dirtyFilesQueue = new List <string>();
}
if (logEntries == null)
{
logEntries = new List <GitLog.LogEntry>();
}
}
private void OnUpdateRepository(GitRepoStatus status, string[] paths)
{
if (gitSettings.Threading.IsFlagSet(GitSettingsJson.ThreadingType.StatusList))
{
gitManager.ActionQueue.Enqueue(() =>
{
UpdateStatusTreeThreaded(status);
});
}
else
{
GitProfilerProxy.BeginSample("Git Project Window status tree building");
UpdateStatusTree(status);
GitProfilerProxy.EndSample();
}
}
private static void RebuildStatus(string[] paths)
{
if (paths != null && paths.Length > 0 && status != null)
{
foreach (var path in paths)
{
status.Update(path, repository.RetrieveStatus(path));
}
}
else
{
var options = GetStatusOptions();
var s = repository.RetrieveStatus(options);
status = new GitRepoStatus(s);
}
}
private static void UpdateStatusTreeThreaded(object statusObj)
{
Monitor.Enter(statusTreeLock);
try
{
GitRepoStatus status = (GitRepoStatus)statusObj;
statusTree = new StatusTreeClass(status);
actionQueue.Enqueue(RepaintProjectWidnow);
}
catch (Exception e)
{
Debug.LogException(e);
}
finally
{
Monitor.Exit(statusTreeLock);
}
}
private void UpdateChachesThreaded(object statusObj)
{
Monitor.Enter(commitCachesLock);
try
{
GitRepoStatus status = (GitRepoStatus)statusObj;
//update all branches
cachedBranches = GitManager.Repository.Branches.Select(b => new BranchInfo(b)).ToArray();
//update selected branch
UpdateSelectedBranch();
int commitCount = 0;
if (selectedBranch != null)
{
//update commits and limit them depending on settings
var loadedBranch = selectedBranch.LoadBranch();
if (loadedBranch != null && loadedBranch.Commits != null)
{
IEnumerable <Commit> commits = GitManager.Settings.MaxCommits >= 0 ? loadedBranch.Commits.Take(GitManager.Settings.MaxCommits) : loadedBranch.Commits;
if (commits != null)
{
cachedCommits = commits.Take(GitManager.Settings.MaxCommits).Select(c => new CommitInfo(c, cachedBranches.Where(b => b.Tip.Id == c.Id).ToArray())).ToArray();
commitCount = cachedCommits.Length;
}
}
}
commitRects = new Rect[commitCount];
hasConflicts = status.Any(s => s.Status == FileStatus.Conflicted);
GitManager.ActionQueue.Enqueue(UpdateGitStatusIcon);
GitManager.ActionQueue.Enqueue(Repaint);
}
catch (Exception e)
{
Debug.LogException(e);
}
finally
{
Monitor.Exit(commitCachesLock);
}
}
private void UpdateStatusTree(GitRepoStatus status, bool threaded = false)
{
try
{
var subModules = status.SubModuleEntries;
if (gitManager.InSubModule)
{
subModules = subModules.Concat(new [] { new GitStatusSubModuleEntry(gitSettings.ActiveSubModule) });
}
var newStatusTree = injectionHelper.CreateInstance <StatusTreeClass>(cullNonAssetPaths);
newStatusTree.Build(status, subModules);
statusTree = newStatusTree;
gitManager.ExecuteAction(RepaintProjectWidnow, threaded);
}
catch (Exception e)
{
logger.LogException(e);
}
}
private void CreateStatusListThreaded(GitRepoStatus status, string[] paths)
{
if (statusListUpdateOperation != null && !statusListUpdateOperation.IsDone)
{
needsAsyncStatusListUpdate = true;
if (paths != null)
{
foreach (var path in paths)
{
pathsToBeUpdated.Add(path);
}
}
}
else
{
statusListUpdateOperation = asyncManager.QueueWorkerWithLock(() =>
{
CreateStatusListInternal(status, paths, true);
},
(o) =>
{
updatingPaths.Clear();
Repaint();
}, statusListLock, true);
if (paths != null)
{
foreach (var path in paths)
{
updatingPaths.Add(path);
}
}
foreach (var path in pathsToBeUpdated)
{
updatingPaths.Add(path);
}
pathsToBeUpdated.Clear();
}
}
private void UpdateChaches(GitRepoStatus status)
{
try
{
//update all branches
cachedBranches = gitManager.Repository.Branches.Select(b => new BranchInfo(b)).ToArray();
//update selected branch
SetSelectedBranch(selectedBranchName);
int commitCount = 0;
CommitInfo[] newCachedCommits = null;
if (selectedBranch != null)
{
//update commits and limit them depending on settings
var loadedBranch = selectedBranch.LoadBranch(gitManager);
if (loadedBranch != null && loadedBranch.Commits != null)
{
Commit[] commits = loadedBranch.Commits.Take(maxCommitsCount).ToArray();
newCachedCommits = new CommitInfo[commits.Length];
for (int i = 0; i < commits.Length; i++)
{
newCachedCommits[i] = new CommitInfo(commits[i], cachedBranches.Where(b => b.Tip.Id == commits[i].Id).ToArray());
}
commitCount = newCachedCommits.Length;
}
}
commitRects = new Rect[commitCount];
cachedCommits = newCachedCommits;
hasConflicts = status.Any(s => s.Status == FileStatus.Conflicted);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
private void RepositoryUpdate(GitRepoStatus status, string[] paths)
{
updateRepositoryCalled++;
}
protected override void OnGitUpdate(GitRepoStatus status, string[] path)
{
Repaint();
StartUpdateChaches(status);
}
public virtual void OnGitUpdate(GitRepoStatus status, string[] paths)
{
}
protected abstract void OnGitUpdate(GitRepoStatus status, string[] paths);
protected override void OnGitUpdate(GitRepoStatus status, string[] paths)
{
}
private void CreateStatusList(GitRepoStatus param, string[] paths)
{
CreateStatusListInternal(param, paths, false);
Repaint();
}
private void OnUpdateRepository(GitRepoStatus status, string[] paths)
{
UpdateInitilized();
}
private void CreateStatusList(GitRepoStatus param)
{
CreateStatusListInternal(param, null, false);
Repaint();
}
protected override void OnGitUpdate(GitRepoStatus status, string[] path)
{
ThreadPool.QueueUserWorkItem(UpdateChachesThreaded, status);
}