public override IEnumerable<NewFolding> CreateNewFoldings(TextDocument document, out int firstErrorOffset)
{
try
{
var timer = Stopwatch.StartNew();
TimeSpan = timer.Elapsed;
var result = new List<NewFolding>();
foreach (var o in Outlining)
{
var newFolding = new NewFolding
{
DefaultClosed = o.IsDefaultCollapsed,
StartOffset = o.Span.StartPos,
EndOffset = o.Span.EndPos
};
result.Add(newFolding);
}
result.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset));
firstErrorOffset = 0;
return result;
}
catch (Exception ex)
{
Debug.WriteLine(ex.GetType().Name + ":" + ex.Message);
firstErrorOffset = 0;
return Enumerable.Empty<NewFolding>();
}
}
/// <summary>
/// Create <see cref="NewFolding"/>s for the specified document.
/// </summary>
public IEnumerable<NewFolding> CreateNewFoldings(ITextSource document)
{
List<NewFolding> newFoldings = new List<NewFolding>();
Stack<int> startOffsets = new Stack<int>();
int lastNewLineOffset = 0;
char openingBrace = OpeningBrace;
char closingBrace = ClosingBrace;
foreach (var startKeyword in foldingKeywords.Keys)
{
int lastKeywordPos = 0;
int pos = 0;
while ((pos = document.Text.IndexOf(startKeyword, pos)) > lastKeywordPos)
{
int endOffset = document.Text.IndexOf(foldingKeywords[startKeyword], pos);
if (endOffset > pos)
{
var offset = document.Text.IndexOf("\r\n", pos);
var name = document.Text.Substring(pos + 8, offset - (pos + 8));
var folding = new NewFolding(pos, endOffset + 10);
folding.Name = name;
// Add the folding
newFoldings.Add(folding);
}
lastKeywordPos = pos;
}
}
for (int i = 0; i < document.TextLength; i++)
{
char c = document.GetCharAt(i);
if (c == openingBrace)
{
startOffsets.Push(i);
}
else if (c == closingBrace && startOffsets.Count > 0)
{
int startOffset = startOffsets.Pop();
// don't fold if opening and closing brace are on the same line
if (startOffset < lastNewLineOffset)
{
newFoldings.Add(new NewFolding(startOffset, i + 1));
}
}
else if (c == '\n' || c == '\r')
{
lastNewLineOffset = i + 1;
}
}
newFoldings.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset));
return newFoldings;
}
NewFolding AddFolding(TextLocation start, TextLocation end, bool isDefinition = false)
{
if (end.Line <= start.Line || start.IsEmpty || end.IsEmpty)
return null;
NewFolding folding = new NewFolding(GetOffset(start), GetOffset(end));
folding.IsDefinition = isDefinition;
foldings.Add(folding);
return folding;
}
/// <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;
}
public void UpdateFoldings(FoldingManager fm, IEnumerable<String> linesadded)
{
var last = fm.GetNextFolding(lastfold.StartOffset);
foreach (var line in linesadded)
{
var M = r.Match(line);
if (M.Success)
{
endfold = n + line.Length;
if (!prev)
{
prev = true;
startfold = n;
lastfold = new NewFolding(startfold, endfold);
fm.CreateFolding(startfold, endfold).Title = "FileSync Complete";
}
else
{
last.EndOffset = endfold;
}
}
else
{
if (prev)
{
lastfold = new NewFolding(startfold, endfold);
fm.CreateFolding(startfold, endfold).Title = "FileSync Complete";
}
prev = false;
}
linenr++;
n += line.Length+1;
}
}
/// <summary>
/// Create new folding for a givem visual basic string representation.
/// </summary>
/// <param name="text"></param>
/// <param name="lowerCaseText"></param>
/// <param name="keyword"></param>
/// <returns></returns>
public IEnumerable<NewFolding> GetFoldings(string text, string lowerCaseText, string keyword)
{
const char vbCr = '\r';
const char vbLf = '\n';
////const string vbCrLf = "\r\n";
List<NewFolding> foldings = new List<NewFolding>();
string closingKeyword = "end " + keyword;
int closingKeywordLength = closingKeyword.Length;
keyword += " ";
int keywordLength = keyword.Length;
Stack<int> startOffsets = new Stack<int>();
for (int i = 0; i <= text.Length - closingKeywordLength; i++)
{
if (lowerCaseText.Substring(i, keywordLength) == keyword)
{
int k = i;
if (k > 0)
{
int lastLetterPos = i;
while (!(text[k - 1] == vbLf || text[k - 1] == vbCr))
{
if (char.IsLetter(text[k]))
lastLetterPos = k;
k -= 1;
if (k == 0)
break;
}
//if (lastLetterPos > k) Dirkster99 Not sure why this is necessary
// k = lastLetterPos;
}
startOffsets.Push(k);
}
else if (lowerCaseText.Substring(i, closingKeywordLength) == closingKeyword)
{
int startOffset = startOffsets.Pop();
NewFolding newFolding = new NewFolding(startOffset, i + closingKeywordLength);
int p = text.IndexOf(vbLf, startOffset);
if (p == -1)
p = text.IndexOf(vbCr, startOffset);
if (p == -1)
p = text.Length - 1;
newFolding.Name = text.Substring(startOffset, p - startOffset);
foldings.Add(newFolding);
}
}
return foldings;
}
public override void VisitPreProcessorDirective(PreProcessorDirective preProcessorDirective)
{
switch (preProcessorDirective.Type) {
case PreProcessorDirectiveType.Region:
NewFolding folding = new NewFolding();
folding.DefaultClosed = true;
folding.Name = preProcessorDirective.Argument;
folding.StartOffset = GetOffset(preProcessorDirective.StartLocation);
regions.Push(folding);
break;
case PreProcessorDirectiveType.Endregion:
if (regions.Count > 0) {
folding = regions.Pop();
folding.EndOffset = GetOffset(preProcessorDirective.EndLocation);
foldings.Add(folding);
}
break;
}
}
/// <summary>
/// Create <see cref="NewFolding"/>s for the specified document.
/// </summary>
public IEnumerable<NewFolding> CreateNewFoldings(ITextSource document)
{
var newFoldings = new List<NewFolding>();
var template = FoldingTemplates[0];
var regexOpenFolding = new Regex(template.OpeningPhrase);
var matchesOpenFolding = regexOpenFolding.Matches(document.Text);
var regexCloseFolding = new Regex(template.ClosingPhrase);
var matchesCloseFolding = regexCloseFolding.Matches(document.Text);
var currentOpenIndex = 0;
for (var i = 0; i < matchesCloseFolding.Count && currentOpenIndex < matchesOpenFolding.Count; i++)
{
if (matchesOpenFolding[currentOpenIndex].Index >= matchesCloseFolding[i].Index)
continue;
var folding = new NewFolding(matchesOpenFolding[currentOpenIndex].Index + 1,
matchesCloseFolding[i].Index + 10)
{
DefaultClosed = template.IsDefaultFolded,
Name = template.Name
};
newFoldings.Add(folding);
while (currentOpenIndex < matchesOpenFolding.Count &&
matchesOpenFolding[currentOpenIndex].Index < matchesCloseFolding[i].Index)
{
currentOpenIndex++;
}
}
return newFoldings;
}
public void GenerateFolds_MethodCalled_FoldsFromFoldParserUsedToUpdateTextEditor()
{
CreateFakeTextEditor();
CreateFoldGenerator();
string html = "<p></p>";
SetTextInTextEditor(html);
var expectedFolds = new NewFolding[] {
new NewFolding()
};
SetFoldsToReturnFromFoldParserForHtml(expectedFolds, html);
foldGenerator.GenerateFolds();
fakeTextEditor.AssertWasCalled(textEditor => textEditor.UpdateFolds(expectedFolds));
}
void SetFoldsToReturnFromFoldParserForHtml(NewFolding[] expectedFolds, string html)
{
fakeFoldParser.Stub(parser => parser.GetFolds(html))
.Return(expectedFolds);
}
public IEnumerable<NewFolding> CreateNewFoldings(ITextSource document)
{
List<NewFolding> newFoldings = new List<NewFolding>();
_procList = new List<ProcListItem>();
int startPos = 0;
int len = document.TextLength;
int currentStart = 0;
bool MethodIsOpen = false;
string MethodName ="";
string EndToken = null;
int PreCommentStart = -1;
//var Reader = document.CreateReader();
string FullText = document.Text;
int DocLine = 0;
int MethodStart = 0;
const string kProcStart = "ПРОЦЕДУРА";
const string kProcEnd = "КОНЕЦПРОЦЕДУРЫ";
const string kFuncStart = "ФУНКЦИЯ";
const string kFuncEnd = "КОНЕЦФУНКЦИИ";
char[] trimArr = new char[]{' ','\t'};
do
{
int prev_start = startPos;
string lineText = ReadLine(FullText, ref startPos);
DocLine++;
if (lineText == null)
{
break;
}
TextFragment tf = new TextFragment();
tf.offset = prev_start;
tf.len = lineText.Length;
//startPos += lineText.Length + 2;
if (!MethodIsOpen)
{
bool CommentBreak = false;
if (lineText.StartsWith("//"))
{
if (PreCommentStart < 0)
{
PreCommentStart = tf.offset + tf.len;
}
}
else
{
CommentBreak = true;
}
if (LineIsKeyword(lineText.TrimStart(trimArr), kProcStart))
{
MethodIsOpen = true;
MethodName = ScanForParamList(FullText, prev_start+kProcStart.Length);
EndToken = kProcEnd;
MethodStart = DocLine;
}
else if(LineIsKeyword(lineText.TrimStart(trimArr), kFuncStart))
{
MethodIsOpen = true;
MethodName = ScanForParamList(FullText, prev_start + kFuncStart.Length);
EndToken = kFuncEnd;
MethodStart = DocLine;
}
if (MethodIsOpen)
{
currentStart = tf.offset + tf.len;
if (PreCommentStart >= 0)
{
var Folding = new NewFolding(PreCommentStart, tf.offset-1);
newFoldings.Add(Folding);
PreCommentStart = -1;
}
}
else if(CommentBreak)
{
PreCommentStart = -1;
}
}
else if (LineIsKeyword(lineText.TrimStart(trimArr), EndToken))
{
var Folding = new NewFolding(currentStart, tf.offset + tf.len);
newFoldings.Add(Folding);
if (MethodName != "")
{
ProcListItem pli = new ProcListItem();
pli.Name = MethodName;
pli.StartLine = MethodStart;
pli.EndLine = DocLine;
pli.ListIndex = _procList.Count;
_procList.Add(pli);
MethodName = "";
}
MethodIsOpen = false;
}
}
while (true);
return newFoldings;
}
NewFolding ConvertToNewFold(FoldingRegion foldingRegion)
{
NewFolding newFold = new NewFolding();
newFold.Name = foldingRegion.Name;
newFold.StartOffset = GetStartOffset(foldingRegion.Region);
newFold.EndOffset = GetEndOffset(foldingRegion.Region);
return newFold;
}
public static string ConvertToString(NewFolding fold)
{
return String.Format("Name: '{0}' StartOffset: {1} EndOffset: {2} DefaultClosed: {3}",
fold.Name, fold.StartOffset, fold.EndOffset, fold.DefaultClosed);
}
NewFolding CreateTestNewFolding()
{
NewFolding expectedFold = new NewFolding();
expectedFold.DefaultClosed = false;
expectedFold.StartOffset = 5;
expectedFold.EndOffset = 10;
expectedFold.Name = "test";
return expectedFold;
}
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;
}
/// <inheritdoc/>
protected override IEnumerable<NewFolding> CreateNewFoldings(
AvalonEditDocument document, out int firstErrorOffset)
{
firstErrorOffset = -1;
List<NewFolding> foldings = new List<NewFolding>();
Stack<NewFolding> activeFoldings = new Stack<NewFolding>();
Stack<int> activeIndentations = new Stack<int>();
NewFolding activeFolding = null;
int activeIndentation = -1;
int endOffsetOfLastNonEmptyLine = 0;
for (int lineNumber = 1; lineNumber <= document.LineCount; lineNumber++)
{
var line = document.GetLineByNumber(lineNumber);
// Determine indentation of line.
int offset = line.Offset;
int indentation = 0;
bool isLineEmpty = true;
for (int i = 0; i < line.Length; i++)
{
if (char.IsWhiteSpace(document.GetCharAt(offset + i)))
{
indentation++;
}
else
{
// Found the first non-white space character.
isLineEmpty = false;
break;
}
}
// Skip empty lines.
if (isLineEmpty)
continue;
// If the indentation is less than the previous, then we close the last active
// folding.
if (indentation < activeIndentation)
{
// ReSharper disable once PossibleNullReferenceException
activeFolding.EndOffset = endOffsetOfLastNonEmptyLine;
// Keep foldings which span more than one line.
if (document.GetLineByOffset(activeFolding.StartOffset) != document.GetLineByOffset(activeFolding.EndOffset))
foldings.Add(activeFolding);
if (activeFoldings.Count > 0)
{
activeFolding = activeFoldings.Pop();
activeIndentation = activeIndentations.Pop();
}
else
{
activeFolding = null;
activeIndentation = -1;
}
// Test same line again. The previous folding could also end on this line.
lineNumber--;
continue;
}
endOffsetOfLastNonEmptyLine = line.EndOffset;
// If the indentation is larger than the previous indentation, we start a new
// folding.
if (indentation > 0 && indentation > activeIndentation)
{
// Store current folding on stack.
if (activeFolding != null)
{
activeFoldings.Push(activeFolding);
activeIndentations.Push(activeIndentation);
}
activeFolding = new NewFolding { StartOffset = offset + indentation, };
activeIndentation = indentation;
}
}
// Close all open foldings.
while (activeFoldings.Count > 0)
{
var folding = activeFoldings.Pop();
folding.EndOffset = endOffsetOfLastNonEmptyLine;
foldings.Add(folding);
}
foldings.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset));
return foldings;
}
private NewFolding CreateElementFold(TextDocument document, HtmlNode node)
{
NewFolding newFold = new NewFolding();
if (node.Line != node.EndNode.Line)
{
if (this.ShowAttributesWhenFolded && node.HasAttributes)
newFold.Name = String.Concat("<", node.Name, " ", GetAttributeFoldText(node), ">");
else
newFold.Name = String.Concat("<", node.Name, ">");
newFold.StartOffset = document.GetOffset(node.Line, node.LinePosition - 1);
newFold.EndOffset = document.GetOffset(node.EndNode.Line, node.EndNode.LinePosition + node.OriginalName.Length + 3);
}
return newFold;
}