private void CreateStub(int position, ITextChange change)
{
string text = this._view.TextSnapshot.ToString();
using (ITextEdit editor = this._view.TextBuffer.CreateEdit())
{
try
{
this.tabs = StubUtils.GetIndention(position, this._view.TextSnapshot, true);
string summaryString = StubUtils.Options.MultiLineSummary ? NewLine() : "";
string parameters = getFunctionParameters(position);
string returnTag = getReturnTag(position);
string commentBody = summaryString + parameters + returnTag;
string autoComment = this.tabs + "/**" + commentBody;
if (!String.IsNullOrEmpty(commentBody))
{
autoComment += Environment.NewLine + this.tabs;
}
autoComment += " */";
int lineStart = this._view.TextSnapshot.GetLineFromPosition(position).Start.Position;
Span firstLineSpan = new Span(lineStart, change.NewSpan.End - lineStart);
editor.Replace(firstLineSpan, autoComment);
ITextSnapshotLine prevLine = this._view.TextSnapshot.GetLineFromPosition(position);
var after = editor.Apply();
}
catch (Exception ex)
{
Console.WriteLine(errorMsgPrefix + ex.Message);
}
}
}
private void CreateNewCommentLine(ITextChange change)
{
using (ITextEdit editor = this._view.TextBuffer.CreateEdit())
{
try
{
ITextSnapshotLine line = this._view.TextSnapshot.GetLineFromPosition(change.OldEnd);
string lineText = line.GetText();
string nextLine = this._view.TextSnapshot.GetLineFromLineNumber(line.LineNumber + 1).GetText();
if (commentLineStart.IsMatch(lineText) && (commentLineStart.IsMatch(nextLine) || change.OldEnd != line.End.Position))
{
int asteriskIndex = lineText.IndexOf('*');
//Only add a new comment line if the newline char is after the triple slash
//(how Visual Studio in C# works)
if ((line.Start.Position + asteriskIndex) > change.OldEnd)
{
return;
}
int tabsStopIndex = -1;
if (asteriskIndex >= 0 || lineText.Contains("/**"))
{
// There's no slash, or its open-comment line, so it's a jsdoc comment. We need asteriskIndex here.
tabsStopIndex = asteriskIndex;
}
string newTabs = tabsStopIndex >= 0 ? lineText.Substring(0, tabsStopIndex) : "";
newTabs = newTabs.Replace('/', ' ');
editor.Replace(change.NewSpan, Environment.NewLine + newTabs + "* ");
editor.Apply();
}
}
catch (Exception) { }
}
}
private void OnTextChange(ITextChange textChange)
{
int index = 0;
// Move past the keys that don't matter
while (index < _adornmentCache.Count && _adornmentCache[index].Position < textChange.OldPosition)
{
index++;
}
if (textChange.Delta < 0)
{
// Remove the items which were in the deleted
while (index < _adornmentCache.Count && _adornmentCache[index].Position < textChange.OldEnd)
{
_adornmentCache.RemoveAt(index);
}
}
// Now adjust everything after the possible delete by the new value
while (index < _adornmentCache.Count)
{
var old = _adornmentCache[index];
_adornmentCache[index] = new AdornmentData(old.Position + textChange.Delta, old.Adornment);
index++;
}
}
public static List <string> GetLines(this ITextChange change)
{
List <string> lines = new List <string>();
var changeLength = change.NewText.Length;
if (changeLength > 0)
{
StringBuilder sb = new StringBuilder();
int currInd = 0;
do
{
sb.Append(change.NewText[currInd]);
if (change.NewText[currInd] == '\n')
{
lines.Add(sb.ToString());
sb.Clear();
}
}while (++currInd < changeLength);
if (sb.Length > 0)
{
lines.Add(sb.ToString());
}
}
return(lines);
}
public void onTextChanged(ITextChange change)
{
if (recordingInProgress)
{
int currentPos = change.NewPosition;
if (currentPos != pos)
{
writeString();
setNewCursorPosition(currentPos);
}
String newText = change.NewText;
String oldText = change.OldText;
if (oldText.Length == 0)
{
buffer += newText;
pos += newText.Length;
if (pos != change.NewEnd)
{
writeString();
setNewCursorPosition(change.NewEnd);
}
}
}
}
private void CreateNewCommentLine(ITextChange change)
{
using (ITextEdit editor = this._view.TextBuffer.CreateEdit())
{
try
{
ITextSnapshotLine line = this._view.TextSnapshot.GetLineFromPosition(change.OldEnd);
string lineText = line.GetText();
string nextLine = this._view.TextSnapshot.GetLineFromLineNumber(line.LineNumber + 1).GetText();
if (commentLineStart.IsMatch(lineText) && (commentLineStart.IsMatch(nextLine) || change.OldEnd != line.End.Position))
{
int asteriskIndex = lineText.IndexOf('*');
//Only add a new comment line if the newline char is after the triple slash
//(how Visual Studio in C# works)
if ((line.Start.Position + asteriskIndex) > change.OldEnd)
return;
int tabsStopIndex = -1;
if (asteriskIndex >= 0 || lineText.Contains("/**"))
{
// There's no slash, or its open-comment line, so it's a jsdoc comment. We need asteriskIndex here.
tabsStopIndex = asteriskIndex;
}
string newTabs = tabsStopIndex >= 0 ? lineText.Substring(0, tabsStopIndex) : "";
newTabs = newTabs.Replace('/', ' ');
editor.Replace(change.NewSpan, Environment.NewLine + newTabs + "* ");
editor.Apply();
}
}
catch (Exception) { }
}
}
private void CreateNewCommentLine(ITextChange change)
{
using (ITextEdit editor = this._view.TextBuffer.CreateEdit())
{
try
{
ITextSnapshotLine line = this._view.TextSnapshot.GetLineFromPosition(change.OldEnd);
string lineText = line.GetText();
string nextLine = this._view.TextSnapshot.GetLineFromLineNumber(line.LineNumber + 1).GetText();
if (lineText.Trim().StartsWith("///") && (nextLine.Trim().StartsWith("///") || change.OldEnd != line.End.Position))
{
int slashIndex = lineText.IndexOf('/');
//Only add a new comment line if the newline char is after the triple slash
//(how Visual Studio in C# works)
if ((line.Start.Position + 3 + slashIndex) > change.OldEnd)
return;
string newTabs = lineText.Substring(0, slashIndex);
editor.Replace(change.NewSpan, Environment.NewLine + newTabs + "/// ");
editor.Apply();
}
}
catch (Exception) { }
}
}
public void TryCloseTag(ITextChange textChange, IList <TextManipulation> manipulations)
{
var currentTag = _state.ParseCurrentTagName();
if (textChange.NewText == "/" && !string.IsNullOrEmpty(currentTag) && currentTag != "/")
{
var text = _text.Span;
int pos = _state.ParserPos;
char c = ' ';
while (char.IsWhiteSpace(c) && text.Length > pos + 1)
{
pos++;
c = text[pos];
}
bool tagAlreadyClosed = c == '>';
if (!tagAlreadyClosed)
{
manipulations.Add(TextManipulation.Insert(_position + 1, $">"));
}
else
{
var closingTagPos = FindClosingTag(currentTag, pos + 1);
if (closingTagPos != null)
{
manipulations.Add(TextManipulation.Insert(_position + 1, $">"));
manipulations.Add(TextManipulation.Delete(_position + 1, closingTagPos.Value - _position));
}
}
}
}
private bool PeviewTextTypedIs(ITextChange change, string character)
{
int i = change.OldEnd;
string lineText = this.view.TextSnapshot.GetLineFromPosition(i - 1).GetText();
return(lineText.EndsWith(character));
}
public void ApplyTextChange(ITextSnapshot before, ITextSnapshot after, ITextChange change)
{
List <TrackingToken> forRemoval = GetInvalidated(before, change);
// Some of the tokens marked for removal must be deleted before applying a new version,
// because otherwise some trackingtokens will have broken spans
int i = 0;
for (; i < forRemoval.Count; i++)
{
tree.Remove(forRemoval[i]);
}
CurrentSnapshot = after;
IList <TrackingToken> updated = Rescan(forRemoval, before, change.Delta);
for (; i < forRemoval.Count; i++)
{
tree.Remove(forRemoval[i]);
}
foreach (var token in updated)
{
tree.Add(token);
}
RaiseTokensChanged(updated);
CheckChanges(change);
}
/// <summary>
/// Converts list of text changes in a text buffer to a collection of
/// changes that are relative one to another.
/// </summary>
/// <param name="changes">Sorted collection of changes</param>
/// <returns>Collection of relative changes</returns>
public static List <TextChangeEventArgs> ConvertToRelative(TextContentChangedEventArgs changeInfo)
{
IList <ITextChange> changes = changeInfo.Changes;
var list = new List <TextChangeEventArgs>(changes.Count);
ITextChange previousChange = null;
TextProvider oldText = new TextProvider(changeInfo.Before, true);
TextProvider newText = new TextProvider(changeInfo.After, true);
for (int i = 0; i < changes.Count; i++)
{
var change = changes[i];
if (previousChange != null)
{
if (previousChange.OldEnd > change.OldPosition || previousChange.NewEnd > change.NewPosition)
{
throw new ArgumentException("List of changes must not overlap", "changes");
}
}
var textChange = new TextChangeEventArgs(change.NewPosition, change.OldPosition, change.OldLength, change.NewLength, oldText, newText);
list.Add(textChange);
previousChange = change;
}
return(list);
}
private void CreateNewCommentLine(ITextChange change)
{
using (ITextEdit editor = this._view.TextBuffer.CreateEdit())
{
try
{
ITextSnapshotLine line = this._view.TextSnapshot.GetLineFromPosition(change.OldEnd);
string lineText = line.GetText();
string nextLine = this._view.TextSnapshot.GetLineFromLineNumber(line.LineNumber + 1).GetText();
if (lineText.Trim().StartsWith("///") && (nextLine.Trim().StartsWith("///") || change.OldEnd != line.End.Position))
{
int slashIndex = lineText.IndexOf('/');
//Only add a new comment line if the newline char is after the triple slash
//(how Visual Studio in C# works)
if ((line.Start.Position + 3 + slashIndex) > change.OldEnd)
{
return;
}
string newTabs = lineText.Substring(0, slashIndex);
editor.Replace(change.NewSpan, Environment.NewLine + newTabs + "/// ");
editor.Apply();
}
}
catch (Exception) { }
}
}
/// <summary>
/// Builds the comment stub and inserts it into the editor.
/// </summary>
/// <param name="position">The position of the last slash.</param>
private void CreateStub(int position, ITextChange change)
{
string text = this._view.TextSnapshot.ToString();
using (ITextEdit editor = this._view.TextBuffer.CreateEdit())
{
try
{
this.tabs = StubUtils.GetIndention(position, this._view.TextSnapshot);
string summaryTag = generateSummaryTag();
string parameters = getFunctionParameters(position);
string returnTag = getReturnTag(position);
string autoComment = summaryTag + parameters + returnTag;
int lineStart = this._view.TextSnapshot.GetLineFromPosition(position).Start.Position;
var caretPosition = autoComment.IndexOf(StubUtils.CaretPlaceholder);
Span firstLineSpan = new Span(lineStart, change.NewSpan.End - lineStart);
autoComment = autoComment.Replace(StubUtils.CaretPlaceholder, "");
editor.Replace(firstLineSpan, autoComment);
ITextSnapshotLine prevLine = this._view.TextSnapshot.GetLineFromPosition(position);
StubUtils.MoveCaretAfterChange(this._view, this.editor, lineStart + caretPosition);
var after = editor.Apply();
}
catch (Exception ex)
{
Console.WriteLine(errorMsgPrefix + ex.Message);
}
}
}
public int IndexOf(ITextChange item) {
for (int i = 0; i < _changes.Length; i++) {
if (_changes[i] == item) {
return i;
}
}
return -1;
}
private void HandleChange(ITextChange c)
{
/*
* ITextEdit edit = this.view.TextBuffer.CreateEdit();
* edit.Insert(c.NewEnd-1, "!");
* edit.Apply();
*/
}
private void CreateMethodComment(ITextChange change)
{
int position = change.NewEnd;
string text = this.view.TextSnapshot.ToString();
using (ITextEdit editor = this.view.TextBuffer.CreateEdit())
{
try
{
this.tabs = StubUtils.GetIndention(position, this.view.TextSnapshot);
string summaryString = StubUtils.Options.MultiLineSummary ? NewLine() : "";
string parameters = GetFunctionParameters(position);
string returnTag = GetReturnTag(position);
string commentBody = summaryString + parameters + returnTag;
string autoComment = this.tabs + "/**" + commentBody;
if (!String.IsNullOrEmpty(commentBody))
{
autoComment += Environment.NewLine + this.tabs;
}
autoComment += " */";
int lineStart = this.view.TextSnapshot.GetLineFromPosition(position).Start.Position;
Span firstLineSpan = new Span(lineStart, change.NewSpan.End - lineStart);
editor.Replace(firstLineSpan, autoComment);
ITextSnapshot after = editor.Apply();
////Move the caret back at the comment description
//int lineNumber = after.GetLineNumberFromPosition(change.NewPosition);
//var lineSnapShotPoint = after.GetLineFromLineNumber(lineNumber).End;
//this.view.Caret.MoveTo(lineSnapShotPoint);
//view.Caret.MoveTo(
// view.GetTextViewLineContainingBufferPosition(
// after.GetLineFromPosition(
// after.GetText().IndexOf(autoComment)).Start));
//view.Caret.MoveTo(
// view.GetTextViewLineContainingBufferPosition(
// view.TextSnapshot.GetLineFromPosition(
// view.TextSnapshot.GetText().IndexOf(fn)).Start));
}
catch (Exception ex)
{
Console.WriteLine(ERROR_MSG_PREFIX + ex.Message);
}
}
}
private void SourceTextChanged(object sender, TextContentChangedEventArgs e)
{
if (this.enabled && e.Changes.Count > 0)
{
ITextChange firstChange = e.Changes[0];
ITextChange lastChange = e.Changes[e.Changes.Count - 1];
SnapshotSpan changedSpan = new SnapshotSpan(e.After, Span.FromBounds(firstChange.NewSpan.Start, lastChange.NewSpan.End));
UpdateAfterChange(changedSpan);
}
}
private void CompileIfWhitespace(ITextChange c)
{
if (c.Delta == 1)
{
// we do nothing if there's just one letter typed (no space or CR)
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(c.NewText);
if (bytes != null && bytes[0] != 13 && bytes[0] != 32) return;
}
timer.stop(); // this will call Compile()
}
// Returns spans corresponding to the changes that occurred between startVersion and endVersion
public static bool GetChangedExtent(this ITextVersion oldVersion, ITextVersion newVersion, out Span?oldSpan, out Span?newSpan)
{
oldSpan = null;
newSpan = null;
if (oldVersion.VersionNumber > newVersion.VersionNumber)
{
// They've asked for information about an earlier snapshot, not supported
Debug.Assert(false);
return(false);
}
int newEnd = Int32.MinValue;
int position = Int32.MaxValue;
int deltaLen = 0;
while (oldVersion != newVersion)
{
INormalizedTextChangeCollection changes = oldVersion.Changes;
if (changes.Count > 0)
{
ITextChange firstChange = changes[0];
ITextChange lastChange = changes[changes.Count - 1];
int changeDeltaLen = lastChange.NewEnd - lastChange.OldEnd;
deltaLen += changeDeltaLen;
position = Math.Min(position, firstChange.NewPosition);
if (newEnd < lastChange.OldEnd)
{
newEnd = lastChange.NewEnd;
}
else
{
newEnd += changeDeltaLen;
}
}
oldVersion = oldVersion.Next;
}
if (newEnd < position)
{
// There weren't any changes between the versions, return a null TextChangeExtent
return(false);
}
int oldEnd = newEnd - deltaLen;
oldSpan = Span.FromBounds(position, oldEnd);
newSpan = Span.FromBounds(position, newEnd);
return(true);
}
private void SynchronizeStartAndEndTag(ITextChange textChange, List <TextManipulation> maniplations)
{
if (!textChange.NewText.All(n => char.IsLetterOrDigit(n) || XmlNameSpecialCharacters.Contains(n)))
{
return;
}
string startTag = _state.ParseCurrentTagName();
int? maybeTagStart = _state.CurrentValueStart;
if (maybeTagStart == null)
{
return;
}
int startPos = maybeTagStart.Value; // add 1 to take opening < into account
if (startTag.EndsWith("/"))
{
return; // start tag is self-closing
}
if (textChange.NewPosition < startPos || textChange.NewPosition > startPos + startTag.Length)
{
return; //we are not editing tag name
}
XmlParser searchEndTag = _state.Clone();
if (searchEndTag.SeekClosingTag())
{
string endTag = searchEndTag.ParseCurrentTagName();
if (endTag[0] != '/')
{
return;
}
maybeTagStart = searchEndTag.CurrentValueStart;
if (maybeTagStart == null)
{
return;
}
int endPos = maybeTagStart.Value; // add 1 to take opening < into account
// reverse change to start tag
startTag = textChange.ReverseOn(startTag, startPos);
bool isTheSameTag = endTag.Length > 0 && endTag.Substring(1) == startTag;
if (isTheSameTag)
{
maniplations.AddRange(textChange.AsManipulations(endPos - startPos));
}
}
}
public int IndexOf(ITextChange item)
{
for (int i = 0; i < _changes.Length; i++)
{
if (_changes[i] == item)
{
return(i);
}
}
return(-1);
}
private static TextChangeRange CreateTextChangeRange(ITextChange change, bool forward)
{
if (forward)
{
return(new TextChangeRange(new TextSpan(change.OldSpan.Start, change.OldSpan.Length), change.NewLength));
}
else
{
return(new TextChangeRange(new TextSpan(change.NewSpan.Start, change.NewSpan.Length), change.OldLength));
}
}
public static IEnumerable <TextManipulation> AsManipulations(this ITextChange textChange, int offset = 0)
{
if (!string.IsNullOrEmpty(textChange.OldText))
{
yield return(TextManipulation.Delete(textChange.OldPosition + offset + 1, textChange.OldText.Length));
}
if (!string.IsNullOrEmpty(textChange.NewText))
{
yield return(TextManipulation.Insert(textChange.NewPosition + offset + 1, textChange.NewText));
}
}
private static bool PriorTo(ITextChange denormalizedChange, ITextChange normalizedChange, int accumulatedDelta, int accumulatedNormalizedDelta)
{
// notice that denormalizedChange.OldPosition == denormalizedChange.NewPosition
if ((denormalizedChange.OldLength != 0) && (normalizedChange.OldLength != 0))
{
// both deletions
return(denormalizedChange.OldPosition <= normalizedChange.NewPosition - accumulatedDelta - accumulatedNormalizedDelta);
}
else
{
return(denormalizedChange.OldPosition < normalizedChange.NewPosition - accumulatedDelta - accumulatedNormalizedDelta);
}
}
private void DumpChange(ITextChange c)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.AppendLine(">>>>> HandleChange:");
s.Append("Delta=").Append(c.Delta).Append(" LineCountDelta=").Append(c.LineCountDelta).AppendLine();
s.Append("Position=").Append(c.OldPosition).Append('>').Append(c.NewPosition).AppendLine();
s.Append("Length=").Append(c.OldLength).Append('>').Append(c.NewLength).AppendLine();
s.Append("End=").Append(c.OldEnd).Append('>').Append(c.NewEnd).AppendLine();
s.Append("Span=").Append(c.OldSpan).Append('>').Append(c.NewSpan).AppendLine();
s.Append("Text=\"").Append(c.OldText).Append("\">\"").Append(c.NewText).AppendLine("\"");
s.Append("<<<<<<<<<<");
System.Console.WriteLine(s.ToString());
}
private void CompileIfWhitespace(ITextChange c)
{
if (c.Delta == 1)
{
// we do nothing if there's just one letter typed (no space or CR)
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(c.NewText);
if (bytes != null && bytes[0] != 13 && bytes[0] != 32)
{
return;
}
}
timer.stop(); // this will call Compile()
}
/// <summary>
/// TextChange reversal is required to compare original text (before change)
/// </summary>
/// <param name="textChangeOffset">
/// As text change is scoped in document this param allows to apply it to short strings, ie. tag names
/// </param>
public static string ReverseOn(this ITextChange textChange, string input, int textChangeOffset = 0)
{
if (!string.IsNullOrEmpty(textChange.NewText))
{
var start = textChange.NewPosition - textChangeOffset;
input = input.Remove(start, Math.Min(input.Length - start, textChange.NewText.Length));
}
if (!string.IsNullOrEmpty(textChange.OldText))
{
input = input.Insert(textChange.OldPosition - textChangeOffset, textChange.OldText);
}
return(input);
}
private static bool ContainsTemplateMarkup(ITextChange change)
{
bool recalc = false;
foreach (var tag in _templateTags)
{
if (change.NewText.Contains(tag))
{
recalc = true;
break;
}
}
return(recalc);
}
private void TextBuffer_Changed(object sender, TextContentChangedEventArgs e)
{
if (!isChangingText)
{
isChangingText = true;
if (e.Changes != null)
{
for (int i = e.Changes.Count - 1; i >= 0; i--)
{
change = e.Changes[i];
HandleChange();
}
}
}
}
private void CheckChanges(ITextChange change)
{
Span[] expected = lexer.Run(new [] { CurrentSnapshot.GetText() }, 0).Select(x => x.Span).ToArray();
Span[] actual = GetTokens(new Span(0, CurrentSnapshot.Length)).Select(x => x.GetSpan(CurrentSnapshot)).ToArray();
var wrong = expected.Zip(actual, (_1, _2) => new { _1, _2 }).FirstOrDefault(x => x._1 != x._2);
if(wrong != null)
{
Utils.DebugPrintToOutput(
"Parser state mismatch.\nExpected span: {0} `{1}`\nActual span: {2} `{3}`",
wrong._1,
CurrentSnapshot.GetText(wrong._1),
wrong._2,
CurrentSnapshot.GetText(wrong._2));
}
}
public static FileChange Convert(ITextChange change)
{
var newLength = change.NewLength;
var oldLength = change.OldLength;
if (oldLength == 0 && newLength > 0)
{
return(new FileChange.Insert(change.OldPosition, change.NewText));
}
if (oldLength > 0 && newLength == 0)
{
return(new FileChange.Delete(Convert(change.OldSpan)));
}
return(new FileChange.Replace(Convert(change.OldSpan), change.NewText));
}
private void CheckChanges(ITextChange change)
{
Span[] expected = lexer.Run(new [] { CurrentSnapshot.GetText() }, 0).Select(x => x.Span).ToArray();
Span[] actual = GetTokens(new Span(0, CurrentSnapshot.Length)).Select(x => x.GetSpan(CurrentSnapshot)).ToArray();
var wrong = expected.Zip(actual, (_1, _2) => new { _1, _2 }).FirstOrDefault(x => x._1 != x._2);
if (wrong != null)
{
Utils.DebugPrintToOutput(
"Parser state mismatch.\nExpected span: {0} `{1}`\nActual span: {2} `{3}`",
wrong._1,
CurrentSnapshot.GetText(wrong._1),
wrong._2,
CurrentSnapshot.GetText(wrong._2));
}
}
internal static SnapshotSpan?GetPasteSpan(ITextSnapshot prePasteSnapshot, ITextSnapshot postPasteSnapshot)
{
INormalizedTextChangeCollection changes = prePasteSnapshot.Version.Changes;
if (changes != null && changes.Count > 0)
{
ITextChange firstChange = changes[0];
ITextChange lastChange = changes[changes.Count - 1];
SnapshotSpan newSpan = new SnapshotSpan(postPasteSnapshot, Span.FromBounds(firstChange.NewPosition, lastChange.NewEnd));
return(newSpan);
}
return(null);
}
public StringRebuilder ApplyChangesToStringRebuilder(INormalizedTextChangeCollection normalizedChanges, StringRebuilder source)
{
var doppelganger = this.GetDoppelgangerBuilder();
if (doppelganger != null)
{
return(doppelganger);
}
for (int i = normalizedChanges.Count - 1; (i >= 0); --i)
{
ITextChange change = normalizedChanges[i];
source = source.Replace(change.OldSpan, TextChange.NewStringRebuilder(change));
}
return(source);
}
public void ApplyTextChange(ITextSnapshot before, ITextSnapshot after, ITextChange change)
{
List<TrackingToken> forRemoval = GetInvalidated(before, change);
// Some of the tokens marked for removal must be deleted before applying a new version,
// because otherwise some trackingtokens will have broken spans
int i = 0;
for (; i < forRemoval.Count; i++)
tree.Remove(forRemoval[i]);
CurrentSnapshot = after;
IList<TrackingToken> updated = Rescan(forRemoval, before, change.Delta);
for (; i < forRemoval.Count; i++)
tree.Remove(forRemoval[i]);
foreach (var token in updated)
tree.Add(token);
RaiseTokensChanged(updated);
CheckChanges(change);
}
private static TextDocumentContentChangeEvent ConvertChange(
ITextSnapshot before,
ITextChange change)
{
var line = before.GetLineFromPosition(change.OldPosition);
var character = change.OldPosition - line.Start.Position;
var length = change.OldSpan.Length;
return(new TextDocumentContentChangeEvent
{
Range = new Range
{
Start = new Position(line.LineNumber, character),
End = new Position(line.LineNumber, character + length)
},
Text = change.NewText
});
}
public static StringRebuilder ChangeNewSubText(ITextChange change, int start, int length)
{
var textChange = change as TextChange;
if (textChange != null)
{
return(textChange._newText.GetSubText(new Span(start, length)));
}
var change3 = change as ITextChange3;
if (change3 != null)
{
return(StringRebuilder.Create(change3.GetNewText(new Span(start, length))));
}
return(StringRebuilder.Create(change.NewText.Substring(start, length)));
}
public static string ChangeNewSubstring(ITextChange change, int start, int length)
{
var textChange = change as TextChange;
if (textChange != null)
{
return(textChange._newText.GetText(new Span(start, length)));
}
var change3 = change as ITextChange3;
if (change3 != null)
{
return(change3.GetNewText(new Span(start, length)));
}
return(change.NewText.Substring(start, length));
}
public void Setup()
{
_textChangeMock = Substitute.For<ITextChange>();
}
public void Insert(int index, ITextChange item) {
throw new NotImplementedException();
}
public bool Remove(ITextChange item)
{
return false;
}
public void Add(ITextChange item) {
throw new NotImplementedException();
}
private List<TrackingToken> GetInvalidated(ITextSnapshot oldSnapshot, ITextChange change)
{
return tree.GetInvalidatedBy(oldSnapshot, change.OldSpan);
}
private void HandleChange(ITextChange c)
{
/*
ITextEdit edit = this.view.TextBuffer.CreateEdit();
edit.Insert(c.NewEnd-1, "!");
edit.Apply();
*/
}
public bool Contains(ITextChange item)
{
throw new NotImplementedException();
}
public void Add(ITextChange item)
{
}
public void CopyTo(ITextChange[] array, int arrayIndex)
{
throw new NotImplementedException();
}
/// <summary>
/// Builds the comment stub and inserts it into the editor.
/// </summary>
/// <param name="position">The position of the last slash.</param>
private void CreateStub(int position, ITextChange change)
{
string text = this._view.TextSnapshot.ToString();
using (ITextEdit editor = this._view.TextBuffer.CreateEdit())
{
try
{
this.tabs = StubUtils.GetIndention(position, this._view.TextSnapshot);
string summaryTag = generateSummaryTag();
string parameters = getFunctionParameters(position);
string returnTag = getReturnTag(position);
string autoComment = summaryTag + parameters + returnTag;
int lineStart = this._view.TextSnapshot.GetLineFromPosition(position).Start.Position;
Span firstLineSpan = new Span(lineStart, change.NewSpan.End - lineStart);
editor.Replace(firstLineSpan, autoComment);
ITextSnapshotLine prevLine = this._view.TextSnapshot.GetLineFromPosition(position);
var after = editor.Apply();
}
catch (Exception ex)
{
Console.WriteLine(errorMsgPrefix + ex.Message);
}
}
}
private static TextChangeRange CreateTextChangeRange(ITextChange change, bool forward)
{
if (forward)
{
return new TextChangeRange(new TextSpan(change.OldSpan.Start, change.OldSpan.Length), change.NewLength);
}
else
{
return new TextChangeRange(new TextSpan(change.NewSpan.Start, change.NewSpan.Length), change.OldLength);
}
}
private bool ShouldClearTrackingSession(ITextChange change)
{
AssertIsForeground();
ISyntaxFactsService syntaxFactsService;
if (!TryGetSyntaxFactsService(out syntaxFactsService))
{
return true;
}
// The editor will replace virtual space with spaces and/or tabs when typing on a
// previously blank line. Trim these characters from the start of change.NewText. If
// the resulting change is empty (the user just typed a <space>), clear the session.
var changedText = change.OldText + change.NewText.TrimStart(' ', '\t');
if (changedText.IsEmpty())
{
return true;
}
return changedText.Any(c => !IsTrackableCharacter(syntaxFactsService, c));
}
public void Insert(int index, ITextChange item)
{
}
private void DumpChange(ITextChange c)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.AppendLine(">>>>> HandleChange:");
s.Append("Delta=").Append(c.Delta).Append(" LineCountDelta=").Append(c.LineCountDelta).AppendLine();
s.Append("Position=").Append(c.OldPosition).Append('>').Append(c.NewPosition).AppendLine();
s.Append("Length=").Append(c.OldLength).Append('>').Append(c.NewLength).AppendLine();
s.Append("End=").Append(c.OldEnd).Append('>').Append(c.NewEnd).AppendLine();
s.Append("Span=").Append(c.OldSpan).Append('>').Append(c.NewSpan).AppendLine();
s.Append("Text=\"").Append(c.OldText).Append("\">\"").Append(c.NewText).AppendLine("\"");
s.Append("<<<<<<<<<<");
System.Console.WriteLine(s.ToString());
}
public bool Remove(ITextChange item) {
throw new NotImplementedException();
}
public int IndexOf(ITextChange item)
{
return 0;
}
private static bool ShouldWrap(
GeneralOptions options,
ITextChange change,
ITextSnapshotLine line,
LineCommentInfo info,
out int commentWrapLength)
{
commentWrapLength = -1;
if (info == null || (!info.CommentOnly && !options.CodeWrapEnabled))
{
return false;
}
// For now, we're only supporting single-line comments.
if (info.Style != CommentStyle.SingleLine)
{
return false;
}
// If we just typed whitespace at the *end* of the line, don't do
// any wrapping yet. (It will cause us to trim the trailing space,
// which would makeeverythingruntogetherlikethis! It also makes
// newline handling weird.)
if ((change.Delta > 0) &&
((change.NewSpan.End >= line.End) && (change.NewSpan.End <= line.EndIncludingLineBreak)) &&
change.NewText.All(c => Whitespace.Contains(c)))
{
return false;
}
commentWrapLength = options.AutoWrapColumn - info.ContentColumnStart;
// There's some minimum length after which wrapping becomes
// pointless...
if (commentWrapLength < options.MinimumWrapWidth)
{
return false;
}
return true;
}
