internal VisualLine(TextView textView, DocumentLine firstDocumentLine)
{
Debug.Assert(textView != null);
Debug.Assert(firstDocumentLine != null);
this.textView = textView;
this.FirstDocumentLine = firstDocumentLine;
}
public LineAdapter(TextDocument document, DocumentLine line)
{
Debug.Assert(document != null);
Debug.Assert(line != null);
this.document = document;
this.line = line;
}
public void RawlyIndentLine(int tabsToInsert, ICSharpCode.AvalonEdit.Document.TextDocument document, DocumentLine line)
{
if (!_doBeginUpdateManually)
document.BeginUpdate();
/*
* 1) Remove old indentation
* 2) Insert new one
*/
// 1)
int prevInd = 0;
int curOff = line.Offset;
if (curOff < document.TextLength)
{
char curChar = '\0';
while (curOff < document.TextLength && ((curChar = document.GetCharAt(curOff)) == ' ' || curChar == '\t'))
{
prevInd++;
curOff++;
}
document.Remove(line.Offset, prevInd);
}
// 2)
string indentString = "";
for (int i = 0; i < tabsToInsert; i++)
indentString += dEditor.Editor.Options.IndentationString;
document.Insert(line.Offset, indentString);
if (!_doBeginUpdateManually)
document.EndUpdate();
}
public void IndentLine(TextDocument document, DocumentLine line)
{
if (document == null || line == null)
{
return;
}
DocumentLine previousLine = line.PreviousLine;
if (previousLine != null)
{
ISegment indentationSegment = TextUtilities.GetWhitespaceAfter(document, previousLine.Offset);
string indentation = document.GetText(indentationSegment);
if (Program.OptionsObject.Editor_AgressiveIndentation)
{
string currentLineTextTrimmed = (document.GetText(line)).Trim();
string lastLineTextTrimmed = (document.GetText(previousLine)).Trim();
char currentLineFirstNonWhitespaceChar = ' ';
if (currentLineTextTrimmed.Length > 0)
{
currentLineFirstNonWhitespaceChar = currentLineTextTrimmed[0];
}
char lastLineLastNonWhitespaceChar = ' ';
if (lastLineTextTrimmed.Length > 0)
{
lastLineLastNonWhitespaceChar = lastLineTextTrimmed[lastLineTextTrimmed.Length - 1];
}
if (lastLineLastNonWhitespaceChar == '{' && currentLineFirstNonWhitespaceChar != '}')
{
indentation += "\t";
}
else if (currentLineFirstNonWhitespaceChar == '}')
{
if (indentation.Length > 0)
{
indentation = indentation.Substring(0, indentation.Length - 1);
}
else
{
indentation = string.Empty;
}
}
/*if (lastLineTextTrimmed == "{" && currentLineTextTrimmed != "}")
{
indentation += "\t";
}
else if (currentLineTextTrimmed == "}")
{
if (indentation.Length > 0)
{
indentation = indentation.Substring(0, indentation.Length - 1);
}
else
{
indentation = string.Empty;
}
}*/
}
indentationSegment = TextUtilities.GetWhitespaceAfter(document, line.Offset);
document.Replace(indentationSegment, indentation);
}
}
/*
protected override void Colorize(ITextRunConstructionContext context)
{
//base.Colorize(context);
foreach (var line in context.Document.Lines)
{
ColorizeText(line, context.Document.GetText(line));
}
}
*/
protected override void ColorizeLine(DocumentLine line)
{
if (CurrentContext == null) return;
string text = CurrentContext.Document.GetText(line);
ColorizeText(line, text);
}
public virtual void IndentLine(TextDocument document, DocumentLine line)
{
if(line == null)
throw new ArgumentNullException("line");
formatting_strategy.IndentLine(editor, editor.Document.GetLineByNumber(line.LineNumber));
}
protected override void ColorizeLine(DocumentLine line)
{
int lineStartOffset = line.Offset;
string text = CurrentContext.Document.GetText(line);
int start = 0;
int index;
while ((index = text.IndexOf("AvalonEdit", start)) >= 0) {
base.ChangeLinePart(
lineStartOffset + index, // startOffset
lineStartOffset + index + 10, // endOffset
(VisualLineElement element) => {
// This lambda gets called once for every VisualLineElement
// between the specified offsets.
Typeface tf = element.TextRunProperties.Typeface;
// Replace the typeface with a modified version of
// the same typeface
element.TextRunProperties.SetTypeface(new Typeface(
tf.FontFamily,
FontStyles.Italic,
FontWeights.Bold,
tf.Stretch
));
});
start = index + 1; // search for next occurrence
}
}
protected override void ColorizeLine(DocumentLine line)
{
var sections = _textEditor.OnHighlightLine(line);
if (sections != null)
foreach (var section in sections)
ChangeLinePart(section.Offset, section.Offset + section.Length, element => ApplyColorToElement(element, section.Color));
}
private void CaretPositionChanged(object sender, EventArgs e)
{
colors.Clear();
if (!Settings.Instance.ShowColorPreviewWhenCaretIsOnColorString)
return;
if (!tab.Editor.TextArea.Selection.IsEmpty)
return;
line = tab.Editor.Document.GetLineByOffset(tab.Editor.CaretOffset);
var offset = tab.Editor.CaretOffset - line.Offset;
var content = tab.Editor.Document.GetText(line);
foreach (Match match in Regex.Matches(content, "\\#([A-Fa-f0-9]{6})([A-Fa-f0-9]{2})?"))
{
// check offset
if (match.Index > offset || match.Index + match.Length < offset)
continue;
// add it
colors.Add(new ColorMatches(match, match.Value.ToColor()));
}
}
/// <inheritdoc/>
protected override void Colorize(ITextRunConstructionContext context)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
CurrentContext = context;
currentDocumentLine = context.VisualLine.FirstDocumentLine;
firstLineStart = currentDocumentLineStartOffset = currentDocumentLine.Offset;
currentDocumentLineEndOffset = currentDocumentLineStartOffset + currentDocumentLine.Length;
if (context.VisualLine.FirstDocumentLine == context.VisualLine.LastDocumentLine)
{
ColorizeLine(currentDocumentLine);
}
else
{
ColorizeLine(currentDocumentLine);
// ColorizeLine modifies the visual line elements, loop through a copy of the line elements
foreach (VisualLineElement e in context.VisualLine.Elements.ToArray())
{
int elementOffset = firstLineStart + e.RelativeTextOffset;
if (elementOffset >= currentDocumentLineEndOffset)
{
currentDocumentLine = context.Document.GetLineByOffset(elementOffset);
currentDocumentLineStartOffset = currentDocumentLine.Offset;
currentDocumentLineEndOffset = currentDocumentLineStartOffset + currentDocumentLine.Length;
ColorizeLine(currentDocumentLine);
}
}
}
currentDocumentLine = null;
CurrentContext = null;
}
public ClassMemberBookmark(IMember member, TextDocument document)
{
this.member = member;
int lineNr = member.Region.BeginLine;
if (document != null && lineNr > 0 && lineNr <= document.LineCount)
this.line = document.GetLineByNumber(lineNr);
}
protected override void ColorizeLine(ICSharpCode.AvalonEdit.Document.DocumentLine line)
{
if (mEditor.TextArea.Caret.Line != line.LineNumber)
{
return;
}
string text = CurrentContext.Document.GetText(line);
foreach (Match m in wordEx.Matches(text))
{
string w = m.Groups[0].Value;
bool correct = NHunspellWrapper.Instance.Hunspeller.Spell(w);
if (correct)
{
continue;
}
List <string> suggestions = NHunspellWrapper.Instance.Hunspeller.Suggest(w);
base.ChangeLinePart(
line.Offset + m.Index, // startOffset
line.Offset + m.Index + m.Length, // endOffset
(VisualLineElement element) =>
{
element.TextRunProperties.SetTextDecorations(collection);
});
}
}
protected override void ColorizeLine(ICSharpCode.AvalonEdit.Document.DocumentLine line)
{
if (!line.IsDeleted && line.LineNumber == lineNumber)
{
ChangeLinePart(line.Offset, line.EndOffset, ApplyChanges);
}
}
internal HeightTreeNode(DocumentLine documentLine, double height)
{
this.documentLine = documentLine;
this.totalCount = 1;
this.lineNode = new HeightTreeLineNode(height);
this.totalHeight = height;
}
void ILineTracker.BeforeRemoveLine(DocumentLine line)
{
ILineTracker targetTracker = targetObject.Target as ILineTracker;
if (targetTracker != null)
targetTracker.BeforeRemoveLine(line);
else
Deregister();
}
private bool IsEmpty( DocumentLine dl )
{
for ( int i = dl.Offset; i<dl.EndOffset; i++){
char ch = ta.Document.GetCharAt(i);
if ((ch!=' ')&&(ch!='\t')) return false;
}
return true;
}
void ILineTracker.SetLineLength(DocumentLine line, int newTotalLength)
{
CheckIsHighlighting();
int number = line.LineNumber;
isValid[number] = false;
if (number < firstInvalidLine)
firstInvalidLine = number;
}
void ILineTracker.SetLineLength(DocumentLine line, int newTotalLength)
{
ILineTracker targetTracker = targetObject.Target as ILineTracker;
if (targetTracker != null)
targetTracker.SetLineLength(line, newTotalLength);
else
Deregister();
}
void ILineTracker.LineInserted(DocumentLine insertionPos, DocumentLine newLine)
{
ILineTracker targetTracker = targetObject.Target as ILineTracker;
if (targetTracker != null)
targetTracker.LineInserted(insertionPos, newLine);
else
Deregister();
}
public bool CommentLine(TextDocument document, DocumentLine documentLine)
{
if (Mode == CommentMode.BeginOfLine)
{
return CommentAtBeginOfLine(document, documentLine);
}
return CommentAtBeginOfText(document, documentLine);
}
/// <summary>
/// Retrieve completion suggestions
/// </summary>
/// <param name="completionWord">Word to complete</param>
/// <param name="content">Script that we're working with</param>
/// <param name="lineContent">Content of the current line</param>
/// <param name="line">Line object from AvaloneEdit</param>
/// <param name="runbookToken">Token containing the name of the runbook (if not runbook, null)</param>
/// <param name="position">Caret offset</param>
/// <param name="triggerChar">Not used</param>
/// <param name="triggerTag">Counter</param>
public void GetCompletionData(string completionWord, string content, string lineContent, DocumentLine line, Token runbookToken, int position, char? triggerChar, long triggerTag)
{
if (_requestTrigger != 0 && triggerTag <= _requestTrigger)
return;
DismissGetCompletionResults();
ProcessCompletion(content, triggerChar, completionWord, runbookToken, position, triggerTag);
}
internal CollapsedLineSection(HeightTree heightTree, DocumentLine start, DocumentLine end)
{
this.heightTree = heightTree;
this.start = start;
this.end = end;
#if DEBUG
this.ID = "#" + (nextId++);
#endif
}
bool IsBracketOnly(TextDocument document, DocumentLine documentLine)
{
var lineText = document.GetText(documentLine).Trim();
return lineText == "{" || string.IsNullOrEmpty(lineText)
|| lineText.StartsWith("//", StringComparison.Ordinal)
|| lineText.StartsWith("/*", StringComparison.Ordinal)
|| lineText.StartsWith("*", StringComparison.Ordinal)
|| lineText.StartsWith("'", StringComparison.Ordinal);
}
public HighlightTask(ITextEditor editor, DocumentLine currentLine, TextView textView)
{
this.fileName = editor.FileName;
this.textView = textView;
this.snapshot = editor.Document.CreateSnapshot();
this.lineText = textView.Document.GetText(currentLine);
this.offset = currentLine.Offset;
this.task = new Task(Process);
}
void ILineTracker.LineInserted(DocumentLine insertionPos, DocumentLine newLine)
{
CheckIsHighlighting();
Debug.Assert(insertionPos.LineNumber + 1 == newLine.LineNumber);
int lineNumber = newLine.LineNumber;
storedSpanStacks.Insert(lineNumber, null);
isValid.Insert(lineNumber, false);
if (lineNumber < firstInvalidLine)
firstInvalidLine = lineNumber;
}
/// <inheritdoc/>
protected override void ColorizeLine(DocumentLine line)
{
var sections = richTextModel.GetHighlightedSections(line.Offset, line.Length);
foreach (HighlightedSection section in sections) {
if (HighlightingColorizer.IsEmptyColor(section.Color))
continue;
ChangeLinePart(section.Offset, section.Offset + section.Length,
visualLineElement => HighlightingColorizer.ApplyColorToElement(visualLineElement, section.Color, CurrentContext));
}
}
public override void IndentLine(TextDocument textDocument, DocumentLine line)
{
TextDocumentAccessor documentAccessor = new TextDocumentAccessor(textDocument, line.LineNumber, line.LineNumber);
Indent(documentAccessor, false);
if (documentAccessor.Text.Length == 0)
{
base.IndentLine(textDocument, line);
}
}
private string GetContinuationType(DocumentLine line)
{
if (line == null) return string.Empty;
var text = _editor.Document.GetText(line).TrimStart();
if (text.StartsWith(Gherkin.Given)) return Gherkin.Given;
if (text.StartsWith(Gherkin.When)) return Gherkin.When;
if (text.StartsWith(Gherkin.Then)) return Gherkin.Then;
if (Gherkin.FunctionKeywords.Any(f => text.StartsWith(f))) return string.Empty;
return GetContinuationType(line.PreviousLine);
}
protected override void ColorizeLine(DocumentLine line)
{
var parts = _model.GetStylesForRange(line.Offset, line.EndOffset);
foreach (var part in parts)
{
switch (part.Style)
{
case ColoredPartStyle.Bold:
ChangeLinePart(part.Begin, part.End, element =>
{
var tf = element.TextRunProperties.Typeface;
tf = new Typeface(tf.FontFamily, tf.Style, FontWeights.Bold, tf.Stretch);
element.TextRunProperties.SetTypeface(tf);
});
break;
case ColoredPartStyle.Header:
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetForegroundBrush(Brushes.Red));
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetFontRenderingEmSize(18));
break;
case ColoredPartStyle.IdeaCaption:
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetForegroundBrush(Brushes.Green));
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetTextDecorations(TextDecorations.Underline));
//ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetFontRenderingEmSize(8));
break;
case ColoredPartStyle.Idea:
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetForegroundBrush(Brushes.Blue));
break;
case ColoredPartStyle.SelectedIdea:
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetForegroundBrush(Brushes.Blue));
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetBackgroundBrush(Brushes.AliceBlue));
break;
case ColoredPartStyle.Comment:
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetForegroundBrush(Brushes.Green));
break;
case ColoredPartStyle.SelectedComment:
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetForegroundBrush(Brushes.Green));
ChangeLinePart(part.Begin, part.End, element => element.TextRunProperties.SetBackgroundBrush(Brushes.AliceBlue));
break;
default:
throw new ArgumentOutOfRangeException();
//ChangeLinePart(part.Begin, part.End, element =>
//{
// var tf = element.TextRunProperties.Typeface;
// element.TextRunProperties.SetTypeface(new Typeface(
// tf.FontFamily,
// FontStyles.Italic,
// FontWeights.Bold,
// tf.Stretch
// ));
//});
}
}
}
public override void IndentLine(TextDocument document, DocumentLine line)
{
var lineNumber = line.LineNumber;
var textDocumentAccessor = new TextDocumentAccessor(document, lineNumber, lineNumber);
Indent(textDocumentAccessor, false);
var text = textDocumentAccessor.Text;
if (text.Length == 0)
{
base.IndentLine(document, line);
}
}
protected override void ColorizeLine(DocumentLine line)
{
var ast = _abstractSyntaxTree;
if (ast == null) return;
var theme = _theme;
if (theme == null) return;
var start = line.Offset;
var end = line.EndOffset;
var leadingSpaces = CurrentContext.GetText(start, end - start).Text.TakeWhile(char.IsWhiteSpace).Count();
Func<Theme, Highlight> highlighter;
foreach (var block in EnumerateSpanningBlocks(ast, start, end))
{
if (BlockHighlighter.TryGetValue(block.Tag, out highlighter))
{
var magnify = double.NaN;
if (block.HeaderLevel == 1) magnify = theme.Header1Height;
if (block.HeaderLevel == 2) magnify = theme.Header2Height;
var length = (block.Tag == BlockTag.ListItem)
? Math.Min(block.SourceLength, block.ListData.Padding)
: block.SourceLength;
ApplyLinePart(highlighter(theme), block.SourcePosition, length, start, end, leadingSpaces, magnify);
}
foreach (var inline in EnumerateInlines(block.InlineContent)
.TakeWhile(il => il.SourcePosition < end)
.Where(il => InlineHighlighter.TryGetValue(il.Tag, out highlighter)))
{
var position = inline.SourcePosition;
var length = inline.SourceLength;
if ((inline.Tag == InlineTag.Link || inline.Tag == InlineTag.Image)
&& inline.FirstChild?.LiteralContent != null
&& inline.FirstChild.LiteralContent != inline.TargetUrl)
{
var literal = inline.FirstChild.LastSibling;
var urlPosition = literal.SourcePosition + literal.SourceLength + 1;
var urlLength = inline.SourcePosition + inline.SourceLength - urlPosition;
if (urlLength > 0) // check for <*****@*****.**> style links
{
position = urlPosition;
length = urlLength;
}
}
// inlines don't magnify
ApplyLinePart(highlighter(theme), position, length, start, end, leadingSpaces, double.NaN);
}
}
}
private IList<HighlightedSection> OnHighlightLine(DocumentLine line)
{
var highlightLineHandler = HighlightLine;
if (highlightLineHandler != null)
{
var args = new HighlightLineEventArgs(line);
highlightLineHandler(this, args);
return args.Sections;
}
return null;
}
protected override void ColorizeLine(ICSharpCode.AvalonEdit.Document.DocumentLine line)
{
if (!line.IsDeleted && line.LineNumber == lineNumber)
{
try
{
ChangeLinePart(startOffset, line.EndOffset, ApplyChanges);
}
catch (ArgumentOutOfRangeException e)
{
ChangeLinePart(line.Offset, line.EndOffset, ApplyChanges);
}
}
}
protected override void ColorizeLine(ICSharpCode.AvalonEdit.Document.DocumentLine line)
{
if (desiredList == null)
{
return;
}
foreach (Description d in desiredList)
{
if (line.LineNumber == d.Line)
{
ChangeLinePart(line.Offset + d.Col, line.Offset + d.Col + d.Length, ApplyChanges);
}
}
}
void textEditor_TextArea_TextEntering(object sender, TextCompositionEventArgs e)
{
// The following code auto-completes \begin{something} +<return> by inserting \end{something}
// This autocompletion can be turned off in the settings
if (e.Text == "\n")
{
if (CompleteBegins)
{
ICSharpCode.AvalonEdit.Document.DocumentLine l = Document.GetLineByOffset(CaretOffset);
//if (l.LineNumber > 0) //todo 1?
{
//get current line
string s = Document.GetText(l.Offset, l.Length).Trim();
//and check if it contains \begin{
Match m = _beginRegex.Match(s);
if (m.Success && m.Groups["tag"] != null && m.Groups["content"] != null)
{
string tag = m.Groups["tag"].Value, content = m.Groups["content"].Value;
int cp = CaretOffset;
string insert = "\\end{" + tag + "}";
//only insert if document does not already hold the corresponding \end{}
if (Text.IndexOf(insert, cp) == -1)
{
Document.Insert(l.Offset + l.Length, "\r\n" + insert);
CaretOffset = cp;
}
}
}
}
}
if (e.Text.Length > 0 && completionWindow != null)
{
if (!char.IsLetterOrDigit(e.Text[0]))
{
// Whenever a non-letter is typed while the completion window is open,
// insert the currently selected element.
completionWindow.CompletionList.RequestInsertion(e);
}
}
// Do not set e.Handled=true.
// We still want to insert the character that was typed.
}
protected override void ColorizeLine(ICSharpCode.AvalonEdit.Document.DocumentLine line)
{
if (!line.IsDeleted && line.LineNumber == lineNumber)
{
//ChangeLinePart(line.Offset, line.EndOffset, ApplyChanges);
foreach (var item in snippetTokens)
{
if (line.Offset > startoffset + item.index)
{
Clear();
return;
}
if (startoffset + item.index + item.Length > line.EndOffset)
{
Clear();
return;
}
ChangeLinePart(startoffset + item.index, startoffset + item.index + item.Length, ApplyChanges);
}
}
}
public void Insert(int offset, ITextSource text, object ob)
{
bool shouldSwap = false;
DocumentLine prev = null;
DocumentLine line = documentLineTree.GetByOffset(offset);
int lineOffset = line.Offset;
if (line.PreviousLine != null)
{
if (line.PreviousLine.obs != null)
{
prev = line.PreviousLine;
shouldSwap = true;
}
}
Debug.Assert(offset <= lineOffset + line.TotalLength);
if (offset > lineOffset + line.Length)
{
Debug.Assert(line.DelimiterLength == 2);
// we are inserting in the middle of a delimiter
// shorten line
SetLineLength(line, line.TotalLength - 1);
// add new line
line = InsertLineAfter(line, 1);
line = SetLineLength(line, 1);
}
SimpleSegment ds = NewLineFinder.NextNewLine(text, 0);
if (ds == SimpleSegment.Invalid)
{
// no newline is being inserted, all text is inserted in a single line
//line.InsertedLinePart(offset - line.Offset, text.Length);
line = SetLineLength(line, line.TotalLength + text.TextLength);
return;
}
//DocumentLine firstLine = line;
//firstLine.InsertedLinePart(offset - firstLine.Offset, ds.Offset);
int lastDelimiterEnd = 0;
while (ds != SimpleSegment.Invalid)
{
// split line segment at line delimiter
int lineBreakOffset = offset + ds.Offset + ds.Length;
lineOffset = line.Offset;
int lengthAfterInsertionPos = lineOffset + line.TotalLength - (offset + lastDelimiterEnd);
line = SetLineLength(line, lineBreakOffset - lineOffset);
DocumentLine newLine = InsertLineAfter(line, lengthAfterInsertionPos);
newLine = SetLineLength(newLine, lengthAfterInsertionPos);
line = newLine;
lastDelimiterEnd = ds.Offset + ds.Length;
ds = NewLineFinder.NextNewLine(text, lastDelimiterEnd);
}
//firstLine.SplitTo(line);
// insert rest after last delimiter
if (lastDelimiterEnd != text.TextLength)
{
//line.InsertedLinePart(0, text.Length - lastDelimiterEnd);
SetLineLength(line, line.TotalLength + text.TextLength - lastDelimiterEnd);
}
}
public static ISegment GetTrailingWhitespace(DocumentLine documentLine)
{
return(GetTrailingWhitespace(documentLine.Document, documentLine));
}
// optimization note: I tried packing color and isDeleted into a single byte field, but that
// actually increased the memory requirements. The JIT packs two bools and a byte (delimiterSize)
// into a single DWORD, but two bytes get each their own DWORD. Three bytes end up in the same DWORD, so
// apparently the JIT only optimizes for memory when there are at least three small fields.
// Currently, DocumentLine takes 36 bytes on x86 (8 byte object overhead, 3 pointers, 3 ints, and another DWORD
// for the small fields).
// TODO: a possible optimization would be to combine 'totalLength' and the small fields into a single uint.
// delimiterSize takes only two bits, the two bools take another two bits; so there's still
// 28 bits left for totalLength. 268435455 characters per line should be enough for everyone :)
/// <summary>
/// Resets the line to enable its reuse after a document rebuild.
/// </summary>
internal void ResetLine()
{
totalLength = delimiterLength = 0;
isDeleted = color = false;
left = right = parent = null;
}
public void Remove(int offset, int length)
{
Debug.Assert(length >= 0);
if (length == 0)
{
return;
}
DocumentLine startLine = documentLineTree.GetByOffset(offset);
int startLineOffset = startLine.Offset;
Debug.Assert(offset < startLineOffset + startLine.TotalLength);
if (offset > startLineOffset + startLine.Length)
{
Debug.Assert(startLine.DelimiterLength == 2);
// we are deleting starting in the middle of a delimiter
// remove last delimiter part
SetLineLength(startLine, startLine.TotalLength - 1);
// remove remaining text
Remove(offset, length - 1);
return;
}
if (offset + length < startLineOffset + startLine.TotalLength)
{
// just removing a part of this line
//startLine.RemovedLinePart(ref deferredEventList, offset - startLineOffset, length);
SetLineLength(startLine, startLine.TotalLength - length);
return;
}
// merge startLine with another line because startLine's delimiter was deleted
// possibly remove lines in between if multiple delimiters were deleted
int charactersRemovedInStartLine = startLineOffset + startLine.TotalLength - offset;
Debug.Assert(charactersRemovedInStartLine > 0);
//startLine.RemovedLinePart(ref deferredEventList, offset - startLineOffset, charactersRemovedInStartLine);
DocumentLine endLine = documentLineTree.GetByOffset(offset + length);
if (endLine == startLine)
{
// special case: we are removing a part of the last line up to the
// end of the document
SetLineLength(startLine, startLine.TotalLength - length);
return;
}
int endLineOffset = endLine.Offset;
int charactersLeftInEndLine = endLineOffset + endLine.TotalLength - (offset + length);
//endLine.RemovedLinePart(ref deferredEventList, 0, endLine.TotalLength - charactersLeftInEndLine);
//startLine.MergedWith(endLine, offset - startLineOffset);
// remove all lines between startLine (excl.) and endLine (incl.)
DocumentLine tmp = startLine.NextLine;
DocumentLine lineToRemove;
do
{
lineToRemove = tmp;
tmp = tmp.NextLine;
RemoveLine(lineToRemove);
} while (lineToRemove != endLine);
SetLineLength(startLine, startLine.TotalLength - charactersRemovedInStartLine + charactersLeftInEndLine);
}
/// <summary>
/// Gets the location from an offset.
/// </summary>
/// <seealso cref="GetOffset(TextLocation)"/>
public TextLocation GetLocation(int offset)
{
DocumentLine line = GetLineByOffset(offset);
return(new TextLocation(line.LineNumber, offset - line.Offset + 1));
}