public override void OnUpdate(CommandUpdateEventArgs e)
{
int n = 0;
foreach (ISvnRepositoryItem i in e.Selection.GetSelection <ISvnRepositoryItem>())
{
n++;
if (n > 1 || i.Origin == null)
{
e.Enabled = false;
return;
}
}
if (n == 1)
{
return;
}
foreach (SvnItem item in e.Selection.GetSelectedSvnItems(false))
{
n++;
if (n > 1 || item.Uri == null)
{
e.Enabled = false;
return;
}
}
if (n != 1)
{
e.Enabled = false;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
if (_ctrl == null)
{
_ctrl = e.GetService <LogToolWindowControl>();
}
if (_ctrl == null)
{
e.Enabled = e.Visible = false;
return;
}
IList <SvnOrigin> origins = _ctrl.Origins;
if (origins == null || origins.Count == 0)
{
e.Enabled = e.Visible = false;
return;
}
// Enable something like this?
/*if (e.Command == AnkhCommand.SvnLogComboBox
* && origins.Count == 1)
* {
* e.Enabled = false;
* }*/
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
int n = 0;
foreach (ISvnRepositoryItem i in e.Selection.GetSelection<ISvnRepositoryItem>())
{
n++;
if (n > 1 || i.Origin == null)
{
e.Enabled = false;
return;
}
}
if (n == 1)
return;
foreach(SvnItem item in e.Selection.GetSelectedSvnItems(false))
{
n++;
if(n > 1 || item.Uri == null)
{
e.Enabled = false;
return;
}
}
if (n != 1)
e.Enabled = false;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
ISvnRepositoryItem reposItem = EnumTools.GetSingle(e.Selection.GetSelection <ISvnRepositoryItem>());
if (reposItem != null)
{
if (reposItem.Origin != null && reposItem.NodeKind != SharpSvn.SvnNodeKind.Directory &&
reposItem.Revision.RevisionType == SharpSvn.SvnRevisionType.Number)
{
if (e.Command == AnkhCommand.RepositoryCompareWithWc)
{
if (!(reposItem.Origin.Target is SvnPathTarget))
{
e.Enabled = false;
return;
}
}
return;
}
else if (e.Command == AnkhCommand.RepositoryCompareWithWc &&
reposItem.Revision == SvnRevision.Working)
{
return;
}
}
e.Enabled = false;
}
public void OnUpdate(CommandUpdateEventArgs e)
{
if (null == EnumTools.GetSingle(e.Selection.GetSelection <ISvnLogItem>()))
{
e.Enabled = false;
}
}
void CommandLoaderOnCommandsUpdated(object sender, CommandUpdateEventArgs <ICommand> e)
{
var workingDict = m_CommandDict.Values.ToDictionary(c => c.Name, StringComparer.OrdinalIgnoreCase);
var updatedCommands = 0;
foreach (var c in e.Commands)
{
if (c == null)
{
continue;
}
var castedCommand = c.Command as ICommand <TAppSession, TRequestInfo>;
if (castedCommand == null)
{
if (Logger.IsErrorEnabled)
{
Logger.Error("Invalid command has been found! Command name: " + c.Command.Name);
}
continue;
}
if (c.UpdateAction == CommandUpdateAction.Remove)
{
workingDict.Remove(castedCommand.Name);
if (Logger.IsInfoEnabled)
{
Logger.InfoFormat("The command '{0}' has been removed from this server!", c.Command.Name);
}
}
else if (c.UpdateAction == CommandUpdateAction.Add)
{
workingDict.Add(castedCommand.Name, castedCommand);
if (Logger.IsInfoEnabled)
{
Logger.InfoFormat("The command '{0}' has been added into this server!", c.Command.Name);
}
}
else
{
workingDict[c.Command.Name] = castedCommand;
if (Logger.IsInfoEnabled)
{
Logger.InfoFormat("The command '{0}' has been updated!", c.Command.Name);
}
}
updatedCommands++;
}
if (updatedCommands > 0)
{
var commandFilters = CommandFilterFactory.GenerateCommandFilterLibrary(this.GetType(), workingDict.Values.Cast <ICommand>());
Interlocked.Exchange(ref m_CommandDict, workingDict);
Interlocked.Exchange(ref m_CommandFilterDict, commandFilters);
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
if (ProjectRootUri == null)
{
e.Enabled = false;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
foreach (SccProject p in e.Selection.GetSelectedProjects(false))
{
ISccProjectInfo pi = e.GetService <IProjectFileMapper>().GetProjectInfo(p);
if (p == null || pi == null || string.IsNullOrEmpty(pi.ProjectFile))
{
break; // No project file
}
if (!string.IsNullOrEmpty(pi.ProjectDirectory) &&
string.Equals(pi.ProjectDirectory, pi.ProjectFile, StringComparison.OrdinalIgnoreCase))
{
break; // Project file is directory
}
SvnItem item = e.GetService <ISvnStatusCache>()[pi.ProjectFile];
if (item != null && item.IsDirectory)
{
break; // Project file is not file
}
return; // Show the menu
}
e.Enabled = e.Visible = false;
}
public void OnUpdate(CommandUpdateEventArgs e)
{
if (EnumTools.IsEmpty(e.Selection.GetSelection <ISvnLogItem>()))
{
e.Enabled = false;
}
}
protected override void OnUpdate(SmartListView list, CommandUpdateEventArgs e)
{
int n = (int)(e.Command - AnkhCommand.ListViewSort0);
if (n >= list.AllColumns.Count || n < 0)
{
e.Text = "";
e.DynamicMenuEnd = true;
return;
}
SmartColumn column = list.AllColumns[n];
if (e.TextQueryType == TextQueryType.Name)
{
e.Text = column.MenuText;
}
if (!column.Sortable)
{
e.Enabled = false;
}
e.Checked = list.SortColumns.Contains(column);
}
bool UpdateForChangedFiles(CommandUpdateEventArgs e)
{
ISvnLogChangedPathItem change = EnumTools.GetSingle(e.Selection.GetSelection <ISvnLogChangedPathItem>());
if (change == null)
{
return(false);
}
// Skip all the files we cannot diff
switch (change.Action)
{
case SvnChangeAction.Add:
if (change.CopyFromRevision >= 0)
{
break; // We can retrieve this file using CopyFromPath
}
e.Enabled = false;
break;
case SvnChangeAction.Delete:
e.Enabled = false;
break;
}
if (change.NodeKind == SvnNodeKind.Directory)
{
e.Enabled = false;
}
return(true);
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
if (null == EnumTools.GetFirst(e.Selection.GetSelectedFiles(true)))
{
e.Enabled = false;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
if (_control == null)
{
_control = e.GetService <SvnInfoGridControl>();
if (_control == null)
{
e.Enabled = false;
return;
}
}
PropertySort sort = _control.Grid.PropertySort;
bool categorized = (PropertySort.NoSort != (sort & PropertySort.Categorized));
if (e.Command == AnkhCommand.SvnInfoAlphabetical)
{
e.Checked = !categorized;
}
else
{
e.Checked = categorized;
}
}
private void OnUpdateCopy(object sender, CommandUpdateEventArgs e)
{
if (SelectedIndices.Count == 0)
{
e.Enabled = false;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
if (!e.State.SolutionExists || !e.State.SccProviderActive)
{
e.Enabled = false;
return;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
e.Enabled = false;
if (PendingChangesToolControl.ShownVertically)
{
e.Visible = false;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
ISvnLogItem item = EnumTools.GetSingle(e.Selection.GetSelection <ISvnLogItem>());
if (item == null || EnumTools.IsEmpty(item.Issues))
{
e.Enabled = false;
}
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
SvnItem i = EnumTools.GetSingle(e.Selection.GetSelectedSvnItems(false));
if (i == null || !i.IsVersioned)
{
e.Enabled = false;
}
}
void OnUpdateOpen(object sender, CommandUpdateEventArgs e)
{
SvnItem item = EnumTools.GetSingle(e.Selection.GetSelectedSvnItems(false));
if (item == null)
{
e.Enabled = false;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
TextMarker im;
if (!TryGetMarker(e, (e.Command == AnkhCommand.PcLogEditorOpenIssue), out im))
{
e.Enabled = false;
}
}
void OnUpdateUp(object sender, CommandUpdateEventArgs e)
{
if (treeView.SelectedNode == null ||
treeView.Nodes.Count == 0 ||
treeView.SelectedNode == treeView.Nodes[0])
{
e.Enabled = false;
}
}
void OnUpdateOpen(object sender, CommandUpdateEventArgs e)
{
RepositoryExplorerItem item = EnumTools.GetSingle(e.Selection.GetSelection <RepositoryExplorerItem>());
if (item == null || item.Uri == null)
{
e.Enabled = false;
}
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
ISvnRepositoryItem single = EnumTools.GetSingle(e.Selection.GetSelection <ISvnRepositoryItem>());
if (single == null || single.NodeKind == SvnNodeKind.File || single.Origin == null)
{
e.Enabled = false;
}
}
private void OnUpdateOpenFolder(object sender, CommandUpdateEventArgs e)
{
SvnItem one = EnumTools.GetSingle(e.Selection.GetSelectedSvnItems(false));
if (one == null || !one.Exists)
{
e.Enabled = false;
}
}
void OnUpdateUp(object sender, CommandUpdateEventArgs e)
{
FileSystemTreeNode tn = folderTree.SelectedNode as FileSystemTreeNode;
if (tn == null || !(tn.Parent is FileSystemTreeNode))
{
e.Enabled = false;
}
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
foreach (ISvnRepositoryItem it in e.Selection.GetSelection<ISvnRepositoryItem>())
{
if (it.Origin != null)
return;
}
e.Enabled = false;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
ISvnRepositoryItem item = EnumTools.GetSingle(e.Selection.GetSelection <ISvnRepositoryItem>());
if (item != null && item.Origin != null && !item.Origin.IsRepositoryRoot)
{
return;
}
e.Enabled = false;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
bool enabled = false;
RepositoryExplorerControl ctrl = e.Selection.ActiveDialogOrFrameControl as RepositoryExplorerControl;
if (ctrl != null)
{
Uri uri = ctrl.SelectedUri;
enabled = uri != null;
}
e.Enabled = enabled;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
ISvnRepositoryItem item = EnumTools.GetSingle(e.Selection.GetSelection <ISvnRepositoryItem>());
if (item == null ||
item.Origin == null ||
item.Origin.Target.Revision != SvnRevision.Head ||
item.NodeKind == SvnNodeKind.File)
{
e.Enabled = false;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
PendingCommitsPage page = e.Context.GetService <PendingCommitsPage>();
if (page == null || !page.Visible || e.Selection.ActiveDialog != null)
{
e.Enabled = false;
return;
}
e.Checked = page.LogMessageVisible;
}
public void OnUpdate(CommandUpdateEventArgs e)
{
IAnkhIssueService service = null;
SvnItem item = null;
e.Enabled = true &&
(item = GetRoot(e)) != null &&
item.IsVersioned && // ensure solution (project root) is versioned
(service = e.GetService <IAnkhIssueService>()) != null &&
service.Connectors != null &&
service.Connectors.Count > 0;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
ISvnRepositoryItem item = EnumTools.GetSingle(e.Selection.GetSelection<ISvnRepositoryItem>());
if (item == null
|| item.Origin == null
|| item.Origin.Target.Revision != SvnRevision.Head
|| item.NodeKind == SvnNodeKind.File)
{
e.Enabled = false;
}
}
public void OnUpdate(CommandUpdateEventArgs e)
{
bool enabled = false;
RepositoryExplorerControl ctrl = e.Selection.ActiveDialogOrFrameControl as RepositoryExplorerControl;
if (ctrl != null)
{
Uri uri = ctrl.SelectedUri;
enabled = uri != null;
}
e.Enabled = enabled;
}
public virtual void OnUpdate(CommandUpdateEventArgs e)
{
SmartListView list = GetListView(e);
if (list == null)
{
e.Enabled = false;
return;
}
OnUpdate(list, e);
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
ISvnRepositoryItem reposItem = EnumTools.GetSingle(e.Selection.GetSelection<ISvnRepositoryItem>());
if (reposItem != null && reposItem.Origin != null && reposItem.NodeKind != SharpSvn.SvnNodeKind.Directory
&& reposItem.Revision.RevisionType == SharpSvn.SvnRevisionType.Number)
{
if (e.Command == AnkhCommand.RepositoryCompareWithWc)
{
if (!(reposItem.Origin.Target is SvnPathTarget))
{
e.Enabled = false;
return;
}
}
return;
}
e.Enabled = false;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
bool foundOne = false;
bool ok = true;
Uri reposRoot = null;
foreach (ISvnRepositoryItem item in e.Selection.GetSelection<ISvnRepositoryItem>())
{
if (item.Origin == null || item.Origin.IsRepositoryRoot)
{
ok = false;
break;
}
else if (e.Command == AnkhCommand.ReposMoveTo && item.Origin.Target.Revision != SvnRevision.Head)
{
ok = false;
break;
}
if(reposRoot == null)
reposRoot = item.Origin.RepositoryRoot;
else if(item.Origin.RepositoryRoot != reposRoot)
{
ok = false;
break;
}
foundOne = true;
}
if(!ok || !foundOne)
{
e.Enabled = false;
}
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
ISvnRepositoryItem item = EnumTools.GetSingle(e.Selection.GetSelection<ISvnRepositoryItem>());
if (item != null && item.Origin != null && !item.Origin.IsRepositoryRoot)
return;
e.Enabled = false;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
foreach (ISvnRepositoryItem i in e.Selection.GetSelection<ISvnRepositoryItem>())
{
if (i.Origin == null || i.Origin.Target.Revision != SvnRevision.Head || i.Origin.IsRepositoryRoot)
break;
return;
}
e.Enabled = false;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
base.OnUpdate(e);
ISvnRepositoryItem item = EnumTools.GetSingle(e.Selection.GetSelection<ISvnRepositoryItem>());
if (item != null && item.Origin != null)
{
if (item.Origin.Target.Revision == SvnRevision.Head
&& !item.Origin.IsRepositoryRoot)
{
return;
}
}
e.Enabled = false;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
IGitRepositoryItem reposItem = EnumTools.GetSingle(e.Selection.GetSelection<IGitRepositoryItem>());
if (reposItem != null && reposItem.Origin != null && reposItem.NodeKind != GitNodeKind.Directory
&& reposItem.Revision.RevisionType == GitRevisionType.Hash)
{
return;
}
e.Enabled = false;
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
base.OnUpdate(e);
if (e.Enabled && e.Command == AnkhCommand.ViewInVsNet)
{
ISvnRepositoryItem single = EnumTools.GetSingle(e.Selection.GetSelection<ISvnRepositoryItem>());
IAnkhSolutionSettings settings = e.GetService<IAnkhSolutionSettings>();
SvnOrigin origin = single.Origin; // Checked in parent
string ext = Path.GetExtension(origin.Target.FileName);
if (!string.IsNullOrEmpty(ext) && settings.OpenFileFilter.IndexOf("*" + ext, StringComparison.OrdinalIgnoreCase) < 0)
e.Enabled = false;
}
}
public override void OnUpdate(CommandUpdateEventArgs e)
{
// Always available
}
