static void Rollback(Ide.Editor.TextEditor editor, List <MonoDevelop.Core.Text.TextChangeEventArgs> textChanges)
{
for (int i = textChanges.Count - 1; i >= 0; i--)
{
for (int j = 0; j < textChanges [i].TextChanges.Count; ++j)
{
var v = textChanges [i].TextChanges [j];
editor.ReplaceText(v.Offset, v.InsertionLength, v.RemovedText);
}
}
}
public bool FixLineStart(Ide.Editor.TextEditor textEditorData, ICSharpCode.NRefactory6.CSharp.IStateMachineIndentEngine stateTracker, int lineNumber)
{
if (lineNumber > 1)
{
var line = textEditorData.GetLine(lineNumber);
if (line == null)
{
return(false);
}
var prevLine = textEditorData.GetLine(lineNumber - 1);
if (prevLine == null)
{
return(false);
}
string trimmedPreviousLine = textEditorData.GetTextAt(prevLine).TrimStart();
//xml doc comments
//check previous line was a doc comment
//check there's a following line?
if (trimmedPreviousLine.StartsWith("///", StringComparison.Ordinal))
{
if (textEditorData.GetTextAt(line.Offset, line.Length).TrimStart().StartsWith("///", StringComparison.Ordinal))
{
return(false);
}
//check that the newline command actually inserted a newline
textEditorData.EnsureCaretIsNotVirtual();
var nextLineSegment = textEditorData.GetLine(lineNumber + 1);
string nextLine = nextLineSegment != null?textEditorData.GetTextAt(nextLineSegment).TrimStart() : "";
if (trimmedPreviousLine.Length > "///".Length || nextLine.StartsWith("///", StringComparison.Ordinal))
{
var insertionPoint = textEditorData.CaretOffset;
textEditorData.InsertText(insertionPoint, "/// ");
textEditorData.CaretOffset = insertionPoint + "/// ".Length;
return(true);
}
//multi-line comments
}
else if (stateTracker.IsInsideMultiLineComment)
{
if (textEditorData.GetTextAt(line.Offset, line.Length).TrimStart().StartsWith("*", StringComparison.Ordinal))
{
return(false);
}
textEditorData.EnsureCaretIsNotVirtual();
string commentPrefix = string.Empty;
if (trimmedPreviousLine.StartsWith("* ", StringComparison.Ordinal))
{
commentPrefix = "* ";
}
else if (trimmedPreviousLine.StartsWith("/**", StringComparison.Ordinal) || trimmedPreviousLine.StartsWith("/*", StringComparison.Ordinal))
{
commentPrefix = " * ";
}
else if (trimmedPreviousLine.StartsWith("*", StringComparison.Ordinal))
{
commentPrefix = "*";
}
int indentSize = line.GetIndentation(textEditorData).Length;
var insertedText = prevLine.GetIndentation(textEditorData) + commentPrefix;
textEditorData.ReplaceText(line.Offset, indentSize, insertedText);
textEditorData.CaretOffset = line.Offset + insertedText.Length;
return(true);
}
else if (wasInStringLiteral)
{
var lexer = new ICSharpCode.NRefactory.CSharp.Completion.CSharpCompletionEngineBase.MiniLexer(textEditorData.GetTextAt(0, prevLine.EndOffset).TrimEnd());
lexer.Parse();
if (!lexer.IsInString)
{
return(false);
}
textEditorData.EnsureCaretIsNotVirtual();
var insertedText = "\" +";
textEditorData.InsertText(prevLine.Offset + prevLine.Length, insertedText);
var lineOffset = line.Offset + insertedText.Length;
int indentSize = textEditorData.CaretOffset - lineOffset;
insertedText = prevLine.GetIndentation(textEditorData) + (trimmedPreviousLine.StartsWith("\"", StringComparison.Ordinal) ? "" : "\t") + "\"";
textEditorData.ReplaceText(lineOffset, indentSize, insertedText);
return(true);
}
}
return(false);
}
async Task TryStartRenameSession(Workspace workspace, Solution oldSolution, Solution newSolution, CancellationToken cancellationToken)
{
var changedDocuments = GetChangedDocuments(newSolution, oldSolution);
foreach (var documentId in changedDocuments)
{
var document = newSolution.GetDocument(documentId);
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SyntaxToken?renameTokenOpt = root.GetAnnotatedNodesAndTokens(RenameAnnotation.Kind)
.Where(s => s.IsToken)
.Select(s => s.AsToken())
.Cast <SyntaxToken?> ()
.FirstOrDefault();
if (renameTokenOpt.HasValue)
{
var latestDocument = workspace.CurrentSolution.GetDocument(documentId);
var latestModel = await latestDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var latestRoot = await latestDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
await Runtime.RunInMainThread(async delegate {
try {
var node = latestRoot.FindNode(renameTokenOpt.Value.Parent.Span, false, false);
if (node == null)
{
return;
}
var info = latestModel.GetSymbolInfo(node);
var sym = info.Symbol ?? latestModel.GetDeclaredSymbol(node);
if (sym != null)
{
await new Refactoring.Rename.RenameRefactoring().Rename(sym);
}
else
{
var links = new List <TextLink> ();
var link = new TextLink("name");
link.AddLink(new TextSegment(node.Span.Start, node.Span.Length));
links.Add(link);
var oldVersion = editor.Version;
editor.StartTextLinkMode(new TextLinkModeOptions(links, (arg) => {
//If user cancel renaming revert changes
if (!arg.Success)
{
var textChanges = editor.Version.GetChangesTo(oldVersion).ToList();
foreach (var change in textChanges)
{
foreach (var v in change.TextChanges.Reverse())
{
editor.ReplaceText(v.Offset, v.RemovalLength, v.InsertedText);
}
}
}
})
{
TextLinkPurpose = TextLinkPurpose.Rename
});
}
} catch (Exception ex) {
LoggingService.LogError("Error while renaming " + renameTokenOpt.Value.Parent, ex);
}
});
return;
}
}
}
public override void HandleSpecialSelectionKey(uint unicodeKey)
{
string start, end;
((SelectionSurroundingProvider)this).GetSelectionSurroundings(unicodeKey, out start, out end);
if (editor.SelectionMode == SelectionMode.Block)
{
var selection = editor.SelectionRegion;
int startCol = System.Math.Min(selection.Begin.Column, selection.End.Column) - 1;
int endCol = System.Math.Max(selection.Begin.Column, selection.End.Column);
int minLine = System.Math.Min(selection.Begin.Line, selection.End.Line);
int maxLine = System.Math.Max(selection.BeginLine, selection.End.Line);
var changes = new List <TextChange> ();
for (int lineNumber = minLine; lineNumber <= maxLine; lineNumber++)
{
var lineSegment = editor.GetLine(lineNumber);
if (lineSegment.Offset + startCol < lineSegment.EndOffset)
{
changes.Add(new TextChange(new TextSpan(lineSegment.Offset + startCol, 0), start));
}
if (lineSegment.Offset + endCol < lineSegment.EndOffset)
{
changes.Add(new TextChange(new TextSpan(lineSegment.Offset + endCol, 0), end));
}
}
editor.ApplyTextChanges(changes);
// textEditorData.MainSelection = new Selection (
// new DocumentLocation (selection.Anchor.Line, endCol == selection.Anchor.Column ? endCol + start.Length : startCol + 1 + start.Length),
// new DocumentLocation (selection.Lead.Line, endCol == selection.Anchor.Column ? startCol + 1 + start.Length : endCol + start.Length),
// MonoDevelop.Ide.Editor.SelectionMode.Block);
}
else
{
var selectionRange = editor.SelectionRange;
int anchorOffset = selectionRange.Offset;
int leadOffset = selectionRange.EndOffset;
var text = editor.GetTextAt(selectionRange);
var formattingService = context.AnalysisDocument.GetLanguageService <IEditorFormattingService> ();
if (editor.Options.GenerateFormattingUndoStep)
{
using (var undo = editor.OpenUndoGroup()) {
editor.ReplaceText(selectionRange, start);
}
using (var undo = editor.OpenUndoGroup()) {
editor.ReplaceText(anchorOffset, 1, start + text + end);
editor.SetSelection(anchorOffset + start.Length, leadOffset + start.Length + end.Length);
}
if (unicodeKey == '{')
{
if (formattingService != null)
{
var changes = formattingService.GetFormattingChangesAsync(context.AnalysisDocument, TextSpan.FromBounds(anchorOffset + start.Length - 1, leadOffset + start.Length + end.Length), CancellationToken.None).WaitAndGetResult(CancellationToken.None);
editor.ApplyTextChanges(changes);
}
}
}
else
{
using (var undo = editor.OpenUndoGroup()) {
editor.InsertText(anchorOffset, start);
editor.InsertText(leadOffset >= anchorOffset ? leadOffset + start.Length : leadOffset, end);
if (unicodeKey == '{')
{
if (formattingService != null)
{
var changes = formattingService.GetFormattingChangesAsync(context.AnalysisDocument, TextSpan.FromBounds(anchorOffset + start.Length, leadOffset + start.Length), CancellationToken.None).WaitAndGetResult(CancellationToken.None);
editor.ApplyTextChanges(changes);
}
}
else
{
editor.SetSelection(anchorOffset + start.Length, leadOffset + start.Length + end.Length);
}
}
}
}
}