internal static void PopulateOpenWithViewers(CommandArrayInfo info, Project project, string filePath)
{
var viewers = DisplayBindingService.GetFileViewers(filePath, project).ToList();
//show the default viewer first
var def = viewers.FirstOrDefault(v => v.CanUseAsDefault) ?? viewers.FirstOrDefault(v => v.IsExternal);
if (def != null)
{
CommandInfo ci = info.Add(def.Title, def);
ci.Description = GettextCatalog.GetString("Open with '{0}'", def.Title);
if (viewers.Count > 1)
{
info.AddSeparator();
}
}
//then the builtins, followed by externals
FileViewer prev = null;
foreach (FileViewer fv in viewers)
{
if (def != null && fv.Equals(def))
{
continue;
}
if (prev != null && fv.IsExternal != prev.IsExternal)
{
info.AddSeparator();
}
CommandInfo ci = info.Add(fv.Title, fv);
ci.Description = GettextCatalog.GetString("Open with '{0}'", fv.Title);
prev = fv;
}
}
public static void GenerateExecutionModeCommands(SolutionEntityItem project, CanExecuteDelegate runCheckDelegate, CommandArrayInfo info)
{
CommandExecutionContext ctx = new CommandExecutionContext(project, runCheckDelegate);
bool supportsParameterization = false;
foreach (List <IExecutionMode> modes in GetExecutionModeCommands(ctx, false, true))
{
foreach (IExecutionMode mode in modes)
{
CommandInfo ci = info.Add(mode.Name, new CommandItem(ctx, mode));
if ((mode.ExecutionHandler is ParameterizedExecutionHandler) || ((mode is CustomExecutionMode) && ((CustomExecutionMode)mode).PromptForParameters))
{
// It will prompt parameters, so we need command to end with '..'.
// However, some commands may end with '...' already and we don't want to break
// already-translated strings by altering them
if (!ci.Text.EndsWith("..."))
{
ci.Text += "...";
}
supportsParameterization = true;
}
else
{
// The parameters window will be shown if ctrl is pressed
ci.Description = GettextCatalog.GetString("Run With: {0}", ci.Text);
if (SupportsParameterization(mode, ctx))
{
ci.Description += " - " + GettextCatalog.GetString("Hold Control key to display the execution parameters dialog.");
supportsParameterization = true;
}
}
}
if (info.Count > 0)
{
info.AddSeparator();
}
}
var targets = new List <ExecutionTarget> ();
FlattenExecutionTargets(targets, project.GetExecutionTargets(IdeApp.Workspace.ActiveConfiguration));
if (targets.Count > 1)
{
foreach (var t in targets)
{
var h = new TargetedExecutionHandler(Runtime.ProcessService.DefaultExecutionHandler, t);
CommandInfo ci = info.Add(t.FullName, new CommandItem(ctx, new ExecutionMode(t.Id, t.FullName, h)));
ci.Description = GettextCatalog.GetString("Run With: {0}", ci.Text);
}
info.AddSeparator();
}
if (supportsParameterization)
{
info.AddSeparator();
info.Add(GettextCatalog.GetString("Edit Custom Modes..."), new CommandItem(ctx, null));
}
}
protected override void Update(CommandArrayInfo ainfo)
{
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument;
if (doc != null)
{
SourceEditorView view = IdeApp.Workbench.ActiveDocument.GetContent <SourceEditorView>();
if (view != null)
{
DocumentLocation location = view.TextEditor.Caret.Location;
if (location.IsEmpty)
{
return;
}
DocumentLine line = view.Document.GetLine(location.Line);
if (line == null || line.Markers == null)
{
return;
}
foreach (TextLineMarker marker in line.Markers)
{
UrlMarker urlMarker = marker as UrlMarker;
if (urlMarker != null)
{
if (urlMarker.StartColumn <= location.Column && location.Column < urlMarker.EndColumn)
{
ainfo.Add(urlMarker.UrlType == UrlType.Email ? GettextCatalog.GetString("_Write an e-mail to...") : GettextCatalog.GetString("_Open URL..."), urlMarker);
ainfo.AddSeparator();
}
}
}
}
}
}
void AddItem(CommandArrayInfo cis, CodeFixMenuEntry item)
{
if (item == CodeFixMenuEntry.Separator)
{
if (cis.Count == 0)
{
return;
}
cis.AddSeparator();
}
else if (item is CodeFixMenu)
{
var menu = (CodeFixMenu)item;
var submenu = new CommandInfoSet {
Text = menu.Label
};
foreach (var subItem in menu.Items)
{
AddItem(submenu.CommandInfos, subItem);
}
cis.Add(submenu, item.Action);
}
else
{
var info = new CommandInfo(item.Label);
info.Enabled = item.Action != null;
cis.Add(info, item.Action);
}
}
public void OnSetBuildActionUpdate (CommandArrayInfo info)
{
Set<string> toggledActions = new Set<string> ();
Project proj = null;
foreach (ITreeNavigator node in CurrentNodes) {
ProjectFile finfo = (ProjectFile) node.DataItem;
//disallow multi-slect on more than one project, since available build actions may differ
if (proj == null && finfo.Project != null) {
proj = finfo.Project;
} else if (proj == null || proj != finfo.Project) {
info.Clear ();
return;
}
toggledActions.Add (finfo.BuildAction);
}
foreach (string action in proj.GetBuildActions ()) {
if (action == "--") {
info.AddSeparator ();
} else {
CommandInfo ci = info.Add (action, action);
ci.Checked = toggledActions.Contains (action);
if (ci.Checked)
ci.CheckedInconsistent = toggledActions.Count > 1;
}
}
}
protected override void Update(CommandArrayInfo info)
{
ResolverContextStack ctxt;
var rr = Resolver.DResolverWrapper.ResolveHoveredCode(out ctxt);
bool noRes = true;
if (rr != null && rr.Length > 0)
{
res = rr[rr.Length - 1];
n = DResolver.GetResultMember(res);
if (n != null)
{
noRes = false;
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.GotoDeclaration), new Action(GotoDeclaration));
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindReferences), new Action(FindReferences));
if (RenamingRefactoring.CanRename(n))
{
info.AddSeparator();
info.Add(IdeApp.CommandService.GetCommandInfo(EditCommands.Rename), new Action(RenameSymbol));
}
}
}
if (noRes)
{
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.ImportSymbol), new Action(ImportSymbol));
}
info.Add(IdeApp.CommandService.GetCommandInfo(Commands.OpenDDocumentation), new Action(OpenDDoc));
}
protected void OnUpdateInsertOption(CommandArrayInfo info)
{
foreach (string[] op in options)
{
if (op [0] == "-")
{
info.AddSeparator();
}
else
{
info.Add(op [0], op [1]);
}
}
}
public void OnOpenWithUpdate(CommandArrayInfo info)
{
SystemFile file = CurrentNode.DataItem as SystemFile;
FileViewer prev = null;
foreach (FileViewer fv in IdeApp.Workbench.GetFileViewers(file.Path))
{
if (prev != null && fv.IsExternal != prev.IsExternal)
{
info.AddSeparator();
}
info.Add(fv.Title, fv);
prev = fv;
}
}
public void OnOpenWithUpdate(CommandArrayInfo info)
{
ProjectFile finfo = (ProjectFile)CurrentNode.DataItem;
FileViewer prev = null;
foreach (FileViewer fv in IdeApp.Workbench.GetFileViewers(finfo.Name))
{
if (prev != null && fv.IsExternal != prev.IsExternal)
{
info.AddSeparator();
}
CommandInfo ci = info.Add(fv.Title, fv);
ci.Description = GettextCatalog.GetString("Open with '{0}'", fv.Title);
prev = fv;
}
}
protected override void Update(CommandArrayInfo info)
{
foreach (ExternalTools.ExternalTool externalTool in ExternalTools.ExternalToolService.Tools)
{
//Create CommandInfo object
CommandInfo commandInfo = new CommandInfo();
commandInfo.Text = externalTool.MenuCommand;
commandInfo.Description = GettextCatalog.GetString("Start tool") + " " + string.Join(string.Empty, externalTool.MenuCommand.Split('&'));
//Add menu item
info.Add(commandInfo, externalTool);
}
if (info.Count > 0)
{
info.AddSeparator();
}
}
protected override void Update(CommandArrayInfo ainfo)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.FileName == FilePath.Null)
{
return;
}
var parsedDocument = doc.ParsedDocument;
if (parsedDocument == null || parsedDocument.IsInvalid)
{
return;
}
ResolveResult resolveResult;
object item = GetItem(doc, out resolveResult);
bool added = false;
var options = new RefactoringOptions(doc)
{
ResolveResult = resolveResult,
SelectedItem = item
};
var ciset = new CommandInfoSet();
ciset.Text = GettextCatalog.GetString("Refactor");
bool canRename;
if (item is IVariable || item is IParameter)
{
canRename = true;
}
else if (item is ITypeDefinition)
{
canRename = !((ITypeDefinition)item).Region.IsEmpty;
}
else if (item is IType)
{
canRename = ((IType)item).Kind == TypeKind.TypeParameter;
}
else if (item is IMember)
{
canRename = !((IMember)item).Region.IsEmpty;
}
else if (item is INamespace)
{
canRename = true;
}
else
{
canRename = false;
}
if (canRename)
{
ciset.CommandInfos.Add(IdeApp.CommandService.GetCommandInfo(MonoDevelop.Ide.Commands.EditCommands.Rename), new Action(delegate {
new MonoDevelop.Refactoring.Rename.RenameHandler().Start(null);
}));
added = true;
}
foreach (var refactoring in RefactoringService.Refactorings)
{
if (refactoring.IsValid(options))
{
CommandInfo info = new CommandInfo(refactoring.GetMenuDescription(options));
info.AccelKey = refactoring.AccelKey;
ciset.CommandInfos.Add(info, new Action(new RefactoringOperationWrapper(refactoring, options).Operation));
}
}
var refactoringInfo = doc.Annotation <RefactoringDocumentInfo> ();
if (refactoringInfo == null)
{
refactoringInfo = new RefactoringDocumentInfo();
doc.AddAnnotation(refactoringInfo);
}
var loc = doc.Editor.Caret.Location;
bool first = true;
if (refactoringInfo.lastDocument != doc.ParsedDocument || loc != lastLocation)
{
if (QuickTaskStrip.EnableFancyFeatures)
{
var ext = doc.GetContent <CodeActionEditorExtension> ();
refactoringInfo.validActions = ext != null?ext.GetCurrentFixes() : null;
}
else
{
refactoringInfo.validActions = RefactoringService.GetValidActions(doc, loc).Result;
}
lastLocation = loc;
refactoringInfo.lastDocument = doc.ParsedDocument;
}
if (refactoringInfo.validActions != null && refactoringInfo.lastDocument != null && refactoringInfo.lastDocument.CreateRefactoringContext != null)
{
var context = refactoringInfo.lastDocument.CreateRefactoringContext(doc, CancellationToken.None);
foreach (var fix_ in refactoringInfo.validActions.OrderByDescending(i => Tuple.Create(CodeActionEditorExtension.IsAnalysisOrErrorFix(i), (int)i.Severity, CodeActionEditorExtension.GetUsage(i.IdString))))
{
if (CodeActionEditorExtension.IsAnalysisOrErrorFix(fix_))
{
continue;
}
var fix = fix_;
if (first)
{
first = false;
if (ciset.CommandInfos.Count > 0)
{
ciset.CommandInfos.AddSeparator();
}
}
ciset.CommandInfos.Add(fix.Title, new Action(() => RefactoringService.ApplyFix(fix, context)));
}
}
if (ciset.CommandInfos.Count > 0)
{
ainfo.Add(ciset, null);
added = true;
}
if (IdeApp.ProjectOperations.CanJumpToDeclaration(item))
{
var type = item as IType;
if (type != null && type.GetDefinition().Parts.Count > 1)
{
var declSet = new CommandInfoSet();
declSet.Text = GettextCatalog.GetString("_Go to Declaration");
var ct = type.GetDefinition();
foreach (var part in ct.Parts)
{
declSet.CommandInfos.Add(string.Format(GettextCatalog.GetString("{0}, Line {1}"), FormatFileName(part.Region.FileName), part.Region.BeginLine), new System.Action(new JumpTo(part).Run));
}
ainfo.Add(declSet);
}
else
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.GotoDeclaration), new System.Action(new JumpTo(item).Run));
}
added = true;
}
if (item is IMember)
{
var member = (IMember)item;
if (member.IsOverride || member.ImplementedInterfaceMembers.Any())
{
ainfo.Add(GettextCatalog.GetString("Go to _Base Symbol"), new System.Action(new GotoBase(member).Run));
added = true;
}
}
if (!(item is IMethod && ((IMethod)item).SymbolKind == SymbolKind.Operator) && (item is IEntity || item is ITypeParameter || item is IVariable || item is INamespace))
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindReferences), new System.Action(new FindRefs(item, false).Run));
if (doc.HasProject && HasOverloads(doc.Project.ParentSolution, item))
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindAllReferences), new System.Action(new FindRefs(item, true).Run));
}
added = true;
}
if (item is IMember)
{
var member = (IMember)item;
if (member.IsVirtual || member.IsAbstract || member.DeclaringType.Kind == TypeKind.Interface)
{
var handler = new FindDerivedSymbolsHandler(doc, member);
if (handler.IsValid)
{
ainfo.Add(GettextCatalog.GetString("Find Derived Symbols"), new System.Action(handler.Run));
added = true;
}
}
}
if (item is IMember)
{
var member = (IMember)item;
if (member.SymbolKind == SymbolKind.Method || member.SymbolKind == SymbolKind.Indexer)
{
var findMemberOverloadsHandler = new FindMemberOverloadsHandler(doc, member);
if (findMemberOverloadsHandler.IsValid)
{
ainfo.Add(GettextCatalog.GetString("Find Member Overloads"), new System.Action(findMemberOverloadsHandler.Run));
added = true;
}
}
}
if (item is ITypeDefinition)
{
ITypeDefinition cls = (ITypeDefinition)item;
foreach (var bc in cls.DirectBaseTypes)
{
if (bc != null && bc.GetDefinition() != null && bc.GetDefinition().Kind != TypeKind.Interface /* TODO: && IdeApp.ProjectOperations.CanJumpToDeclaration (bc)*/)
{
ainfo.Add(GettextCatalog.GetString("Go to _Base"), new System.Action(new GotoBase((ITypeDefinition)item).Run));
break;
}
}
if ((cls.Kind == TypeKind.Class && !cls.IsSealed) || cls.Kind == TypeKind.Interface)
{
ainfo.Add(cls.Kind != TypeKind.Interface ? GettextCatalog.GetString("Find _derived classes") : GettextCatalog.GetString("Find _implementor classes"), new System.Action(new FindDerivedClasses(cls).Run));
}
ainfo.Add(GettextCatalog.GetString("Find Extension Methods"), new System.Action(new FindExtensionMethodHandler(doc, cls).Run));
added = true;
}
if (added)
{
ainfo.AddSeparator();
}
}
