public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedNode;
ISolutionFolderNode solutionFolderNode = node as ISolutionFolderNode;
if (solutionFolderNode != null)
{
using (OpenFileDialog fdiag = new OpenFileDialog()) {
fdiag.AddExtension = true;
fdiag.Filter = ProjectService.GetAllProjectsFilter(this, false);
fdiag.Multiselect = true;
fdiag.CheckFileExists = true;
fdiag.InitialDirectory = AddNewProjectToSolution.GetInitialDirectorySuggestion(solutionFolderNode.Folder);
if (fdiag.ShowDialog(SD.WinForms.MainWin32Window) == DialogResult.OK)
{
try {
foreach (string fileName in fdiag.FileNames)
{
solutionFolderNode.Folder.AddExistingProject(FileName.Create(fileName));
}
} catch (ProjectLoadException ex) {
MessageService.ShowError(ex.Message);
} catch (IOException ex) {
MessageService.ShowError(ex.Message);
}
ProjectService.SaveSolution();
}
}
}
}
public override void Execute(object parameter)
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
if (node != null) {
string nodeFileName = null;
var projectNode = node as ProjectNode;
if (projectNode != null)
nodeFileName = projectNode.Project.FileName;
else
{
var directoryNode = node as DirectoryNode;
if (directoryNode != null)
nodeFileName = directoryNode.Directory;
else
{
var fileNode = node as FileNode;
if (fileNode != null)
nodeFileName = fileNode.FileName;
else
{
var solutionNode = node as SolutionNode;
if (solutionNode != null)
nodeFileName = solutionNode.Solution.Directory;
}
}
}
if (nodeFileName != null) {
List<OpenedFile> unsavedFiles = new List<OpenedFile>();
foreach (OpenedFile file in SD.FileService.OpenedFiles) {
if (file.IsDirty && !file.IsUntitled) {
if (string.IsNullOrEmpty(file.FileName)) continue;
if (FileUtility.IsUrl(file.FileName)) continue;
if (FileUtility.IsBaseDirectory(nodeFileName, file.FileName)) {
unsavedFiles.Add(file);
}
}
}
if (unsavedFiles.Count > 0) {
if (MessageService.ShowCustomDialog(
MessageService.DefaultMessageBoxTitle,
"The version control operation would affect files with unsaved modifications.\n" +
"You have to save those files before running the operation.",
0, 1,
"Save files", "Cancel")
== 0)
{
// Save
foreach (OpenedFile file in unsavedFiles) {
ICSharpCode.SharpDevelop.Commands.SaveFile.Save(file);
}
} else {
// Cancel
return;
}
}
// now run the actual operation:
Execute(nodeFileName, node, AfterCommand(nodeFileName, node));
}
}
}
protected override void Execute(string filename, AbstractProjectBrowserTreeNode node, Action callback)
{
var item = TFS.GetTfsItem(filename);
if (item != null)
{
try {
// var historyList = item.Workspace.VersionControlServer.QueryHistory(item.ItemSpec).ToList();
// var earliest = historyList.OrderByDescending(x => x.CreationDate).FirstOrDefault();
var wrapper = new TfsHistoryDialogWrapper(
item.Workspace.VersionControlServer,
filename,
VersionSpec.Latest,
item.ItemSpec.DeletionId,
RecursionType.OneLevel,
null,
null,
string.Empty,
int.MaxValue,
true);
wrapper.ShowDialog();
//item.Workspace.VersionControlServer.GetItem(filename);
}
catch (Exception ex)
{
}
}
}
void AddWebReferenceToProjectBrowser(AbstractProjectBrowserTreeNode node, WebReference webReference)
{
TreeNode webReferencesNode = null;
if (node is ProjectNode)
{
webReferencesNode = AddWebReferenceToProjectNode((ProjectNode)node, webReference);
}
else if (node is WebReferencesFolderNode)
{
webReferencesNode = node;
WebReferenceNodeBuilder.AddWebReference((WebReferencesFolderNode)webReferencesNode, webReference);
}
else if (node is ReferenceFolder && node.Parent != null && node.Parent is ProjectNode)
{
webReferencesNode = AddWebReferenceToProjectNode((ProjectNode)node.Parent, webReference);
}
else
{
LoggingService.Warn("AddWebReferenceToProjectBrowser: Selected node type is not handled.");
AddWebReferenceToProjectBrowser(node.Parent as AbstractProjectBrowserTreeNode, webReference);
}
if (webReferencesNode != null)
{
ProjectBrowserPad.Instance.ProjectBrowserControl.TreeView.Sort();
webReferencesNode.Expand();
webReferencesNode.EnsureVisible();
}
}
public static void EnqueueRecursive(AbstractProjectBrowserTreeNode node)
{
if (subversionDisabled)
{
return;
}
lock (queue) {
queue.Enqueue(node);
// use breadth-first search
Queue <AbstractProjectBrowserTreeNode> q = new Queue <AbstractProjectBrowserTreeNode>();
q.Enqueue(node);
while (q.Count > 0)
{
node = q.Dequeue();
foreach (TreeNode n in node.Nodes)
{
node = n as AbstractProjectBrowserTreeNode;
if (node != null)
{
q.Enqueue(node);
queue.Enqueue(node);
}
}
}
if (!threadRunning)
{
threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = Owner as AbstractProjectBrowserTreeNode;
IProject project = (node != null) ? node.Project : ProjectService.CurrentProject;
if (project == null)
{
return;
}
LoggingService.Info("Show add reference dialog for " + project.FileName);
using (SelectReferenceDialog selDialog = new SelectReferenceDialog(project)) {
if (selDialog.ShowDialog(SD.WinForms.MainWin32Window) == DialogResult.OK)
{
var duplicateReferences = new List <string>();
foreach (ReferenceProjectItem reference in selDialog.ReferenceInformations)
{
var thisReference = reference;
if (project.Items.OfType <ReferenceProjectItem>().All(r => r.ShortName != thisReference.ShortName))
{
ProjectService.AddProjectItem(project, reference);
}
}
project.Save();
}
}
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
System.Configuration.ConfigurationSettings.AppSettings["TagDatabase"] = ((FileNode)node).FullPath;
//node.NodeFont = new Font(node.TreeView.Font, FontStyle.Bold);
}
public static void EnqueueRecursive(AbstractProjectBrowserTreeNode node)
{
lock (queue) {
if (inQueue.Add(node))
queue.Enqueue(node);
// use breadth-first search
Queue<AbstractProjectBrowserTreeNode> q = new Queue<AbstractProjectBrowserTreeNode>();
q.Enqueue(node);
while (q.Count > 0) {
node = q.Dequeue();
foreach (TreeNode n in node.Nodes) {
node = n as AbstractProjectBrowserTreeNode;
if (node != null) {
q.Enqueue(node);
if (inQueue.Add(node))
queue.Enqueue(node);
}
}
}
if (!threadRunning) {
threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
if (node != null && node.Project != null)
{
using (AddWebReferenceDialog refDialog = new AddWebReferenceDialog(node.Project)) {
refDialog.NamespacePrefix = node.Project.RootNamespace;
if (refDialog.ShowDialog() == DialogResult.OK)
{
// Do not overwrite existing web references.
refDialog.WebReference.Name = WebReference.GetReferenceName(refDialog.WebReference.WebReferencesDirectory, refDialog.WebReference.Name);
refDialog.WebReference.Save();
foreach (ProjectItem item in refDialog.WebReference.Items)
{
ProjectService.AddProjectItem(node.Project, item);
}
AddWebReferenceToProjectBrowser(node, refDialog.WebReference);
// Add proxy to code completion.
ParserService.ParseFile(refDialog.WebReference.WebProxyFileName);
node.Project.Save();
}
}
}
}
private void GetNodesRecursive(List <AbstractProjectBrowserTreeNode> nodes, AbstractProjectBrowserTreeNode node)
{
foreach (var node1 in node.Nodes.OfType <AbstractProjectBrowserTreeNode>())
{
nodes.Add(node1);
GetNodesRecursive(nodes, node1);
}
}
private static void RunStep(AbstractProjectBrowserTreeNode node)
{
if (node.IsDisposed)
{
return;
}
var fileNode = node as FileNode;
TFSStatus status;
if (fileNode != null)
{
status = TFS.GetFileStatus(fileNode.FileName);
}
else
{
var projectNode = node as ProjectNode;
if (projectNode != null)
{
status = TFS.GetFileStatus(projectNode.Project.FileName);
}
else
{
//var directoryNode = node as DirectoryNode;
//if (directoryNode != null)
//{
// status = TFS.GetFileStatus(directoryNode.Directory);
//}
//else
//{
var solNode = node as SolutionNode;
if (solNode != null)
{
status = TFS.GetFileStatus(solNode.Solution.Directory);
}
else
{
return;
}
// }
}
}
SD.MainThread.InvokeAsyncAndForget(delegate
{
Image image = GetImage(status);
if (image != null)
{
node.Overlay = image;
}
else if (node.Overlay != null && (node.Overlay.Tag as Type) == typeof(OverlayIconManager))
{
// reset overlay to null only if the old overlay belongs to the OverlayIconManager
node.Overlay = null;
}
});
}
static void CallbackInvoked()
{
OverlayIconManager.ClearStatusCache();
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
if (node != null)
{
OverlayIconManager.EnqueueRecursive(node);
}
}
Action AfterCommand(string nodeFileName, AbstractProjectBrowserTreeNode node)
{
return delegate {
SD.MainThread.VerifyAccess();
// and then refresh the project browser:
////////// TFSStatusCache.ClearCachedStatus(nodeFileName);
OverlayIconManager.EnqueueRecursive(node);
OverlayIconManager.EnqueueParents(node);
};
}
Action AfterCommand(string nodeFileName, AbstractProjectBrowserTreeNode node)
{
return delegate {
WorkbenchSingleton.AssertMainThread();
// and then refresh the project browser:
GitStatusCache.ClearCachedStatus(nodeFileName);
OverlayIconManager.EnqueueRecursive(node);
OverlayIconManager.EnqueueParents(node);
};
}
Action AfterCommand(string nodeFileName, AbstractProjectBrowserTreeNode node)
{
return(delegate {
WorkbenchSingleton.AssertMainThread();
// and then refresh the project browser:
GitStatusCache.ClearCachedStatus(nodeFileName);
OverlayIconManager.EnqueueRecursive(node);
OverlayIconManager.EnqueueParents(node);
});
}
void UpdateToolStrip(AbstractProjectBrowserTreeNode node)
{
toolStrip.Items.Clear();
toolStrip.Items.AddRange(standardItems);
ToolbarService.UpdateToolbar(toolStrip);
if (node != null && node.ToolbarAddinTreePath != null) {
toolStrip.Items.Add(new ToolStripSeparator());
toolStrip.Items.AddRange((ToolStripItem[])AddInTree.BuildItems(node.ToolbarAddinTreePath, node, false).ToArray(typeof(ToolStripItem)));
}
}
public static FileNode GetFileNode(AbstractProjectBrowserTreeNode parent, string fileName)
{
foreach (AbstractProjectBrowserTreeNode node in parent.Nodes) {
FileNode fileNode = node as FileNode;
if (fileNode != null && fileNode.FileName == fileName) {
return fileNode;
}
}
return null;
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
if (node == null)
{
return;
}
node.ShowProperties();
}
protected override void Execute(string filename, AbstractProjectBrowserTreeNode node, Action callback)
{
try {
TFS.AddFile(filename);
}
catch (Exception ex)
{
TFSMessageView.Log("TFSError: Add: " + ex.Message + " (" + filename + ")");
}
}
void UpdateToolStrip(AbstractProjectBrowserTreeNode node)
{
if (toolStrip == null) return;
toolStrip.Items.Clear();
toolStrip.Items.AddRange(standardItems);
SD.WinForms.ToolbarService.UpdateToolbar(toolStrip);
if (node != null && node.ToolbarAddinTreePath != null) {
toolStrip.Items.Add(new ToolStripSeparator());
toolStrip.Items.AddRange(SD.WinForms.ToolbarService.CreateToolStripItems(node.ToolbarAddinTreePath, node, false));
}
}
XmlDocument LoadAppConfig()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
FileName appConfigFileName = CompilableProject.GetAppConfigFile(node.Project, false);
if (!String.IsNullOrEmpty(appConfigFileName))
{
return(LoadAppConfig(appConfigFileName));
}
return(null);
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
if (node == null)
{
return;
}
node.ActivateItem();
}
public static FileNode GetFileNode(AbstractProjectBrowserTreeNode parent, string fileName)
{
foreach (AbstractProjectBrowserTreeNode node in parent.Nodes)
{
FileNode fileNode = node as FileNode;
if (fileNode != null && fileNode.FileName == fileName)
{
return(fileNode);
}
}
return(null);
}
public static void Enqueue(AbstractProjectBrowserTreeNode node)
{
lock (queue) {
if (inQueue.Add(node)) {
queue.Enqueue(node);
if (!threadRunning) {
threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
if (node == null)
{
return;
}
ProjectBrowserPad.Instance.ProjectBrowserControl.Select();
ProjectBrowserPad.Instance.ProjectBrowserControl.Focus();
ProjectBrowserPad.Instance.StartLabelEdit(node);
}
public static void Enqueue(AbstractProjectBrowserTreeNode node)
{
if (_subversionDisabled)
return;
lock (Queue)
{
Queue.Enqueue(node);
if (!_threadRunning)
{
_threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
public static void Enqueue(AbstractProjectBrowserTreeNode node)
{
lock (queue) {
if (inQueue.Add(node))
{
queue.Enqueue(node);
if (!threadRunning)
{
threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
}
static void RunStep(AbstractProjectBrowserTreeNode node)
{
if (node.IsDisposed)
{
return;
}
FileNode fileNode = node as FileNode;
GitStatus status;
if (fileNode != null)
{
status = GitStatusCache.GetFileStatus(fileNode.FileName);
}
else
{
DirectoryNode directoryNode = node as DirectoryNode;
if (directoryNode != null)
{
status = GitStatusCache.GetFileStatus(directoryNode.Directory);
}
else
{
SolutionNode solNode = node as SolutionNode;
if (solNode != null)
{
status = GitStatusCache.GetFileStatus(solNode.Solution.Directory);
}
else
{
return;
}
}
}
WorkbenchSingleton.SafeThreadAsyncCall(
delegate {
Image image = GetImage(status);
if (image != null)
{
node.Overlay = image;
}
else if (node.Overlay != null && (node.Overlay.Tag as Type) == typeof(GitAddIn.OverlayIconManager))
{
// reset overlay to null only if the old overlay belongs to the OverlayIconManager
node.Overlay = null;
}
});
}
public static void EnqueueParents(AbstractProjectBrowserTreeNode node)
{
lock (queue) {
while (node != null) {
if (inQueue.Add(node))
queue.Enqueue(node);
node = node.Parent as AbstractProjectBrowserTreeNode;
}
if (!threadRunning) {
threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
public static void Enqueue(AbstractProjectBrowserTreeNode node)
{
if (subversionDisabled)
{
return;
}
lock (queue) {
queue.Enqueue(node);
if (!threadRunning)
{
threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedNode;
ISolutionFolderNode solutionFolderNode = node as ISolutionFolderNode;
if (node != null)
{
ISolutionFolder newSolutionFolder = solutionFolderNode.Folder.CreateFolder(ResourceService.GetString("ProjectComponent.NewFolderString"));
solutionFolderNode.Solution.Save();
SolutionFolderNode newSolutionFolderNode = new SolutionFolderNode(newSolutionFolder);
newSolutionFolderNode.InsertSorted(node);
ProjectBrowserPad.Instance.StartLabelEdit(newSolutionFolderNode);
}
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
if (node == null)
{
return;
}
if (node.Project.IsStartable)
{
node.Project.Start(true);
}
else
{
MessageService.ShowError("${res:BackendBindings.ExecutionManager.CantExecuteDLLError}");
}
}
private static void HandleNode(AbstractProjectBrowserTreeNode node)
{
if (node == null)
{
return;
}
var solutionNode = node as SolutionNode;
if (solutionNode != null)
{
GitStatusCache.ClearCachedStatus(solutionNode.Solution.FileName);
OverlayIconManager.EnqueueRecursive(solutionNode);
return;
}
OverlayIconManager.Enqueue(node);
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
if (node == null)
{
return;
}
if (node is FileNode)
{
ExcludeFileNode((FileNode)node);
}
else if (node is DirectoryNode)
{
node.Expanding();
Stack <TreeNode> nodeStack = new Stack <TreeNode>();
nodeStack.Push(node);
while (nodeStack.Count > 0)
{
TreeNode cur = nodeStack.Pop();
if (cur is FileNode)
{
ExcludeFileNode((FileNode)cur);
}
else if (cur is DirectoryNode)
{
ExcludeDirectoryNode((DirectoryNode)cur);
}
foreach (TreeNode childNode in cur.Nodes)
{
if (childNode is ExtTreeNode)
{
((ExtTreeNode)childNode).Expanding();
}
nodeStack.Push(childNode);
}
}
}
ProjectService.SaveSolution();
((AbstractProjectBrowserTreeNode)node.Parent).Refresh();
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.SelectedNode;
Solution solution = ProjectService.OpenSolution;
if (node == null || solution == null)
{
return;
}
if (node.Project.IsStartable)
{
solution.Preferences.StartupProject = node.Project;
}
else
{
MessageService.ShowError("${res:BackendBindings.ExecutionManager.CantExecuteDLLError}");
}
}
public static void EnqueueParents(AbstractProjectBrowserTreeNode node)
{
lock (queue) {
while (node != null)
{
if (inQueue.Add(node))
{
queue.Enqueue(node);
}
node = node.Parent as AbstractProjectBrowserTreeNode;
}
if (!threadRunning)
{
threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
protected override void Execute(string filename, AbstractProjectBrowserTreeNode node, Action callback)
{
try
{
var nodes = new List <AbstractProjectBrowserTreeNode> {
node
};
GetNodesRecursive(nodes, node);
var anythingUpdated = false;
foreach (var treeNode in nodes)
{
var itemPath = TFS.GetFileName(treeNode);
if (string.IsNullOrWhiteSpace(itemPath))
{
continue;
}
var item = TFS.GetTfsItem(itemPath);
if (item == null)
{
continue;
}
GetRequest request = new GetRequest(item.ItemSpec, VersionSpec.Latest);
GetStatus status = item.Workspace.Get(request, GetOptions.None);
if (!status.NoActionNeeded)
{
TFSMessageView.Log(item.Path + " updated.");
}
anythingUpdated = anythingUpdated || !status.NoActionNeeded;
}
if (!anythingUpdated)
{
TFSMessageView.Log("All files are up to date.");
}
}
catch (Exception ex)
{
}
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = Owner as AbstractProjectBrowserTreeNode;
IProject project = (node != null) ? node.Project : ProjectService.CurrentProject;
if (project == null)
{
return;
}
using (SelectMonoReferenceDialog selDialog = new SelectMonoReferenceDialog(project)) {
if (selDialog.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainWin32Window) == DialogResult.OK)
{
foreach (ReferenceProjectItem reference in selDialog.ReferenceInformations)
{
ProjectService.AddProjectItem(project, reference);
}
project.Save();
}
}
}
public override void Run()
{
AbstractProjectBrowserTreeNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedNode;
ISolutionFolderNode solutionFolderNode = node as ISolutionFolderNode;
if (node != null)
{
using (NewProjectDialog npdlg = new NewProjectDialog(false)) {
npdlg.InitialProjectLocationDirectory = GetInitialDirectorySuggestion(solutionFolderNode);
// show the dialog to request project type and name
if (npdlg.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainForm) == DialogResult.OK)
{
if (npdlg.NewProjectLocation.Length == 0)
{
MessageService.ShowError("No project has been created, there is nothing to add.");
return;
}
AddExitingProjectToSolution.AddProject(solutionFolderNode, npdlg.NewProjectLocation);
ProjectService.SaveSolution();
if (SDLite.UpdateInfo.ExpandNewProjectByDefaut)
{
IWorkbenchWindow window = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow;
if (window != null && window.ActiveViewContent != null)
{
ProjectBrowserPad.Instance.ProjectBrowserControl.SelectFile(window.ActiveViewContent.PrimaryFileName);
}
node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedNode;
if (node is ProjectNode)
{
node.Expand();
}
}
}
}
}
}
void AddWebReferenceToProjectBrowser(AbstractProjectBrowserTreeNode node, WebReference webReference)
{
TreeNode webReferencesNode = null;
if (node is ProjectNode) {
webReferencesNode = AddWebReferenceToProjectNode((ProjectNode)node, webReference);
} else if (node is WebReferencesFolderNode) {
webReferencesNode = node;
WebReferenceNodeBuilder.AddWebReference((WebReferencesFolderNode)webReferencesNode, webReference);
} else if (node is ReferenceFolder && node.Parent != null && node.Parent is ProjectNode) {
webReferencesNode = AddWebReferenceToProjectNode((ProjectNode)node.Parent, webReference);
} else {
LoggingService.Warn("AddWebReferenceToProjectBrowser: Selected node type is not handled.");
AddWebReferenceToProjectBrowser(node.Parent as AbstractProjectBrowserTreeNode, webReference);
}
if (webReferencesNode != null) {
ProjectBrowserPad.Instance.ProjectBrowserControl.TreeView.Sort();
webReferencesNode.Expand();
webReferencesNode.EnsureVisible();
}
}
public object Visit(AbstractProjectBrowserTreeNode abstractProjectBrowserTreeNode, object data)
{
LoggingService.Warn("Warning visited default Visit() for : " + abstractProjectBrowserTreeNode);
abstractProjectBrowserTreeNode.AcceptChildren(this, data);
return data;
}
static void RunStep(AbstractProjectBrowserTreeNode node)
{
if (node.IsDisposed) return;
FileNode fileNode = node as FileNode;
StatusKind status;
if (fileNode != null) {
status = GetStatus(fileNode.FileName);
} else {
DirectoryNode directoryNode = node as DirectoryNode;
if (directoryNode != null) {
status = GetStatus(directoryNode.Directory);
} else {
SolutionNode solNode = node as SolutionNode;
if (solNode != null) {
status = GetStatus(solNode.Solution.Directory);
} else {
return;
}
}
}
SharpDevelop.Gui.WorkbenchSingleton.SafeThreadAsyncCall(
delegate {
node.Overlay = GetImage(status);
});
}
private static void RunStep(AbstractProjectBrowserTreeNode node)
{
if (node.IsDisposed)
{
return;
}
var statusKind = node.GetNodeStatus();
if (!statusKind.HasValue)
{
return;
}
WorkbenchSingleton.SafeThreadAsyncCall(() => node.Overlay = GetImage(statusKind.Value));
}
static void RunStep(AbstractProjectBrowserTreeNode node)
{
if (node.IsDisposed) return;
FileNode fileNode = node as FileNode;
GitStatus status;
if (fileNode != null) {
status = GitStatusCache.GetFileStatus(fileNode.FileName);
} else {
DirectoryNode directoryNode = node as DirectoryNode;
if (directoryNode != null) {
status = GitStatusCache.GetFileStatus(directoryNode.Directory);
} else {
SolutionNode solNode = node as SolutionNode;
if (solNode != null) {
status = GitStatusCache.GetFileStatus(solNode.Solution.Directory);
} else {
return;
}
}
}
SD.MainThread.InvokeAsyncAndForget(delegate {
Image image = GetImage(status);
if (image != null) {
node.Overlay = image;
} else
if (node.Overlay != null && (node.Overlay.Tag as Type) == typeof(GitAddIn.OverlayIconManager)) {
// reset overlay to null only if the old overlay belongs to the OverlayIconManager
node.Overlay = null;
}
});
}
private static void RunStep(AbstractProjectBrowserTreeNode node)
{
var status = node?.GetNodeStatus();
if (!status.HasValue)
{
return;
}
WorkbenchSingleton.SafeThreadAsyncCall(
() =>
{
var image = GetImage(status.Value);
if (image != null)
{
node.Overlay = image;
}
else if (node.Overlay != null && (node.Overlay.Tag as Type) == typeof(OverlayIconManager))
{
// reset overlay to null only if the old overlay belongs to the OverlayIconManager
node.Overlay = null;
}
});
}
public static void EnqueueRecursive(AbstractProjectBrowserTreeNode node)
{
if (_subversionDisabled)
return;
lock (Queue)
{
Queue.Enqueue(node);
// use breadth-first search
var q = new Queue<AbstractProjectBrowserTreeNode>();
q.Enqueue(node);
while (q.Count > 0)
{
node = q.Dequeue();
foreach (TreeNode n in node.Nodes)
{
node = n as AbstractProjectBrowserTreeNode;
if (node != null)
{
q.Enqueue(node);
Queue.Enqueue(node);
}
}
}
if (!_threadRunning)
{
_threadRunning = true;
ThreadPool.QueueUserWorkItem(Run);
}
}
}
static void RunStep(AbstractProjectBrowserTreeNode node)
{
if (node.IsDisposed) return;
FileNode fileNode = node as FileNode;
StatusKind status;
if (fileNode != null) {
status = GetStatus(fileNode.FileName);
} else {
DirectoryNode directoryNode = node as DirectoryNode;
if (directoryNode != null) {
status = GetStatus(directoryNode.Directory);
} else {
SolutionNode solNode = node as SolutionNode;
if (solNode != null) {
status = GetStatus(solNode.Solution.Directory);
} else {
return;
}
}
}
SD.MainThread.InvokeAsyncAndForget(delegate {
node.Overlay = GetImage(status);
});
}
