TextSegment GetWordRangeAtPosition(int column, IDocumentLine line)
{
string text = Editor.GetLineText(line);
string pattern = @"(-?\d*\.\d\w*)|([^\[\{\]\}\:\""\,\s]+)";
MatchCollection matches = Regex.Matches(text, pattern, RegexOptions.Singleline);
foreach (Match match in matches)
{
string word = match.Value;
int endWord = match.Index + match.Length;
int startWord = match.Index;
int startColumn = startWord + 1;
int endColumn = endWord + 1;
if (startColumn <= column && column <= endColumn)
{
Console.WriteLine("GetWordRangeAtPosition: '{0}' start={1},length={2}", word, startColumn, word.Length);
return(new TextSegment(startColumn, word.Length));
}
}
return(new TextSegment());
}
void GetLineFromActiveTextEditor()
{
int lineNumber = activeTextEditor.Caret.Line;
IDocumentLine documentLine = activeTextEditor.Document.GetLineByNumber(lineNumber);
lineFromActiveTextEditor = activeTextEditor.Document.GetText(documentLine);
}
/// <summary>
/// Checks if deferral code has been changed or removed from the line.
/// If so, ensures the removal of any associated deferral schedules.
/// </summary>
public static void DeleteAssociatedScheduleIfDeferralCodeChanged(
PXGraph graph,
IDocumentLine documentLine)
{
IDocumentLine oldLine;
// Obtain the document line last saved into the database
// to check if the new line's deferral code differs from it.
// -
switch (documentLine.Module)
{
case GL.BatchModule.AR:
oldLine = GetOriginal <ARTran>(graph.Caches[typeof(ARTran)], documentLine as ARTran);
break;
case GL.BatchModule.AP:
oldLine = GetOriginal <APTran>(graph.Caches[typeof(APTran)], documentLine as APTran);
break;
default:
throw new PXException(Messages.UnexpectedDocumentLineModule);
}
DeleteAssociatedScheduleIfDeferralCodeChanged(graph, documentLine, oldLine);
}
void EditorKeyPress(object sender, KeyEventArgs e)
{
if (e.Key == Key.Tab || e.Key == Key.Enter || e.Key == Key.Return)
{
using (editor.Document.OpenUndoGroup())
{
// is there a better way to calculate the optimal insertion point?
DomRegion region = resolveResult.CallingMember.BodyRegion;
editor.Caret.Line = region.EndLine;
editor.Caret.Column = region.EndColumn;
editor.Document.Insert(editor.Caret.Offset, this.newHandlerCode);
editor.Language.FormattingStrategy.IndentLines(editor, region.EndLine, editor.Caret.Line);
IDocumentLine line = editor.Document.GetLine(editor.Caret.Line - 1);
int indentationLength = DocumentUtilitites.GetWhitespaceAfter(editor.Document, line.Offset).Length;
editor.Select(line.Offset + indentationLength, line.Length - indentationLength);
}
e.Handled = true;
}
// detatch our keydown filter to return to the normal processing state
RemoveEventHandlers();
}
/// <summary>
/// Default implementation for multiline comments.
/// </summary>
protected void SurroundSelectionWithBlockComment(ITextEditor editor, string blockStart, string blockEnd)
{
using (editor.Document.OpenUndoGroup()) {
int startOffset = editor.SelectionStart;
int endOffset = editor.SelectionStart + editor.SelectionLength;
if (editor.SelectionLength == 0)
{
IDocumentLine line = editor.Document.GetLineByOffset(editor.SelectionStart);
startOffset = line.Offset;
endOffset = line.Offset + line.Length;
}
BlockCommentRegion region = FindSelectedCommentRegion(editor, blockStart, blockEnd);
if (region != null)
{
editor.Document.Remove(region.EndOffset, region.CommentEnd.Length);
editor.Document.Remove(region.StartOffset, region.CommentStart.Length);
}
else
{
editor.Document.Insert(endOffset, blockEnd);
editor.Document.Insert(startOffset, blockStart);
}
}
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
var document = editor.Document;
var engine = CreateIndentEngine(document, editor.ToEditorOptions());
IndentSingleLine(engine, document, line);
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
if (line.LineNumber == 1) {
base.IndentLine(editor, line);
return;
}
IDocument document = editor.Document;
IDocumentLine previousLine = document.GetLine(line.LineNumber - 1);
string previousLineText = previousLine.Text.Trim();
if (previousLineText.EndsWith(":")) {
IncreaseLineIndent(editor, line);
} else if (previousLineText == "pass") {
DecreaseLineIndent(editor, line);
} else if ((previousLineText == "return") || (previousLineText.StartsWith("return "))) {
DecreaseLineIndent(editor, line);
} else if ((previousLineText == "raise") || (previousLineText.StartsWith("raise "))) {
DecreaseLineIndent(editor, line);
} else if (previousLineText == "break") {
DecreaseLineIndent(editor, line);
} else {
base.IndentLine(editor, line);
}
}
async Task <HighlightState> GetStateAsync(IDocumentLine line, CancellationToken cancellationToken = default)
{
var pl = line?.PreviousLine;
if (pl == null)
{
return(HighlightState.CreateNewState(this));
}
if (stateCache.Count == 0)
{
stateCache.Add(HighlightState.CreateNewState(this));
}
var ln = line.LineNumber;
if (ln <= stateCache.Count)
{
return(stateCache [ln - 1].Clone());
}
var lastState = stateCache [stateCache.Count - 1];
var cur = Document.GetLine(stateCache.Count);
if (cur != null && cur.Offset < line.Offset)
{
do
{
var high = new Highlighter(this, lastState.Clone());
await high.GetColoredSegments(Document, cur.Offset, cur.LengthIncludingDelimiter, cancellationToken);
stateCache.Add(lastState = high.State);
cur = cur.NextLine;
} while (cur != null && cur.Offset < line.Offset);
}
return(lastState.Clone());
}
void ModifyLineIndent(ITextEditor editor, IDocumentLine line, bool increaseIndent)
{
string indentation = GetLineIndentation(editor, line.LineNumber - 1);
indentation = GetNewLineIndentation(indentation, editor.Options.IndentationString, increaseIndent);
string newIndentedText = indentation + line.Text;
editor.Document.Replace(line.Offset, line.Length, newIndentedText);
}
/// <summary>
/// Gets the line containing the character at a specific offset in the document
/// (first char at index 0 at the beginning of document)
/// </summary>
public ITextLine GetLineByOffset(int offset, out int indexOfCharInLine)
{
IDocumentLine documentLine = _avalonEditTextDocument.GetLineByOffset(offset);
indexOfCharInLine = offset - documentLine.Offset;
return(BuildTextLineFromDocumentLine(documentLine));
}
/// <summary>
/// Checks whether the sequence point can be added to the document.
/// </summary>
/// <remarks>
/// Checks for invalid start lines, start columns, end columns and end
/// lines that cannot fit in the document.</remarks>
bool IsValidSequencePoint(IDocument document, CodeCoverageSequencePoint sequencePoint)
{
if (sequencePoint.Line <= 0 || sequencePoint.EndLine <= 0 || sequencePoint.Column <= 0 || sequencePoint.EndColumn <= 0)
{
return(false);
}
else if (sequencePoint.Line > document.TotalNumberOfLines)
{
return(false);
}
else if (sequencePoint.EndLine > document.TotalNumberOfLines)
{
return(false);
}
else if (sequencePoint.Line == sequencePoint.EndLine && sequencePoint.Column > sequencePoint.EndColumn)
{
return(false);
}
else
{
// Check the columns exist on the line.
IDocumentLine lineSegment = document.GetLine(sequencePoint.Line);
if (sequencePoint.Column > lineSegment.Length)
{
return(false);
}
IDocumentLine endLineSegment = document.GetLine(sequencePoint.EndLine);
if (sequencePoint.EndColumn > endLineSegment.Length + 1)
{
return(false);
}
}
return(true);
}
static void MarkResult(List <ITextEditor> textAreas, SearchResultMatch result)
{
ITextEditor textArea = OpenTextArea(result.FileName);
if (textArea != null)
{
if (!textAreas.Contains(textArea))
{
textAreas.Add(textArea);
}
textArea.Caret.Offset = result.Offset;
IDocumentLine segment = textArea.Document.GetLineForOffset(result.Offset);
int lineNr = segment.LineNumber;
foreach (var bookmark in BookmarkManager.GetBookmarks(result.FileName))
{
if (bookmark.CanToggle && bookmark.LineNumber == lineNr)
{
// bookmark or breakpoint already exists at that line
return;
}
}
BookmarkManager.AddMark(new Bookmark(result.FileName, textArea.Document.OffsetToPosition(result.Offset)));
}
}
private void Reformat(CustomDialog dialog)
{
ITextEditor editor = UttCodeEditor.GetActiveTextEditor();
string selectedText = editor.SelectedText;
string[] xmlLines = FormatXml(GetSelectedString()).Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
IDocumentLine documentLine = editor.Document.GetLineForOffset(editor.SelectionStart);
string lineText = documentLine.Text;
string indentation = lineText.Substring(0, lineText.Length - lineText.TrimStart().Length);
StringBuilder formattedText = new StringBuilder();
foreach (string line in xmlLines)
{
formattedText.AppendLine(indentation + "\"" + line.Replace("\"", "\\\"") + "\"");
}
formattedText.Remove(formattedText.Length - Environment.NewLine.Length, Environment.NewLine.Length);
if (!selectedText.TrimStart().StartsWith("\""))
{
formattedText.Insert(0, "\"" + Environment.NewLine);
}
if (!selectedText.TrimEnd().EndsWith("\""))
{
formattedText.Append(Environment.NewLine + indentation + "\"");
}
DocumentUtilitites.FindNextWordStart(editor.Document, documentLine.Offset);
editor.Document.Replace(editor.SelectionStart, editor.SelectionLength, formattedText.ToString());
dialog.Close();
}
public void SortLines(IDocument document, int startLine, int endLine, StringComparer comparer, bool removeDuplicates)
{
List <string> lines = new List <string>();
for (int i = startLine; i <= endLine; ++i)
{
IDocumentLine line = document.GetLineByNumber(i);
lines.Add(document.GetText(line.Offset, line.Length));
}
lines.Sort(comparer);
if (removeDuplicates)
{
lines = lines.Distinct(comparer).ToList();
}
using (document.OpenUndoGroup()) {
for (int i = 0; i < lines.Count; ++i)
{
IDocumentLine line = document.GetLineByNumber(startLine + i);
document.Replace(line.Offset, line.Length, lines[i]);
}
// remove removed duplicate lines
for (int i = startLine + lines.Count; i <= endLine; ++i)
{
IDocumentLine line = document.GetLineByNumber(startLine + lines.Count);
document.Remove(line.Offset, line.TotalLength);
}
}
}
/// <summary>
/// Replaces the text in a line.
/// If only whitespace at the beginning and end of the line was changed, this method
/// only adjusts the whitespace and doesn't replace the other text.
/// </summary>
public static void SmartReplaceLine(this IDocument document, IDocumentLine line, string newLineText)
{
if (document == null)
throw new ArgumentNullException("document");
if (line == null)
throw new ArgumentNullException("line");
if (newLineText == null)
throw new ArgumentNullException("newLineText");
string newLineTextTrim = newLineText.Trim(whitespaceChars);
string oldLineText = line.Text;
if (oldLineText == newLineText)
return;
int pos = oldLineText.IndexOf(newLineTextTrim, StringComparison.Ordinal);
if (newLineTextTrim.Length > 0 && pos >= 0) {
using (document.OpenUndoGroup()) {
// find whitespace at beginning
int startWhitespaceLength = 0;
while (startWhitespaceLength < newLineText.Length) {
char c = newLineText[startWhitespaceLength];
if (c != ' ' && c != '\t')
break;
startWhitespaceLength++;
}
// find whitespace at end
int endWhitespaceLength = newLineText.Length - newLineTextTrim.Length - startWhitespaceLength;
// replace whitespace sections
int lineOffset = line.Offset;
document.Replace(lineOffset + pos + newLineTextTrim.Length, line.Length - pos - newLineTextTrim.Length, newLineText.Substring(newLineText.Length - endWhitespaceLength));
document.Replace(lineOffset, pos, newLineText.Substring(0, startWhitespaceLength));
}
} else {
document.Replace(line.Offset, line.Length, newLineText);
}
}
void GetPreviousLine()
{
int lineNumber = line.LineNumber - 1;
previousLine = document.GetLine(lineNumber);
previousLineText = previousLine.Text.Trim();
}
public virtual ICompletionItemList GenerateCompletionList(ITextEditor editor, IProjectContent projectContent)
{
int caretLineNumber = editor.Caret.Line;
int caretColumn = editor.Caret.Column;
IDocumentLine caretLine = editor.Document.GetLine(caretLineNumber);
string lineText = caretLine.Text;
if (!lineText.Trim().StartsWith("///", StringComparison.Ordinal) &&
!lineText.Trim().StartsWith("'''", StringComparison.Ordinal))
{
return(null);
}
DefaultCompletionItemList list = new DefaultCompletionItemList();
foreach (string[] tag in commentTags)
{
list.Items.Add(new DefaultCompletionItem(tag[0])
{
Description = new SimpleDescription(tag[1])
});
}
list.SortItems();
return(list);
}
public HighlightedLine HighlightLine(int lineNumber)
{
IDocumentLine line = Document.GetLineByNumber(lineNumber);
var highlightedLine = new HighlightedLine(Document, line);
lineNumber--;
if (lineNumber >= SyntaxInfo.Count)
{
return(highlightedLine);
}
int lineOffset = line.Offset;
int pos = 0;
List <SyntaxSpan> spans = SyntaxInfo[lineNumber];
foreach (SyntaxSpan span in spans)
{
if (pos >= line.Length)
{
break;
}
highlightedLine.Sections.Add(new HighlightedSection
{
Offset = pos + lineOffset,
Length = Math.Min(span.Length, line.Length - pos),
Color = SyntaxInfo.Colors[span.FormatType]
});
pos += span.Length;
}
return(highlightedLine);
}
void InsertEventHandlerBeforeLine(IDocument doc, string eventHandler, IDocumentLine classEndLine)
{
string newContent = "\r\n" + eventHandler + "\r\n";
int offset = classEndLine.Offset;
doc.Insert(offset, newContent);
}
/// <summary>
/// Replaces the text in a line.
/// If only whitespace at the beginning and end of the line was changed, this method
/// only adjusts the whitespace and doesn't replace the other text.
/// </summary>
public static void SmartReplaceLine(this IDocument document, IDocumentLine line, string newLineText)
{
if (document == null)
throw new ArgumentNullException("document");
if (line == null)
throw new ArgumentNullException("line");
if (newLineText == null)
throw new ArgumentNullException("newLineText");
string newLineTextTrim = newLineText.Trim(whitespaceChars);
string oldLineText = document.GetText(line);
if (oldLineText == newLineText)
return;
int pos = oldLineText.IndexOf(newLineTextTrim, StringComparison.Ordinal);
if (newLineTextTrim.Length > 0 && pos >= 0) {
using (document.OpenUndoGroup()) {
// find whitespace at beginning
int startWhitespaceLength = 0;
while (startWhitespaceLength < newLineText.Length) {
char c = newLineText[startWhitespaceLength];
if (c != ' ' && c != '\t')
break;
startWhitespaceLength++;
}
// find whitespace at end
int endWhitespaceLength = newLineText.Length - newLineTextTrim.Length - startWhitespaceLength;
// replace whitespace sections
int lineOffset = line.Offset;
document.Replace(lineOffset + pos + newLineTextTrim.Length, line.Length - pos - newLineTextTrim.Length, newLineText.Substring(newLineText.Length - endWhitespaceLength));
document.Replace(lineOffset, pos, newLineText.Substring(0, startWhitespaceLength));
}
} else {
document.Replace(line.Offset, line.Length, newLineText);
}
}
static void Apply_TrimTrailingWhitespace(
TextEditor editor,
IDocumentLine line,
List <TextChange> changes)
{
int offset = line.EndOffset;
for (; offset > line.Offset; --offset)
{
char c = editor.GetCharAt(offset - 1);
if (!char.IsWhiteSpace(c))
{
break;
}
}
TextChange change = ChangeFromBounds(offset, line.EndOffset, string.Empty);
if (change.Span.Length == 0)
{
return;
}
changes.Add(change);
}
static WixDocumentLineSegment ConvertRegionToSingleLineSegment(IDocument document, DomRegion region)
{
IDocumentLine documentLine = document.GetLineByNumber(region.BeginLine);
return(new WixDocumentLineSegment(documentLine.Offset + region.BeginColumn - 1,
region.EndColumn - region.BeginColumn + 1));
}
void HighlightLineAndUpdateTreeList(IDocumentLine line, int lineNumber)
{
//Debug.WriteLine("Highlight line " + lineNumber + (highlightedLine != null ? "" : " (span stack only)"));
spanStack = storedSpanStacks[lineNumber - 1];
HighlightLineInternal(line);
if (!EqualSpanStacks(spanStack, storedSpanStacks[lineNumber]))
{
isValid[lineNumber] = true;
//Debug.WriteLine("Span stack in line " + lineNumber + " changed from " + storedSpanStacks[lineNumber] + " to " + spanStack);
storedSpanStacks[lineNumber] = spanStack;
if (lineNumber + 1 < isValid.Count)
{
isValid[lineNumber + 1] = false;
firstInvalidLine = lineNumber + 1;
}
else
{
firstInvalidLine = int.MaxValue;
}
if (lineNumber + 1 < document.LineCount)
{
OnHighlightStateChanged(lineNumber + 1, lineNumber + 1);
}
}
else if (firstInvalidLine == lineNumber)
{
isValid[lineNumber] = true;
firstInvalidLine = isValid.IndexOf(false);
if (firstInvalidLine < 0)
{
firstInvalidLine = int.MaxValue;
}
}
}
static int FindEndStatementAroundOffset(IDocument document, int offset, out VBStatement statement)
{
IDocumentLine line = document.GetLineForOffset(offset);
string interestingText = line.Text.TrimLine().Trim(' ', '\t');
//LoggingService.Debug("text: '" + interestingText + "'");
foreach (VBStatement s in VBNetFormattingStrategy.Statements)
{
Match match = Regex.Matches(interestingText, s.EndRegex, RegexOptions.Singleline | RegexOptions.IgnoreCase).OfType <Match>().FirstOrDefault();
if (match != null)
{
//LoggingService.DebugFormatted("Found end statement at offset {1}: {0}", s, offset);
statement = s;
int result = match.Index + (line.Length - line.Text.TrimStart(' ', '\t').Length) + line.Offset;
if (offset >= result && offset <= (result + match.Length))
{
return(result);
}
}
}
statement = null;
return(-1);
}
static bool TryDeclarationTypeInference(ITextEditor editor, IDocumentLine curLine)
{
string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, new System.IO.StringReader(lineText));
if (lexer.NextToken().Kind != Tokens.Dim)
{
return(false);
}
if (lexer.NextToken().Kind != Tokens.Identifier)
{
return(false);
}
if (lexer.NextToken().Kind != Tokens.As)
{
return(false);
}
Token t1 = lexer.NextToken();
if (t1.Kind != Tokens.QuestionMark)
{
return(false);
}
Token t2 = lexer.NextToken();
if (t2.Kind != Tokens.Assign)
{
return(false);
}
string expr = lineText.Substring(t2.Location.Column);
LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
editor.Caret.Line,
t2.Location.Column, editor.FileName,
editor.Document.Text);
if (rr != null && rr.ResolvedType != null)
{
ClassFinder context = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.Caret.Line, t1.Location.Column);
VBNetAmbience ambience = new VBNetAmbience();
if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
{
ambience.ConversionFlags = ConversionFlags.None;
}
else
{
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames;
}
string typeName = ambience.Convert(rr.ResolvedType);
using (editor.Document.OpenUndoGroup()) {
int offset = curLine.Offset + t1.Location.Column - 1;
editor.Document.Remove(offset, 1);
editor.Document.Insert(offset, typeName);
}
editor.Caret.Column += typeName.Length - 1;
return(true);
}
return(false);
}
static bool IsSingleLine(int line, ITextEditor editor)
{
if (line < 1)
{
return(false);
}
IDocumentLine lineSeg = editor.Document.GetLine(line);
if (lineSeg == null)
{
return(false);
}
string text = lineSeg.Text;
if (text.TrimComments().Trim(' ', '\t', '\r', '\n').EndsWith("_", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// This method gets the line indentation.
/// </summary>
/// <param name = "line"></param>
/// <param name="doc">
/// The <see cref="IReadonlyTextDocument"/> the line belongs to.
/// </param>
/// <returns>
/// The indentation of the line (all whitespace chars up to the first non ws char).
/// </returns>
public static string GetIndentation(this IDocumentLine line, IReadonlyTextDocument doc)
{
if (line == null)
{
throw new ArgumentNullException(nameof(line));
}
if (doc == null)
{
throw new ArgumentNullException(nameof(doc));
}
var result = new StringBuilder();
int offset = line.Offset;
int max = Math.Min(offset + line.LengthIncludingDelimiter, doc.Length);
for (int i = offset; i < max; i++)
{
char ch = doc.GetCharAt(i);
if (ch != ' ' && ch != '\t')
{
break;
}
result.Append(ch);
}
return(result.ToString());
}
HighlightState GetState(IDocumentLine line)
{
var pl = line.PreviousLine;
if (pl == null)
{
return(HighlightState.CreateNewState(this));
}
if (stateCache.Count == 0)
{
stateCache.Add(HighlightState.CreateNewState(this));
}
var ln = line.LineNumber;
if (ln <= stateCache.Count)
{
return(stateCache [ln - 1].Clone());
}
var lastState = stateCache [stateCache.Count - 1];
var cur = Document.GetLine(stateCache.Count);
if (cur != null && cur.Offset < line.Offset)
{
do
{
var high = new Highlighter(this, lastState.Clone());
high.GetColoredSegments(Document, cur.Offset, cur.LengthIncludingDelimiter).Wait();
stateCache.Add(lastState = high.State);
cur = cur.NextLine;
} while (cur != null && cur.Offset < line.Offset);
}
return(lastState.Clone());
}
/// <summary>
/// Creates a new <see cref="FixedHighlighter"/> for a copy of a portion
/// of the input document (including the original highlighting).
/// </summary>
public static FixedHighlighter CreateView(IHighlighter highlighter, int offset, int endOffset)
{
var oldDocument = highlighter.Document;
// ReadOnlyDocument would be better; but displaying the view in AvalonEdit
// requires a TextDocument
var newDocument = new TextDocument(oldDocument.CreateSnapshot(offset, endOffset - offset));
var oldStartLine = oldDocument.GetLineByOffset(offset);
var oldEndLine = oldDocument.GetLineByOffset(endOffset);
int oldStartLineNumber = oldStartLine.LineNumber;
HighlightedLine[] newLines = new HighlightedLine[oldEndLine.LineNumber - oldStartLineNumber + 1];
highlighter.BeginHighlighting();
try {
for (int i = 0; i < newLines.Length; i++)
{
HighlightedLine oldHighlightedLine = highlighter.HighlightLine(oldStartLineNumber + i);
IDocumentLine newLine = newDocument.GetLineByNumber(1 + i);
HighlightedLine newHighlightedLine = new HighlightedLine(newDocument, newLine);
MoveSections(oldHighlightedLine.Sections, -offset, newLine.Offset, newLine.EndOffset, newHighlightedLine.Sections);
newHighlightedLine.ValidateInvariants();
newLines[i] = newHighlightedLine;
}
} finally {
highlighter.EndHighlighting();
}
return(new FixedHighlighter(newDocument, newLines));
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
LineIndenter indenter = CreateLineIndenter(editor, line);
if (!indenter.Indent()) {
base.IndentLine(editor, line);
}
}
void GetLineFromActiveTextEditor()
{
int lineNumber = activeTextEditor.Caret.Line;
IDocumentLine documentLine = activeTextEditor.Document.GetLine(lineNumber);
lineFromActiveTextEditor = documentLine.Text;
}
void GetPreviousLine()
{
int lineNumber = line.LineNumber - 1;
previousLine = document.GetLineByNumber(lineNumber);
previousLineText = document.GetText(previousLine).Trim();
}
public static void SetPosition(FileName fileName, IDocument document, int makerStartLine, int makerStartColumn, int makerEndLine, int makerEndColumn)
{
Remove();
startLine = makerStartLine;
startColumn = makerStartColumn;
endLine = makerEndLine;
endColumn = makerEndColumn;
if (startLine < 1 || startLine > document.TotalNumberOfLines)
{
return;
}
if (endLine < 1 || endLine > document.TotalNumberOfLines)
{
endLine = startLine;
endColumn = int.MaxValue;
}
if (startColumn < 1)
{
startColumn = 1;
}
IDocumentLine line = document.GetLine(startLine);
if (endColumn < 1 || endColumn > line.Length)
{
endColumn = line.Length;
}
instance = new CurrentLineBookmark(fileName, new Location(startColumn, startLine));
BookmarkManager.AddMark(instance);
}
/// <summary>
/// Creates a new HighlightedLine instance.
/// </summary>
public HighlightedLine(IDocument document, IDocumentLine documentLine)
{
//if (!document.Lines.Contains(documentLine))
// throw new ArgumentException("Line is null or not part of document");
Document = document ?? throw new ArgumentNullException(nameof(document));
DocumentLine = documentLine;
Sections = new NullSafeCollection <HighlightedSection>();
}
public EntityBookmark(IUnresolvedEntity entity, IDocument document)
{
this.entity = entity;
int lineNr = entity.Region.BeginLine;
if (document != null && lineNr > 0 && lineNr < document.LineCount) {
this.line = document.GetLineByNumber(lineNr);
}
}
public VBIndentationStrategy(ITextEditor editor, int start, int end)
: this()
{
this.editor = editor;
startLine = editor.Document.GetLine(start);
endLine = editor.Document.GetLine(end);
}
bool IsBracketOnly(IDocument document, IDocumentLine documentLine)
{
string 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 RubyLineIndenter(ITextEditor editor, IDocumentLine line)
: base(editor, line)
{
CreateDecreaseLineIndentStatements();
CreateDecreaseLineIndentStartsWithStatements();
CreateIncreaseLineIndentStatements();
CreateIncreaseLineIndentStartsWithStatements();
CreateIncreaseLineIndentEndsWithStatements();
CreateIncreaseLineIndentContainsStatements();
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
editor.Document.StartUndoableAction();
try {
TryIndent(editor, line.LineNumber, line.LineNumber);
} catch (XmlException ex) {
LoggingService.Debug(ex.ToString());
} finally {
editor.Document.EndUndoableAction();
}
}
/// <summary>
/// Updates <see cref="CurrentSpanStack"/> for the specified line in the specified document.
///
/// Before calling this method, <see cref="CurrentSpanStack"/> must be set to the proper
/// state for the beginning of this line. After highlighting has completed,
/// <see cref="CurrentSpanStack"/> will be updated to represent the state after the line.
/// </summary>
public void ScanLine(IDocument document, IDocumentLine line)
{
//this.lineStartOffset = line.Offset; not necessary for scanning
this.lineText = document.GetText(line);
try {
Debug.Assert(highlightedLine == null);
HighlightLineInternal();
} finally {
this.lineText = null;
}
}
static void IndentSingleLine(CacheIndentEngine engine, IDocument document, IDocumentLine line)
{
engine.Update(line.EndOffset);
if (engine.NeedsReindent) {
var indentation = TextUtilities.GetWhitespaceAfter(document, line.Offset);
// replacing the indentation in two steps is necessary to make the caret move accordingly.
document.Replace(indentation.Offset, indentation.Length, "");
document.Replace(indentation.Offset, 0, engine.ThisLineIndent);
engine.ResetEngineToPosition(line.Offset);
}
}
/// <inheritdoc/>
public bool MoveNext()
{
if (lineDirty) {
DocumentUtilitites.SmartReplaceLine(doc, line, text);
lineDirty = false;
}
++num;
if (num > maxLine) return false;
line = doc.GetLine(num);
text = line.Text;
return true;
}
public static bool IsInsideDocumentationComment(ITextEditor editor, IDocumentLine curLine, int cursorOffset)
{
for (int i = curLine.Offset; i < cursorOffset; ++i) {
char ch = editor.Document.GetCharAt(i);
if (ch == '"')
return false;
if (ch == '\'' && i + 2 < cursorOffset && editor.Document.GetCharAt(i + 1) == '\'' &&
editor.Document.GetCharAt(i + 2) == '\'')
return true;
}
return false;
}
public virtual void IndentLine(ITextEditor editor, IDocumentLine line)
{
IDocument document = editor.Document;
int lineNumber = line.LineNumber;
if (lineNumber > 1) {
IDocumentLine previousLine = document.GetLineByNumber(lineNumber - 1);
string indentation = DocumentUtilities.GetWhitespaceAfter(document, previousLine.Offset);
// copy indentation to line
string newIndentation = DocumentUtilities.GetWhitespaceAfter(document, line.Offset);
document.Replace(line.Offset, newIndentation.Length, indentation);
}
}
/// <summary>
/// Highlights the specified line in the specified document.
///
/// Before calling this method, <see cref="CurrentSpanStack"/> must be set to the proper
/// state for the beginning of this line. After highlighting has completed,
/// <see cref="CurrentSpanStack"/> will be updated to represent the state after the line.
/// </summary>
public HighlightedLine HighlightLine(IDocument document, IDocumentLine line)
{
this.lineStartOffset = line.Offset;
this.lineText = document.GetText(line);
try {
this.highlightedLine = new HighlightedLine(document, line);
HighlightLineInternal();
return this.highlightedLine;
} finally {
this.highlightedLine = null;
this.lineText = null;
this.lineStartOffset = 0;
}
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
int lineNr = line.LineNumber;
DocumentAccessor acc = new DocumentAccessor(editor.Document, lineNr, lineNr);
CSharpIndentationStrategy indentStrategy = new CSharpIndentationStrategy();
indentStrategy.IndentationString = editor.Options.IndentationString;
indentStrategy.Indent(acc, false);
string t = acc.Text;
if (t.Length == 0) {
// use AutoIndentation for new lines in comments / verbatim strings.
base.IndentLine(editor, line);
}
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
if (line.LineNumber > 1)
{
IDocumentLine above = editor.Document.GetLine(line.LineNumber - 1);
string up = above.Text.Trim();
if (up.StartsWith("--") == false)
{
// above line is an indent statement
if (up.EndsWith("do")
|| up.EndsWith("then")
|| (up.StartsWith("function") && up.EndsWith(")"))
|| (up.Contains("function") && up.EndsWith(")"))) // e.g. aTable.x = function([...])
{
string indentation = DocumentUtilitites.GetWhitespaceAfter(editor.Document, above.Offset);
string newLine = line.Text.TrimStart();
newLine = indentation + editor.Options.IndentationString + newLine;
editor.Document.SmartReplaceLine(line, newLine);
}
else // above line is not an indent statement
{
string indentation = DocumentUtilitites.GetWhitespaceAfter(editor.Document, above.Offset);
string newLine = line.Text.TrimStart();
newLine = indentation + newLine;
editor.Document.SmartReplaceLine(line, newLine);
}
}
if (line.Text.StartsWith("end"))
{
string indentation = DocumentUtilitites.GetWhitespaceAfter(editor.Document, above.Offset);
string newLine = line.Text.TrimStart();
string newIndent = "";
if (indentation.Length >= editor.Options.IndentationSize)
newIndent = indentation.Substring(0, indentation.Length - editor.Options.IndentationSize);
newLine = newIndent + newLine;
editor.Document.SmartReplaceLine(line, newLine);
}
}
else
{
}
//base.IndentLine(editor, line);
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
IDocument document = editor.Document;
int lineNumber = line.LineNumber;
if (lineNumber > 1) {
IDocumentLine previousLine = document.GetLine(line.LineNumber - 1);
if (previousLine.Text.EndsWith(":", StringComparison.Ordinal)) {
string indentation = DocumentUtilitites.GetWhitespaceAfter(document, previousLine.Offset);
indentation += editor.Options.IndentationString;
string newIndentation = DocumentUtilitites.GetWhitespaceAfter(document, line.Offset);
document.Replace(line.Offset, newIndentation.Length, indentation);
return;
}
}
base.IndentLine(editor, line);
}
public void Init()
{
formattingStrategy = new XmlFormattingStrategy();
options = new MockTextEditorOptions();
textEditor = new MockTextEditor();
textEditor.Options = options;
textDocument = new TextDocument();
document = textDocument;
textEditor.SetDocument(document);
document.Text =
"<root>\r\n" +
"\t<child>\r\n" +
"</child>\r\n" +
"</root>\r\n";
docLine = MockRepository.GenerateStub<IDocumentLine>();
docLine.Stub(l => l.LineNumber).Return(3);
formattingStrategy.IndentLine(textEditor, docLine);
}
public static bool GuessSemicolonInsertionOffset (TextEditorData data, IDocumentLine curLine, int caretOffset, out int outOffset)
{
int lastNonWsOffset = caretOffset;
char lastNonWsChar = '\0';
outOffset = caretOffset;
int max = curLine.EndOffset;
// if (caretOffset - 2 >= curLine.Offset && data.Document.GetCharAt (caretOffset - 2) == ')' && !IsSemicolonalreadyPlaced (data, caretOffset))
// return false;
int end = caretOffset;
while (end > 1 && char.IsWhiteSpace (data.GetCharAt (end)))
end--;
int end2 = end;
while (end2 > 1 && char.IsLetter(data.GetCharAt (end2 - 1)))
end2--;
if (end != end2) {
string token = data.GetTextBetween (end2, end + 1);
// guess property context
if (token == "get" || token == "set")
return false;
}
bool isInString = false , isInChar= false , isVerbatimString= false;
bool isInLineComment = false , isInBlockComment= false;
bool firstChar = true;
for (int pos = caretOffset; pos < max; pos++) {
if (pos == caretOffset) {
if (isInString || isInChar || isVerbatimString || isInLineComment || isInBlockComment) {
outOffset = pos;
return true;
}
}
char ch = data.Document.GetCharAt (pos);
switch (ch) {
case '}':
if (firstChar && !IsSemicolonalreadyPlaced (data, caretOffset))
return false;
break;
case '/':
if (isInBlockComment) {
if (pos > 0 && data.Document.GetCharAt (pos - 1) == '*')
isInBlockComment = false;
} else if (!isInString && !isInChar && pos + 1 < max) {
char nextChar = data.Document.GetCharAt (pos + 1);
if (nextChar == '/') {
outOffset = lastNonWsOffset;
return true;
}
if (!isInLineComment && nextChar == '*') {
outOffset = lastNonWsOffset;
return true;
}
}
break;
case '\\':
if (isInChar || (isInString && !isVerbatimString))
pos++;
break;
case '@':
if (!(isInString || isInChar || isInLineComment || isInBlockComment) && pos + 1 < max && data.Document.GetCharAt (pos + 1) == '"') {
isInString = true;
isVerbatimString = true;
pos++;
}
break;
case '"':
if (!(isInChar || isInLineComment || isInBlockComment)) {
if (isInString && isVerbatimString && pos + 1 < max && data.Document.GetCharAt (pos + 1) == '"') {
pos++;
} else {
isInString = !isInString;
isVerbatimString = false;
}
}
break;
case '\'':
if (!(isInString || isInLineComment || isInBlockComment))
isInChar = !isInChar;
break;
}
if (!char.IsWhiteSpace (ch)) {
firstChar = false;
lastNonWsOffset = pos;
lastNonWsChar = ch;
}
}
// if the line ends with ';' the line end is not the correct place for a new semicolon.
if (lastNonWsChar == ';')
return false;
outOffset = lastNonWsOffset;
return true;
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
editor.Document.StartUndoableAction();
TryIndent(editor, line.LineNumber, line.LineNumber);
editor.Document.EndUndoableAction();
}
IUrlTextLineMarker ITextMarkerFactory.CreateUrlTextMarker (MonoDevelop.Ide.Editor.TextEditor editor, IDocumentLine line, string value, MonoDevelop.Ide.Editor.UrlType url, string syntax, int startCol, int endCol)
{
return new UrlTextLineMarker (TextEditor.Document, line, value, (Mono.TextEditor.UrlType)url, syntax, startCol, endCol);
}
static void DoCasingOnLine(IDocumentLine lineAbove, string textToReplace, ITextEditor editor)
{
foreach (string keyword in keywords) {
string regex = "\\b" + keyword + "\\b"; // \b = word border
MatchCollection matches = Regex.Matches(textToReplace, regex, RegexOptions.IgnoreCase | RegexOptions.Singleline);
foreach (Match match in matches) {
if (keyword == "EndIf") // special case
editor.Document.Replace(lineAbove.Offset + match.Index, match.Length, "End If");
else
editor.Document.Replace(lineAbove.Offset + match.Index, match.Length, keyword);
}
}
}
bool IsInsideDocumentationComment(ITextEditor textArea, IDocumentLine curLine, int cursorOffset)
{
for (int i = curLine.Offset; i < cursorOffset; ++i) {
char ch = textArea.Document.GetCharAt(i);
if (ch == '"') {
// parsing strings correctly is too complicated (see above),
// but I don't now any case where a doc comment is after a string...
return false;
}
if (ch == '/' && i + 2 < cursorOffset && textArea.Document.GetCharAt(i + 1) == '/' && textArea.Document.GetCharAt(i + 2) == '/') {
return true;
}
}
return false;
}
bool IsInsideStringOrComment(ITextEditor textArea, IDocumentLine curLine, int cursorOffset)
{
// scan cur line if it is inside a string or single line comment (//)
bool insideString = false;
char stringstart = ' ';
bool verbatim = false; // true if the current string is verbatim (@-string)
char c = ' ';
char lastchar;
for (int i = curLine.Offset; i < cursorOffset; ++i) {
lastchar = c;
c = textArea.Document.GetCharAt(i);
if (insideString) {
if (c == stringstart) {
if (verbatim && i + 1 < cursorOffset && textArea.Document.GetCharAt(i + 1) == '"') {
++i; // skip escaped character
} else {
insideString = false;
}
} else if (c == '\\' && !verbatim) {
++i; // skip escaped character
}
} else if (c == '/' && i + 1 < cursorOffset && textArea.Document.GetCharAt(i + 1) == '/') {
return true;
} else if (c == '"' || c == '\'') {
stringstart = c;
insideString = true;
verbatim = (c == '"') && (lastchar == '@');
}
}
return insideString;
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
var document = editor.Document;
var engine = CreateIndentEngine(document, editor.ToEditorOptions());
IndentSingleLine(engine, document, line);
}
void DoInsertionOnLine(string terminator, IDocumentLine currentLine, IDocumentLine lineAbove, string textToReplace, ITextEditor editor, int lineNr)
{
string curLineText = currentLine.Text;
if (Regex.IsMatch(textToReplace.Trim(), "^If .*[^_]$", RegexOptions.IgnoreCase)) {
if (!Regex.IsMatch(textToReplace, "\\bthen\\b", RegexOptions.IgnoreCase)) {
string specialThen = "Then"; // do special check in cases like If t = True' comment
if (editor.Document.GetCharAt(lineAbove.Offset + textToReplace.Length) == '\'')
specialThen += " ";
if (editor.Document.GetCharAt(lineAbove.Offset + textToReplace.Length - 1) != ' ')
specialThen = " " + specialThen;
editor.Document.Insert(lineAbove.Offset + textToReplace.Length, specialThen);
textToReplace += specialThen;
}
}
// check #Region statements
if (Regex.IsMatch(textToReplace.Trim(), "^#Region", RegexOptions.IgnoreCase) && LookForEndRegion(editor)) {
string indentation = DocumentUtilitites.GetWhitespaceAfter(editor.Document, lineAbove.Offset);
textToReplace += indentation + "\r\n" + indentation + "#End Region";
editor.Document.Replace(currentLine.Offset, currentLine.Length, textToReplace);
}
foreach (VBStatement statement_ in statements) {
VBStatement statement = statement_; // allow passing statement byref
if (Regex.IsMatch(textToReplace.Trim(), statement.StartRegex, RegexOptions.IgnoreCase)) {
string indentation = DocumentUtilitites.GetWhitespaceAfter(editor.Document, lineAbove.Offset);
if (IsEndStatementNeeded(editor, ref statement, lineNr)) {
editor.Document.Replace(currentLine.Offset, currentLine.Length, terminator + indentation + statement.EndStatement);
}
if (!IsInsideInterface(editor, lineNr) || statement == interfaceStatement) {
for (int i = 0; i < statement.IndentPlus; i++) {
indentation += editor.Options.IndentationString;
}
}
editor.Document.Replace(currentLine.Offset, currentLine.Length, indentation + curLineText.Trim());
editor.Caret.Line = currentLine.LineNumber;
editor.Caret.Column = indentation.Length;
return;
}
}
}
void ITextEditorImpl.AddMarker (IDocumentLine line, ITextLineMarker lineMarker)
{
var debugPair = lineMarker as DebugMarkerPair;
if (debugPair != null) {
debugPair.AddTo (TextEditor.Document, ((DocumentLineWrapper)line).Line);
return;
}
var textLineMarker = lineMarker as TextLineMarker;
if (textLineMarker == null)
throw new InvalidOperationException ("Tried to add an incompatible text marker. Use the MarkerHost to create compatible ones.");
if (lineMarker is IUnitTestMarker) {
var actionMargin = TextEditor.ActionMargin;
if (actionMargin != null) {
actionMargin.IsVisible = true;
}
}
TextEditor.Document.AddMarker (((DocumentLineWrapper)line).Line, textLineMarker);
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
IndentLines(editor, line.LineNumber, line.LineNumber);
}
IEnumerable<ITextLineMarker> ITextEditorImpl.GetLineMarkers (IDocumentLine line)
{
return ((DocumentLineWrapper)line).Line.Markers.OfType<ITextLineMarker> ();
}