protected bool VimAddinIsEnabled()
{
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument;
if (doc != null && doc.GetContent <ITextEditorDataProvider> () != null)
{
var editorView = doc.GetContent <SourceEditorView> ();
var textEditor = editorView.TextEditor;
return(textEditor.CurrentMode.GetType() == typeof(VimAddin.IdeViMode));
}
return(false);
}
protected override void Run()
{
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument;
//
var textEditorData = doc.GetContent <ITextEditorDataProvider> ().GetTextEditorData();
// var editorView = doc.GetContent<SourceEditorView> ();
//// if (textEditorData.GetType () == typeof(TextEditorData)) {
//// Console.WriteLine ("textEditorData is the expected type");
//// }
//
// var textEditor = editorView.TextEditor;
//// textEditor.CurrentMode.InternalHandleKeypress (textEditor, textEditorData,
//// Gdk.Key.f,
//// (char)'f',
//// Gdk.ModifierType.ControlMask);
var vimEditor = (VimAddin.IdeViMode)textEditorData.CurrentMode;
// if (vimEditor.HasTextEditorData ()) {
// Console.WriteLine ("Has textEditorData");
// } else {
// Console.WriteLine ("Has no textEditorData");
// }
// if (vimEditor.HasData ()) {
// vimEditor.SendKeys (Gdk.Key.f, 'f', Gdk.ModifierType.ControlMask);
// } else {
// Console.WriteLine ("Data is null");
// Console.WriteLine(vimEditor.ToString ());
// }
// if (textEditorData == null) {
// Console.WriteLine ("textEditorData is null");
// } else {
// Console.WriteLine ("textEditorData is not null");
// }
vimEditor.InternalHandleKeypress(null, textEditorData, Gdk.Key.d, (uint)'d', Gdk.ModifierType.ControlMask);
}
protected override void Run()
{
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument;
var textEditorData = doc.GetContent <ITextEditorDataProvider> ().GetTextEditorData();
var vimEditor = (VimAddin.IdeViMode)textEditorData.CurrentMode;
vimEditor.InternalHandleKeypress(null, textEditorData,
Gdk.Key.u, (uint)'u', Gdk.ModifierType.ControlMask);
}
public void Insert (MonoDevelop.Ide.Gui.Document document)
{
var handler = document.GetContent<ICodeTemplateHandler> ();
if (handler != null) {
handler.InsertTemplate (this, document);
} else {
InsertTemplateContents (document);
}
}
string GetTextWithDirective(MonoDevelop.Ide.Gui.Document document, bool insertDirective)
{
string tag = Text;
if (!tag.Contains("{0}"))
{
return(tag);
}
if (Type.AssemblyName.StartsWith("System.Web.UI.WebControls", StringComparison.Ordinal))
{
return(string.Format(tag, "asp"));
}
//register the assembly and look up the class
//FIXME: only do this on the insert, not the preview - or remove it afterwards
RegisterReference(document.Project);
var database = document.GetCompilationAsync().Result;
var cls = database.GetTypeByMetadataName(Type.Load().FullName);
if (cls == null)
{
return(tag);
}
var ed = document.GetContent <WebFormsEditorExtension> ();
if (ed == null)
{
return(tag);
}
var assemName = SystemAssemblyService.ParseAssemblyName(Type.AssemblyName);
WebFormsPageInfo.RegisterDirective directive;
string prefix = ed.ReferenceManager.GetTagPrefixWithNewDirective(cls, assemName.Name, null, out directive);
if (prefix == null)
{
return(tag);
}
tag = string.Format(tag, prefix);
if (directive != null && insertDirective)
{
ed.ReferenceManager.AddRegisterDirective(directive, document.Editor, true);
}
return(tag);
}
public static Document GetAnalysisDocument(this MonoDevelop.Ide.Gui.Document documentContext)
{
var textBuffer = documentContext.GetContent <ITextBuffer>();
if (textBuffer != null && textBuffer.AsTextContainer() is SourceTextContainer container)
{
var document = container.GetOpenDocumentInCurrentContext();
if (document != null)
{
return(document);
}
}
return(null);
}
public static EditorData GetEditorData(MonoDevelop.Ide.Gui.Document doc = null)
{
var ed = new EditorData();
if (doc == null)
{
doc = IdeApp.Workbench.ActiveDocument;
}
if (doc == null ||
doc.FileName == FilePath.Null ||
IdeApp.ProjectOperations.CurrentSelectedSolution == null)
{
return(null);
}
var editor = doc.GetContent <ITextBuffer>();
if (editor == null)
{
return(null);
}
int line, column;
editor.GetLineColumnFromPosition(editor.CursorPosition, out line, out column);
ed.CaretLocation = new CodeLocation(column, line);
ed.CaretOffset = editor.CursorPosition;
var ast = doc.ParsedDocument as ParsedDModule;
var Project = doc.Project as DProject;
ed.SyntaxTree = ast.DDom as DModule;
ed.ModuleCode = editor.Text;
if (ed.SyntaxTree == null)
{
return(null);
}
// Encapsule editor data for resolving
ed.ParseCache = Project != null ?
Project.ParseCache :
ParseCacheList.Create(DCompilerService.Instance.GetDefaultCompiler().ParseCache);
return(ed);
}
public static void Format(PolicyContainer policyParent, IEnumerable <string> mimeTypeChain, MonoDevelop.Ide.Gui.Document data, int startOffset, int endOffset, bool exact, bool formatLastStatementOnly = false)
{
if (data.ParsedDocument == null)
{
return;
}
var ext = data.GetContent <CSharpCompletionTextEditorExtension> ();
if (ext == null)
{
return;
}
string text;
int formatStartOffset, formatLength, realTextDelta;
DomRegion formattingRegion = DomRegion.Empty;
int startDelta = 1;
if (exact)
{
text = data.Editor.Text;
var seg = ext.typeSystemSegmentTree.GetMemberSegmentAt(startOffset);
var seg2 = ext.typeSystemSegmentTree.GetMemberSegmentAt(endOffset);
if (seg != null && seg == seg2)
{
var member = seg.Entity;
if (member == null || member.Region.IsEmpty || member.BodyRegion.End.IsEmpty)
{
return;
}
text = BuildStub(data, seg, startOffset, endOffset, out formatStartOffset);
startDelta = startOffset - seg.Offset;
formatLength = endOffset - startOffset + startDelta;
realTextDelta = seg.Offset - formatStartOffset;
formattingRegion = new DomRegion(data.Editor.OffsetToLocation(formatStartOffset), data.Editor.OffsetToLocation(endOffset));
}
else
{
formatStartOffset = startOffset;
formatLength = endOffset - startOffset;
realTextDelta = 0;
formattingRegion = new DomRegion(data.Editor.OffsetToLocation(startOffset), data.Editor.OffsetToLocation(endOffset));
}
}
else
{
var seg = ext.typeSystemSegmentTree.GetMemberSegmentAt(startOffset - 1);
if (seg == null)
{
return;
}
var member = seg.Entity;
if (member == null)
{
return;
}
// Build stub
text = BuildStub(data, seg, startOffset, endOffset, out formatStartOffset);
formattingRegion = new DomRegion(data.Editor.OffsetToLocation(formatStartOffset), data.Editor.OffsetToLocation(endOffset));
formatLength = endOffset - seg.Offset;
realTextDelta = seg.Offset - formatStartOffset;
}
// Get changes from formatting visitor
var changes = GetFormattingChanges(policyParent, mimeTypeChain, data, text, formattingRegion, ref formatStartOffset, ref formatLength, formatLastStatementOnly);
if (changes == null)
{
return;
}
// Do the actual formatting
// var originalVersion = data.Editor.Document.Version;
using (var undo = data.Editor.OpenUndoGroup()) {
try {
changes.ApplyChanges(formatStartOffset + startDelta, Math.Max(0, formatLength - startDelta - 1), delegate(int replaceOffset, int replaceLength, string insertText) {
int translatedOffset = realTextDelta + replaceOffset;
data.Editor.Document.CommitLineUpdate(data.Editor.OffsetToLineNumber(translatedOffset));
data.Editor.Replace(translatedOffset, replaceLength, insertText);
}, (replaceOffset, replaceLength, insertText) => {
int translatedOffset = realTextDelta + replaceOffset;
if (translatedOffset < 0 || translatedOffset + replaceLength > data.Editor.Length)
{
return(true);
}
return(data.Editor.GetTextAt(translatedOffset, replaceLength) == insertText);
});
} catch (Exception e) {
LoggingService.LogError("Error in on the fly formatter", e);
}
// var currentVersion = data.Editor.Document.Version;
// data.Editor.Caret.Offset = originalVersion.MoveOffsetTo (currentVersion, caretOffset, ICSharpCode.NRefactory.Editor.AnchorMovementType.Default);
}
}
internal static HighlightUsagesExtension GetHighlightUsageExtension(MonoDevelop.Ide.Gui.Document doc)
{
return(doc.GetContent <HighlightUsagesExtension> ());
}
public override bool ExtendsEditor(MonoDevelop.Ide.Gui.Document doc, IEditableTextBuffer editor)
{
//can only attach if there is not already an attached BaseXmlEditorExtension
return(doc.GetContent <BaseXmlEditorExtension> () == null);
}
public async Task GenerateUnitTest(string unitTestName, MethodDeclarationSyntax currentMethod, MonoDevelop.Ide.Gui.Document document, GeneratedTest generatedTestModel)
{
var returnType = generatedTestModel.IsTask ? "Task" : "void";
var modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
if (generatedTestModel.IsTask)
{
modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword));
}
var config = await _configurationService.GetConfiguration();
var annotation = "Test";
if ("xunit".Equals(config.TestFramework))
{
annotation = "Fact";
}
var newMethod = GenerateUnitTestMethodDeclaration(returnType, modifiers, unitTestName, annotation, generatedTestModel);
var analysisDoc = document.GetAnalysisDocument();
var editor = await DocumentEditor.CreateAsync(analysisDoc);
var cuRoot = editor.SemanticModel.SyntaxTree.GetCompilationUnitRoot();
if (cuRoot == null)
{
return;
}
//add required using statements that havent already been added
if (generatedTestModel.RequiredNamespaces != null && generatedTestModel.RequiredNamespaces.Any())
{
var usingNames = cuRoot.Usings.Select(u => u.Name.ToString());
var requiredUsings = new List <UsingDirectiveSyntax>();
foreach (var usingStatement in generatedTestModel.RequiredNamespaces)
{
if (!usingNames.Contains(usingStatement))
{
requiredUsings.Add(GenerateUsingSyntax(usingStatement));
}
}
if (requiredUsings.Any())
{
var updatedRoot = cuRoot.AddUsings(requiredUsings.ToArray());
editor.ReplaceNode(cuRoot, updatedRoot);
cuRoot = updatedRoot;
}
}
var lastMethod = cuRoot.DescendantNodes().OfType <MethodDeclarationSyntax>().LastOrDefault();
if (lastMethod != null)
{
editor.InsertAfter(lastMethod, newMethod);
}
else
{
var classDeclaration = cuRoot.DescendantNodes().OfType <ClassDeclarationSyntax>().First();
var newClassDeclaration = classDeclaration.AddMembers(newMethod);
editor.ReplaceNode(classDeclaration, newClassDeclaration);
}
var newDocument = editor.GetChangedDocument();
var newRoot = await newDocument.GetSyntaxRootAsync();
var textBuffer = document.GetContent <ITextBuffer>();
Microsoft.CodeAnalysis.Workspace.TryGetWorkspace(textBuffer.AsTextContainer(), out var workspace);
newRoot = Formatter.Format(newRoot, Formatter.Annotation, workspace);
workspace.TryApplyChanges(newDocument.WithSyntaxRoot(newRoot).Project.Solution);
await document.Save();
}