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);
}
}
/// <inheritdoc cref="IIndentationStrategy.IndentLine"/>
public override void IndentLine(TextDocument document, DocumentLine line)
{
if (line?.PreviousLine == null)
return;
var prevLine = document.GetText(line.PreviousLine.Offset, line.PreviousLine.Length);
var curLine = document.GetText(line.Offset, line.Length);
int prev = CalcSpace(prevLine);
var previousIsComment = prevLine.TrimStart().StartsWith("--", StringComparison.CurrentCulture);
if (Regex.IsMatch(curLine, patternFull) && !previousIsComment)
{
var ind = new string(' ', prev);
document.Insert(line.Offset, ind);
}
else if (Regex.IsMatch(prevLine, patternStart) && !previousIsComment)
{
var ind = new string(' ', prev + indent_space_count);
document.Insert(line.Offset, ind);
var found = false;
for (int i = line.LineNumber; i < document.LineCount; ++i)
{
var text = document.GetText(document.Lines[i].Offset, document.Lines[i].Length);
if (string.IsNullOrWhiteSpace(text) || text.TrimStart().StartsWith("--", StringComparison.CurrentCulture))
continue;
var sps = CalcSpace(text);
if (sps == prev && Regex.IsMatch(text, patternEnd))
found = true;
}
if (!found)
{
var ntext = Environment.NewLine + new string(' ', prev) + "end";
var point = textEditor.SelectionStart;
document.Insert(line.Offset + ind.Length, ntext);
textEditor.SelectionStart = point;
}
}
else
{
var ind = new string(' ', prev);
if (line != null)
document.Insert(line.Offset, ind);
}
}
/// <summary>
/// Sets the indentation for the specified line.
/// Usually this is constructed from the indentation of the previous line.
/// </summary>
/// <param name="document"></param>
/// <param name="line"></param>
public void IndentLine(TextDocument document, DocumentLine line)
{
var pLine = line.PreviousLine;
if (pLine != null)
{
var segment = TextUtilities.GetWhitespaceAfter(document, pLine.Offset);
var indentation = document.GetText(segment);
var amount = HtmlParser.CountUnclosedTags(document.GetText(pLine));
if (amount > 0)
indentation += new string('\t', amount);
document.Replace(TextUtilities.GetWhitespaceAfter(document, line.Offset), indentation);
}
}
public static Block ConvertTextDocumentToBlock(TextDocument document, IHighlighter highlighter)
{
if (document == null)
throw new ArgumentNullException("document");
// Table table = new Table();
// table.Columns.Add(new TableColumn { Width = GridLength.Auto });
// table.Columns.Add(new TableColumn { Width = new GridLength(1, GridUnitType.Star) });
// TableRowGroup trg = new TableRowGroup();
// table.RowGroups.Add(trg);
Paragraph p = new Paragraph();
foreach (DocumentLine line in document.Lines) {
int lineNumber = line.LineNumber;
// TableRow row = new TableRow();
// trg.Rows.Add(row);
// row.Cells.Add(new TableCell(new Paragraph(new Run(lineNumber.ToString()))) { TextAlignment = TextAlignment.Right });
HighlightedInlineBuilder inlineBuilder = new HighlightedInlineBuilder(document.GetText(line));
if (highlighter != null) {
HighlightedLine highlightedLine = highlighter.HighlightLine(lineNumber);
int lineStartOffset = line.Offset;
foreach (HighlightedSection section in highlightedLine.Sections)
inlineBuilder.SetHighlighting(section.Offset - lineStartOffset, section.Length, section.Color);
}
// Paragraph p = new Paragraph();
// row.Cells.Add(new TableCell(p));
p.Inlines.AddRange(inlineBuilder.CreateRuns());
p.Inlines.Add(new LineBreak());
}
return p;
}
static DToken SearchBackward(TextDocument doc, int caretOffset, CodeLocation caret,out DToken lastToken)
{
var ttp = doc.GetText(0, caretOffset);
var sr = new StringReader(ttp);
var lexer = new Lexer(sr);
lexer.NextToken();
var stk=new Stack<DToken>();
while (lexer.LookAhead.Kind!=DTokens.EOF)
{
if (lexer.LookAhead.Kind == DTokens.OpenParenthesis || lexer.LookAhead.Kind==DTokens.OpenSquareBracket || lexer.LookAhead.Kind==DTokens.OpenCurlyBrace)
stk.Push(lexer.LookAhead);
else if (lexer.LookAhead.Kind == DTokens.CloseParenthesis || lexer.LookAhead.Kind == DTokens.CloseSquareBracket || lexer.LookAhead.Kind == DTokens.CloseCurlyBrace)
{
if (stk.Peek().Kind == getOppositeBracketToken( lexer.LookAhead.Kind))
stk.Pop();
}
lexer.NextToken();
}
lastToken = lexer.CurrentToken;
sr.Close();
lexer.Dispose();
if (stk.Count < 1)
return null;
return stk.Pop();
}
protected override IEnumerable<NewFolding> CreateNewFoldings(TextDocument document)
{
string name = null;
int? startOffset = null;
int? endOffset = null;
foreach (var line in document.Lines)
{
var text = document.GetText(line);
var isFunction = _functionRegex.IsMatch(text);
if (isFunction)
{
if (startOffset != null && endOffset != null)
{
yield return new NewFolding { StartOffset = startOffset.Value, EndOffset = endOffset.Value, Name = name, IsDefinition = true };
}
name = text;
startOffset = line.Offset;
endOffset = null;
continue;
}
if (startOffset == null || string.IsNullOrWhiteSpace(text)) continue;
var firstChar = text.First(c => !char.IsWhiteSpace(c));
if (!firstChar.Equals(Gherkin.Comment) && !firstChar.Equals(Gherkin.Tag)) endOffset = line.EndOffset;
}
if (startOffset != null && endOffset != null)
{
yield return new NewFolding { StartOffset = startOffset.Value, EndOffset = endOffset.Value, Name = name, IsDefinition = true };
}
}
public void IndentLine(ICSharpCode.AvalonEdit.Document.TextDocument document, DocumentLine line, bool TakeCaret)
{
if (line.PreviousLine == null)
{
return;
}
if (!DSettings.Instance.EnableSmartIndentation)
{
var t = document.GetText(line);
int c = 0;
for (; c < t.Length && (t[c] == ' ' || t[c] == '\t'); c++)
{
;
}
RawlyIndentLine(t.Length == 0 ? string.Empty : t.Substring(0, c + 1), document, line);
return;
}
var tr = document.CreateReader();
var newIndent = D_Parser.Formatting.Indent.IndentEngineWrapper.CalculateIndent(tr, line.LineNumber, dEditor.Editor.Options.ConvertTabsToSpaces, dEditor.Editor.Options.IndentationSize);
tr.Close();
RawlyIndentLine(newIndent, document, line);
}
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);
}
/// <inheritdoc/>
public override string GetText(TextDocument document)
{
StringBuilder b = new StringBuilder();
foreach (ISegment s in this.Segments) {
if (b.Length > 0)
b.AppendLine();
b.Append(document.GetText(s));
}
return b.ToString();
}
private Match FindMatch(int startOffset)
{
// fetch the end offset of the VisualLine being generated
int endOffset = CurrentContext.VisualLine.LastDocumentLine.EndOffset;
ICSharpCode.AvalonEdit.Document.TextDocument document = CurrentContext.Document;
string relevantText = document.GetText(startOffset, endOffset - startOffset);
return(imageRegex.Match(relevantText));
}
/// <summary>
/// Create <see cref="NewFolding"/>s for the specified document.
/// </summary>
public IEnumerable<NewFolding> CreateNewFoldings(TextDocument document, out int firstErrorOffset)
{
firstErrorOffset = -1;
var foldings = new List<NewFolding>();
var stack = new Stack<int>();
foreach (var line in document.Lines)
{
var text = document.GetText(line.Offset, line.Length);
// комментарии пропускаем
if (commentPattern.IsMatch(text))
continue;
foreach (Match match in startPattern.Matches(text))
{
var element = match.Groups["start"];
if (element.Success)
{
stack.Push(line.EndOffset);
}
}
foreach (Match match in endPattern.Matches(text))
{
var element = match.Groups["end"];
if (element.Success)
{
if (stack.Count > 0)
{
var first = stack.Pop();
var folding = new NewFolding(first, line.EndOffset);
foldings.Add(folding);
}
else
{
firstErrorOffset = line.Offset;
}
}
}
}
if (stack.Count > 0)
{
firstErrorOffset = stack.Pop();
}
foldings.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset));
return foldings;
}
/// <inheritdoc/>
public virtual void IndentLine(TextDocument document, DocumentLine line)
{
if (document == null)
throw new ArgumentNullException("document");
if (line == null)
throw new ArgumentNullException("line");
DocumentLine previousLine = line.PreviousLine;
if (previousLine != null) {
ISegment indentationSegment = TextUtilities.GetWhitespaceAfter(document, previousLine.Offset);
string indentation = document.GetText(indentationSegment);
// copy indentation to line
indentationSegment = TextUtilities.GetWhitespaceAfter(document, line.Offset);
document.Replace(indentationSegment, indentation);
}
}
/// <inheritdoc/>
public virtual void IndentLine(TextDocument document, DocumentLine line)
{
if (document == null)
throw new ArgumentNullException(nameof(document));
if (line == null)
throw new ArgumentNullException(nameof(line));
if (line.PreviousLine != null)
{
var indentationSegment = TextUtilities.GetWhitespaceAfter(document, line.PreviousLine.Offset);
var indentation = document.GetText(indentationSegment);
// copy indentation to line
indentationSegment = TextUtilities.GetWhitespaceAfter(document, line.Offset);
document.Replace(indentationSegment, indentation);
}
}
/// <inheritdoc/>
public virtual void IndentLine(TextDocument document, DocumentLine line)
{
if (document == null)
throw new ArgumentNullException("document");
if (line == null)
throw new ArgumentNullException("line");
DocumentLine previousLine = line.PreviousLine;
if (previousLine != null) {
ISegment indentationSegment = TextUtilities.GetWhitespaceAfter(document, previousLine.Offset);
string indentation = document.GetText(indentationSegment);
// copy indentation to line
indentationSegment = TextUtilities.GetWhitespaceAfter(document, line.Offset);
document.Replace(indentationSegment.Offset, indentationSegment.Length, indentation,
OffsetChangeMappingType.RemoveAndInsert);
// OffsetChangeMappingType.RemoveAndInsert guarantees the caret moves behind the new indentation.
}
}
private void codeEditor_TextEntered(object sender, TextCompositionEventArgs e)
{
if (e.Text == ".")
{
ICSharpCode.AvalonEdit.Editing.TextArea area = (sender as ICSharpCode.AvalonEdit.Editing.TextArea);
ICSharpCode.AvalonEdit.Document.TextDocument doc = area.Document;
int startoff = area.Caret.Offset - 1;
int off = area.Caret.Offset - 2;
while (true)
{
char o = doc.GetCharAt(off);
if (!char.IsLetter(o))
{
break;
}
if (off == 0)
{
break;
}
off--;
}
string prevToken = doc.GetText(off, startoff - off);
// Open code completion after the user has pressed dot:
completionWindow = new CompletionWindow(CodeEditor.TextArea);
completionWindow.Margin = new Thickness(0);
IList <ICompletionData> data = completionWindow.CompletionList.CompletionData;
try
{
List <string> items = CompletionDatabase.completionDatabase[prevToken];
foreach (string item in items)
{
data.Add(new CompletionData(item));
}
completionWindow.Show();
completionWindow.Closed += delegate
{
completionWindow = null;
};
}catch (Exception)
{
}
}
}
public void IndentLine(TextDocument document, DocumentLine line, bool TakeCaret)
{
if (line.PreviousLine == null)
return;
if (!DSettings.Instance.EnableSmartIndentation)
{
var prevIndent = ReadRawLineIndentation(document.GetText(line));
RawlyIndentLine(prevIndent, document, line);
return;
}
var tr=document.CreateReader();
var block = CalculateIndentation(tr, line.LineNumber);
tr.Close();
RawlyIndentLine(block != null ? block.GetLineIndentation(line.LineNumber) : 0, document, line);
}
public void GetCompletions(TextDocument doc, int Offset, IList<ICompletionData> data)
{
// match only last N chars
int N = Math.Min(Offset, 200);
string s = doc.GetText(Offset - N, N);
foreach (CodeEnvironment ee in envs)
{
if ( ee.MatchEnv(s) )
{
foreach (MyCompletionData snipp in ee.snippets)
{
data.Add(snipp);
}
}
}
//data.Add(new MyCompletionData("draw"));
//data.Add(new MyCompletionData("fill"));
//data.Add(new MyCompletionData("minimum size"));
}
internal override string FoldTitle(FoldingSection section, TextDocument doc)
{
var array = Regex.Split(section.Title, "æ");
var offset = section.StartOffset + array[0].Length;
var length = section.Length - (array[0].Length + array[1].Length);
return doc.GetText(offset, length);
}
/// <summary>
/// Marks the region that starts at the given offset.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="offset">The offset.</param>
/// <param name="folds">The fold markers.</param>
/// <returns>The index of the next character after the region.</returns>
private static int MarkRegion(TextDocument document, int offset, List<NewFolding> folds)
{
if (offset >= document.TextLength)
return offset;
if (document.GetCharAt(offset) == '#')
{
int startOffset = offset;
offset++;
string word = TextUtilities.GetIdentifierAt(document, offset);
if (word == "region")
{
offset += "region".Length;
// Find label
var line = document.GetLineByOffset(offset);
int lineEnd = line.Offset + line.Length;
int labelLength = lineEnd - offset;
string label = document.GetText(offset, labelLength);
label = label.Trim();
if (label.Length == 0)
label = "#region";
// Find and mark subregions
offset = FindAndMarkRegions(document, lineEnd, folds);
if (offset <= document.TextLength)
{
AddFold(document, folds, startOffset, offset, label);
offset++;
}
}
}
else
{
offset++;
}
return offset;
}
/// <summary>
/// Gets the line of the document as <see cref="string"/>.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="lineNumber">The line number.</param>
/// <returns>The line as <see cref="string"/>.</returns>
internal static string GetLineAsString(this TextDocument document, int lineNumber)
{
var line = document.GetLineByNumber(lineNumber);
return(document.GetText(line));
}
public void GetCompletions(TextDocument doc, int Offset, IList<ICompletionData> data)
{
// match only last N chars
int N = Math.Min(Offset, 200);
string s = doc.GetText(Offset - N, N);
foreach (CodeEnvironment ee in envs)
{
if ( ee.MatchEnv(s) )
{
foreach (MyCompletionData snipp in ee.snippets)
{
data.Add(snipp);
}
if (ee.ID == DynamicSnippetsEnv && DynamicSnippets != null)
{
foreach (string snipp in DynamicSnippets)
{
data.Add(new MyCompletionData(snipp, null));
}
}
}
}
}
/// <summary>
/// Gets the expression before a given offset.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="initialOffset">The initial offset.</param>
/// <returns>The expression.</returns>
/// <remarks>
/// This method returns the expression before a specified offset.
/// That method is used in code completion to determine the expression before
/// the caret. The expression can be passed to a parser to resolve the type
/// or similar.
/// </remarks>
internal static string GetExpressionBeforeOffset(TextDocument document, int initialOffset)
{
int offset = initialOffset;
while (offset - 1 > 0)
{
switch (document.GetCharAt(offset - 1))
{
case '\n':
case '\r':
case '}':
goto done;
//offset = FindOpeningBracket(document, offset - 2, '{','}');
//break;
case ']':
offset = FindOpeningBracket(document, offset - 2, '[', ']');
break;
case ')':
offset = FindOpeningBracket(document, offset - 2, '(', ')');
break;
case '.':
--offset;
break;
case '"':
if (offset < initialOffset - 1)
{
return(null);
}
return("\"\"");
case '\'':
if (offset < initialOffset - 1)
{
return(null);
}
return("'a'");
case '>':
if (document.GetCharAt(offset - 2) == '-')
{
offset -= 2;
break;
}
goto done;
default:
if (char.IsWhiteSpace(document.GetCharAt(offset - 1)))
{
--offset;
break;
}
int start = offset - 1;
if (!IsIdentifierPart(document.GetCharAt(start)))
{
goto done;
}
while (start > 0 && IsIdentifierPart(document.GetCharAt(start - 1)))
{
--start;
}
string word = document.GetText(start, offset - start).Trim();
switch (word)
{
case "ref":
case "out":
case "in":
case "return":
case "throw":
case "case":
goto done;
}
if (word.Length > 0 && !IsIdentifierPart(word[0]))
{
goto done;
}
offset = start;
break;
}
}
done:
// simple exit fails when : is inside comment line or any other character
// we have to check if we got several ids in resulting line, which usually happens when
// id. is typed on next line after comment one
// Would be better if lexer would parse properly such expressions. However this will cause
// modifications in this area too - to get full comment line and remove it afterwards
if (offset < 0)
{
return(string.Empty);
}
string resText = document.GetText(offset, initialOffset - offset).Trim();
int pos = resText.LastIndexOf('\n');
if (pos >= 0)
{
offset += pos + 1;
// whitespaces and tabs, which might be inside, will be skipped by trim below
}
string expression = document.GetText(offset, initialOffset - offset).Trim();
return(expression);
}
private bool CommentAtBeginOfLine(TextDocument document, DocumentLine documentLine)
{
var text = document.GetText(documentLine).TrimStart(Whitespaces.ToArray());
if (string.IsNullOrEmpty(text))
{
return false;
}
if (!AllowMultipleComments && text.StartsWith(CommentMarker))
{
return false;
}
document.Insert(documentLine.Offset, CommentMarker);
return true;
}
/// <summary>
/// Gets the selected text.
/// </summary>
public virtual string GetText(TextDocument document)
{
if (document == null)
throw new ArgumentNullException("document");
StringBuilder b = null;
string text = null;
foreach (ISegment s in Segments) {
if (text != null) {
if (b == null)
b = new StringBuilder(text);
else
b.Append(text);
}
text = document.GetText(s);
}
if (b != null) {
if (text != null) b.Append(text);
return b.ToString();
} else {
return text ?? string.Empty;
}
}
/// <summary>
/// Converts a TextDocument to Block.
/// </summary>
static Block ConvertTextDocumentToBlock(TextDocument document, IHighlighter highlighter)
{
// ref.: http://community.sharpdevelop.net/forums/t/12012.aspx
if (document == null)
throw new ArgumentNullException("document");
Paragraph p = new Paragraph();
foreach (DocumentLine line in document.Lines)
{
int lineNumber = line.LineNumber;
HighlightedInlineBuilder inlineBuilder = new HighlightedInlineBuilder(document.GetText(line));
if (highlighter != null)
{
HighlightedLine highlightedLine = highlighter.HighlightLine(lineNumber);
int lineStartOffset = line.Offset;
foreach (HighlightedSection section in highlightedLine.Sections)
inlineBuilder.SetHighlighting(section.Offset - lineStartOffset, section.Length, section.Color);
}
p.Inlines.AddRange(inlineBuilder.CreateRuns());
p.Inlines.Add(new LineBreak());
}
return p;
}
/// <summary>
/// Part of the text between start offset and end offset (included),
/// (first char at index 0 at the beginning of document)
/// </summary>
public string TextSegment(int startOffset, int endOffset)
{
return(_avalonEditTextDocument.GetText(startOffset, endOffset - startOffset + 1));
}
public static TextReplaceBlockRegion FindSelectedStartCommentRegion(string commentStart,
TextDocument document,
string selectedText,
int selectionStart,
int selectionLength)
{
if (document == null)
return null;
////if (document.TextLength == 0)
//// return null;
// Find start of comment in selected text.
int commentStartOffset = selectedText.IndexOf(commentStart);
if (commentStartOffset >= 0)
commentStartOffset += selectionStart;
// Find start of comment before or partially inside the selected text.
if (commentStartOffset == -1)
{
int offset = selectionStart + selectionLength + commentStart.Length - 1;
if (offset > document.TextLength)
offset = document.TextLength;
string text = document.GetText(0, offset);
commentStartOffset = text.LastIndexOf(commentStart);
}
if (commentStartOffset != -1)
return new TextReplaceBlockRegion(commentStart, string.Empty, commentStartOffset, -1);
return null;
}
/// <summary>
/// Search in the current selection and before/after the current selection to determine
/// whether a start/end comment match can be found there. Return the matched positions
/// for uncommentin if so.
///
/// This can include a position before the current selection and a position at the end
/// of the current selection if the user has partially selected a commented area.
/// </summary>
/// <param name="commentStart"></param>
/// <param name="commentEnd"></param>
/// <param name="document"></param>
/// <param name="selectedText"></param>
/// <param name="selectionLength"></param>
/// <param name="selectionStart"></param>
/// <returns></returns>
public static TextReplaceBlockRegion FindSelectedCommentRegion(string commentStart,
string commentEnd,
TextDocument document,
string selectedText,
int selectionStart,
int selectionLength
)
{
if (document == null)
return null;
////if (document.TextLength == 0)
//// return null;
// Find start of comment in selected text.
int commentEndOffset = -1;
int commentStartOffset = selectedText.IndexOf(commentStart);
if (commentStartOffset >= 0)
commentStartOffset += selectionStart;
// Find end of comment in selected text.
if (commentStartOffset >= 0)
commentEndOffset = selectedText.IndexOf(commentEnd, commentStartOffset + commentStart.Length - selectionStart);
else
commentEndOffset = selectedText.IndexOf(commentEnd);
if (commentEndOffset >= 0)
commentEndOffset += selectionStart;
// Find start of comment before or partially inside the selected text.
int commentEndBeforeStartOffset = -1;
if (commentStartOffset == -1)
{
int offset = selectionStart + selectionLength + commentStart.Length - 1;
if (offset > document.TextLength)
offset = document.TextLength;
string text = document.GetText(0, offset);
commentStartOffset = text.LastIndexOf(commentStart);
if (commentStartOffset >= 0)
{
// Find end of comment before comment start.
commentEndBeforeStartOffset = text.IndexOf(commentEnd, commentStartOffset, selectionStart - commentStartOffset);
if (commentEndBeforeStartOffset > commentStartOffset)
commentStartOffset = -1;
}
}
// Find end of comment after or partially after the selected text.
if (commentEndOffset == -1)
{
int offset = selectionStart + 1 - commentEnd.Length;
if (offset < 0)
offset = selectionStart;
string text = document.GetText(offset, document.TextLength - offset);
commentEndOffset = text.IndexOf(commentEnd);
if (commentEndOffset >= 0)
commentEndOffset += offset;
}
if (commentStartOffset != -1 && commentEndOffset != -1)
return new TextReplaceBlockRegion(commentStart, commentEnd, commentStartOffset, commentEndOffset);
return null;
}
public static TextReplaceBlockRegion FindSelectedEndCommentRegion(string commentEnd,
TextDocument document,
string selectedText,
int selectionStart)
{
if (document == null)
return null;
////if (document.TextLength == 0)
//// return null;
// Find start of comment in selected text.
int commentEndOffset = -1;
commentEndOffset = selectedText.IndexOf(commentEnd);
if (commentEndOffset >= 0)
commentEndOffset += selectionStart;
// Find end of comment after or partially after the selected text.
if (commentEndOffset == -1)
{
int offset = selectionStart + 1 - commentEnd.Length;
if (offset < 0)
offset = selectionStart;
string text = document.GetText(offset, document.TextLength - offset);
commentEndOffset = text.IndexOf(commentEnd);
if (commentEndOffset >= 0)
commentEndOffset += offset;
}
if (commentEndOffset != -1)
return new TextReplaceBlockRegion(string.Empty, commentEnd, -1, commentEndOffset);
return null;
}
public override IEnumerable<NewFolding> CreateNewFoldings(TextDocument document, out int firstErrorOffset)
{
firstErrorOffset = -1;
var folds = new List<NewFolding>();
linenr = 1;
prev = false;
startfold = 0; endfold = 0;
n = 0;
var l = document.GetLineByNumber(linenr);
int sep = 0;
do
{
int N = l.TotalLength;
var line = document.GetText(n, N);
var M = r.Match(line);
if (M.Success)
{
if (!prev)
{
prev = true;
startfold = n;
}
endfold = n + l.Length;
}
else
{
if (prev)
folds.Add(lastfold=new NewFolding{ StartOffset=startfold, EndOffset= endfold, Name="FileSync Complete", DefaultClosed=true});
prev = false;
}
linenr++;
n += N;
}
while ((l = l.NextLine) != null);
return folds;
}
public static HighlightedInlineBuilder CreateInlineBuilder(Location startPosition, Location endPosition, TextDocument document, IHighlighter highlighter)
{
if (startPosition.Line >= 1 && startPosition.Line <= document.LineCount) {
var matchedLine = document.GetLineByNumber(startPosition.Line);
HighlightedInlineBuilder inlineBuilder = new HighlightedInlineBuilder(document.GetText(matchedLine));
if (highlighter != null) {
HighlightedLine highlightedLine = highlighter.HighlightLine(startPosition.Line);
int startOffset = highlightedLine.DocumentLine.Offset;
// copy only the foreground color
foreach (HighlightedSection section in highlightedLine.Sections) {
if (section.Color.Foreground != null) {
inlineBuilder.SetForeground(section.Offset - startOffset, section.Length, section.Color.Foreground.GetBrush(null));
}
}
}
// now highlight the match in bold
if (startPosition.Column >= 1) {
if (endPosition.Line == startPosition.Line && endPosition.Column > startPosition.Column) {
// subtract one from the column to get the offset inside the line's text
int startOffset = startPosition.Column - 1;
int endOffset = Math.Min(inlineBuilder.Text.Length, endPosition.Column - 1);
inlineBuilder.SetFontWeight(startOffset, endOffset - startOffset, FontWeights.Bold);
}
}
return inlineBuilder;
}
return null;
}
public void GetNameMatch(TextDocument aDoc, int line, string text, ref List<string> suggestions)
{
int depth = scanner_.GetBraceDepth(line);
do {
string[] lineCodes = aDoc.GetText(aDoc.Lines[line]).Split(BREAKCHARS, StringSplitOptions.RemoveEmptyEntries);
foreach (string lineCode in lineCodes) {
if (lineCode.Length > 3 && lineCode.StartsWith(text)) { //contains our current text
int startidx = lineCode.IndexOf(text);
if (!suggestions.Contains(lineCode))
suggestions.Add(lineCode);
}
}
--line;
} while (depth > 0 && line > 0); //function depth may be on the first 0 scanning up, same with class def
}
public static string GetWordUnderMouse(ICSharpCode.AvalonEdit.Document.TextDocument document, TextViewPosition position)
{
string wordHovered = string.Empty;
var line = position.Line;
var column = position.Column - 1;
var offset = document.GetOffset(line, column);
if (offset >= document.TextLength)
{
offset--;
}
var textAtOffset = document.GetText(offset, 1);
// Get text backward of the mouse position, until the first space
while (!string.IsNullOrWhiteSpace(textAtOffset))
{
wordHovered = textAtOffset + wordHovered;
offset--;
if (offset < 0)
{
break;
}
textAtOffset = document.GetText(offset, 1);
if (textAtOffset == "(" || textAtOffset == ")" || textAtOffset == "<" || textAtOffset == ">" || textAtOffset == "," || textAtOffset == ";")
{
break;
}
}
// Get text forward the mouse position, until the first space
offset = document.GetOffset(line, column);
if (offset < document.TextLength - 1)
{
offset++;
textAtOffset = document.GetText(offset, 1);
while (!string.IsNullOrWhiteSpace(textAtOffset))
{
wordHovered = wordHovered + textAtOffset;
offset++;
if (offset >= document.TextLength)
{
break;
}
textAtOffset = document.GetText(offset, 1);
if (textAtOffset == "(" || textAtOffset == ")" || textAtOffset == "<" || textAtOffset == ">" || textAtOffset == "," || textAtOffset == ";")
{
break;
}
}
}
return(wordHovered);
}
public BaseTypeInfo GetClassType(TextDocument aDoc, int line, string text)
{
if (globals_ == null)
return null;
--line; //subtract one for how AvalonEdit stores text versus reports its position
int startLine = line;
if (text.Equals("this")) { //easy case
int depth = scanner_.GetBraceDepth(line);
do {
string lineCode = aDoc.GetText(aDoc.Lines[line]);
if (lineCode.Contains("class ")) {
string[] parts = lineCode.Trim().Split(SPACECHAR, StringSplitOptions.RemoveEmptyEntries);
if (parts[0].Equals("shared") && globals_.ContainsTypeInfo(parts[2]))
return globals_.GetTypeInfo(parts[2]);
else if (globals_.ContainsTypeInfo(parts[1]))
return globals_.GetTypeInfo(parts[1]);
else
break;
}
depth = scanner_.GetBraceDepth(line);
--line;
} while (depth > 0 && line > 0); //class def may be on last line
//unkonwn class
int curDepth = depth;
string[] nameparts = aDoc.GetText(aDoc.Lines[line]).Trim().Split(SPACECHAR, StringSplitOptions.RemoveEmptyEntries);
string className = "";
if (nameparts[0].Equals("shared"))
className = nameparts[2];
else if (nameparts[0].Equals("abstract"))
className = nameparts[2];
else
className = nameparts[1];
//TODO get baseclasses
if (globals_.ContainsTypeInfo(className))
return globals_.GetTypeInfo(className);
TypeInfo tempType = new TypeInfo() { Name = className };
++line;
do {
depth = scanner_.GetBraceDepth(line);
if (depth == curDepth+1) {
string lineCode = aDoc.GetText(aDoc.Lines[line]);
string[] words = aDoc.GetText(aDoc.Lines[line]).Trim().Split(SPACECHAR, StringSplitOptions.RemoveEmptyEntries);
if (words != null && words.Length > 1) {
if (words[1].Contains("(")) { //function
if (globals_.ContainsTypeInfo(words[0])) {
}
} else {
string rettype = FilterTypeName(words[0]);
string propname = FilterTypeName(words[1]);
if (globals_.ContainsTypeInfo(rettype)) {
tempType.Properties[propname] = globals_.GetTypeInfo(rettype);
}
}
}
}
++line;
} while (line < startLine);
return tempType;
}
//SCOPE block for depth
{
int depth = scanner_.GetBraceDepth(line);
bool indexType = false;
if (text.Contains('[')) {
indexType = true;
text = text.Substring(0, text.IndexOf('['));
}
do {
string lineCode = aDoc.GetText(aDoc.Lines[line]).Trim();
if (lineCode.Contains(text)) {
// Prevent partial matches as false positives, ie. "sceneFile" passing as "scene"
string[] lineTokens = lineCode.Split(BREAKCHARS, StringSplitOptions.RemoveEmptyEntries);
if (!lineTokens.Contains(text))
{
--line;
depth = scanner_.GetBraceDepth(line);
continue;
}
int endidx = lineCode.IndexOf(text);
int idx = endidx;
bool okay = true;
bool hitSpace = false;
while (idx > 0) { //scan backwards to find the typename
if (!char.IsLetterOrDigit(lineCode[idx]) && !BACKSCAN_ALLOW.Contains(lineCode[idx])) {
okay = false;
++idx;
break;
}
if (!hitSpace && lineCode[idx] == ' ')
hitSpace = true;
else if (lineCode[idx] == ' ')
{
break;
}
--idx;
}
if (idx < 0) idx = 0;
string substr = endidx - idx > 0 ? FilterTypeName(lineCode.Substring(idx, endidx - idx).Trim()) : "";
if (substr.Length > 0) { //not empty
if (substr.Contains(">")) {//TEMPLATE DEFINITION
try
{
if (!indexType)
substr = lineCode.Substring(0, lineCode.IndexOf('<'));
else
{
int start = lineCode.IndexOf('<');
int end = lineCode.IndexOf('>');
substr = lineCode.Substring(start + 1, end - start - 1);
substr = substr.Replace("@", "");
}
}
catch (Exception) { /* silently eat */}
}
if (globals_.ContainsTypeInfo(substr)) {
//Found a class
if (indexType)
{
TypeInfo ti = globals_.GetTypeInfo(substr);
//HACK for Map types
if (ti.Properties.ContainsKey("values"))
{
TypeInfo valueType = ti.Properties["values"];
if (valueType is TemplateInst)
return ((TemplateInst)valueType).WrappedType;
}
}
return globals_.GetTypeInfo(substr);
} else if (substr.Contains(':'))
{
string[] words = substr.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (words.Length > 1 && globals_.ContainsNamespace(words[0]))
{
Globals g = globals_;
for (int i = 0; i < words.Length - 1; ++i)
{
g = globals_.GetNamespace(words[i]);
}
if (g.ContainsTypeInfo(words[words.Length - 1]))
return g.GetTypeInfo(words[words.Length - 1]);
}
}
}
}
--line;
depth = scanner_.GetBraceDepth(line);
} while (depth >= 0 && line > 0);
return null;
}
}
private bool CommentAtBeginOfText(TextDocument document, DocumentLine documentLine)
{
var text = document.GetText(documentLine);
if (string.IsNullOrEmpty(text))
{
return false;
}
if (!AllowMultipleComments && text.TrimStart(Whitespaces.ToArray()).StartsWith(commentMarker))
{
return false;
}
var num = documentLine.Offset;
var text2 = text;
var i = 0;
while (i < text2.Length)
{
var letter = text2[i];
if (IsWhitespace(letter))
{
num++;
i++;
}
else
{
if (num >= documentLine.EndOffset)
{
return false;
}
break;
}
}
document.Insert(num, CommentMarker);
return true;
}
/// <summary>
/// Gets the newline sequence used in the document at the specified line.
/// </summary>
public static string GetNewLineFromDocument(TextDocument document, int lineNumber)
{
DocumentLine line = document.GetLineByNumber(lineNumber);
if (line.DelimiterLength == 0) {
// at the end of the document, there's no line delimiter, so use the delimiter
// from the previous line
line = line.PreviousLine;
if (line == null)
return Environment.NewLine;
}
return document.GetText(line.Offset + line.Length, line.DelimiterLength);
}
protected override IEnumerable<NewFolding> CreateNewFoldings(TextDocument document, out int firstErrorOffset)
{
var list = new List<NewFolding>();
firstErrorOffset = -1;
var stack = new Stack<DocumentLine>();
var stack2 = new Stack<DocumentLine>();
var flag = false;
foreach (var current in document.Lines)
{
var input = document.GetText(current).ToLower().TrimEnd(new[]
{
' ',
'\t'
}).TrimStart(new[]
{
' ',
'\t'
});
if (FoldFunctions && KrlRegularExpressions.DefLineRegex.IsMatch(input))
{
stack.Push(current);
flag = true;
}
if (FoldFunctions && KrlRegularExpressions.EndDefLineRegex.IsMatch(input) && stack.Count > 0)
{
var endOffset = current.EndOffset;
var documentLine = stack.Pop();
var name = document.GetText(documentLine).TrimStart(new[]
{
' ',
'\t'
}).TrimEnd(new[]
{
' ',
'\t'
});
list.Add(new NewFolding(documentLine.Offset, endOffset)
{
Name = name
});
flag = false;
}
if (KrlRegularExpressions.FoldStartLineRegex.IsMatch(input) && (flag | !FoldFunctions))
{
stack2.Push(current);
}
if (KrlRegularExpressions.FoldEndLineRegex.IsMatch(input) && stack2.Count > 0 && (flag | !FoldFunctions))
{
var endOffset = current.EndOffset;
var documentLine2 = stack2.Pop();
var text = document.GetText(documentLine2).TrimStart(new[]
{
' ',
'\t'
}).TrimEnd(new[]
{
' ',
'\t'
}).ToUpper();
text = text.Replace(";FOLD", string.Empty).TrimStart(new[]
{
' ',
'\t'
});
var num = text.IndexOf(';');
if (num > 0)
{
text = text.Remove(num);
}
list.Add(new NewFolding(documentLine2.Offset, endOffset)
{
Name = text,
DefaultClosed = FoldsClosedByDefault
});
}
}
list.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset));
return list;
}
