public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (_sections == null || _sections.Count == 0 || spans.Count == 0)
{
yield break;
}
ITextSnapshot snapshot = spans[0].Snapshot;
foreach (var section in _sections)
{
var sectionSpan = section.Span.GetSpan(snapshot);
if (spans.IntersectsWith(new NormalizedSnapshotSpanCollection(sectionSpan)))
{
string firstLine = sectionSpan.Start.GetContainingLine().GetText().TrimStart(' ', '\t', '#');
string collapsedHintText;
if (sectionSpan.Length > 250)
{
collapsedHintText = snapshot.GetText(sectionSpan.Start, 247) + "...";
}
else
{
collapsedHintText = sectionSpan.GetText();
}
var tag = new OutliningRegionTag(firstLine, collapsedHintText);
yield return(new TagSpan <IOutliningRegionTag>(sectionSpan, tag));
}
}
}
private static void AddRegion(int spanStart,
string text,
ICollection <TagInformation <IOutliningRegionTag> > regions,
int start,
int end,
string collapsedText,
string collapsedTooltip)
{
if (collapsedText == null)
{
collapsedText = "...";
}
var length = end - start;
if (collapsedTooltip == null)
{
collapsedTooltip = text.Substring(start, length);
}
if (text.IndexOf('\n', start, end - start) == -1)
{
return;
}
var tag = new OutliningRegionTag(false, false, collapsedText, collapsedTooltip);
regions.Add(new TagInformation <IOutliningRegionTag>(start + spanStart, length, tag));
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (_sections == null || _sections.Count == 0 || spans.Count == 0)
{
yield break;
}
var snapshot = spans[0].Snapshot;
foreach (var section in _sections)
{
var sectionSpan = section.GetSpan(snapshot);
if (spans.IntersectsWith(new NormalizedSnapshotSpanCollection(sectionSpan)))
{
var firstLine = sectionSpan.GetText();
firstLine = "{}";
var collapsedHintText = sectionSpan.Length <= 250 ?
sectionSpan.GetText() :
snapshot.GetText(sectionSpan.Start, 249) + "…";
var tag = new OutliningRegionTag(firstLine, collapsedHintText);
yield return(new TagSpan <IOutliningRegionTag>(sectionSpan, tag));
}
}
}
/// <summary>
/// Ases the outlining region tag.
/// </summary>
/// <returns></returns>
public TagSpan<IOutliningRegionTag> AsOutliningRegionTag()
{
var span = this.AsSnapshotSpan();
bool collapsed = (this.Type == RegionType.Custom);
var tag = new OutliningRegionTag(collapsed, false, this.Text, span.GetText());
return new TagSpan<IOutliningRegionTag>(span, tag);
}
public OutliningRegion(
OutliningRegionTag tag,
SnapshotSpan span,
int cookie)
{
Tag = tag;
Span = span;
Cookie = cookie;
}
public OutliningRegion(
OutliningRegionTag tag,
SnapshotSpan span,
int cookie)
{
Tag = tag;
Span = span;
Cookie = cookie;
}
internal OutliningData(
ITrackingSpan trackingSpan,
OutliningRegionTag tag,
int cookie)
{
TrackingSpan = trackingSpan;
Tag = tag;
Cookie = cookie;
}
protected override ITagSpan <IOutliningRegionTag> CreateTagSpan(ITextSnapshot snapshot, OutliningRegionSpan rawTag)
{
var textSpan = rawTag.Span;
var span = new Span(textSpan.Start, textSpan.Length);
var snapshotSpan = new SnapshotSpan(snapshot, span);
var hint = snapshot.GetText(span);
var tag = new OutliningRegionTag(false, false, rawTag.Text, hint);
var tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
return(tagSpan);
}
/// <summary>
/// Get all of the values which map to the given ITextSnapshot
/// </summary>
private IEnumerable <ITagSpan <OutliningRegionTag> > GetRegions(ITextSnapshot snapshot)
{
foreach (var cur in _map.Values)
{
var option = TrackingSpanUtil.GetSpan(snapshot, cur.TrackingSpan);
if (option.IsSome())
{
var tag = new OutliningRegionTag(cur.Text, cur.Hint);
yield return(new TagSpan <OutliningRegionTag>(option.Value, tag));
}
}
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0 || _doc == null || !MarkdownEditorPackage.Options.EnableOutlining)
{
yield break;
}
var descendants = _doc.Descendants();
var snapshot = spans.First().Snapshot;
// Code blocks
var codeBlocks = descendants.OfType <FencedCodeBlock>();
foreach (var block in codeBlocks)
{
if (block.IsOpen || block.Lines.Count == 0)
{
continue;
}
string text = $"{block.Info.ToUpperInvariant()} Code Block".Trim();
string tooltip = new string(block.Lines.ToString().Take(800).ToArray());
var span = new SnapshotSpan(snapshot, block.ToSimpleSpan());
var tag = new OutliningRegionTag(false, false, text, tooltip);
yield return(new TagSpan <IOutliningRegionTag>(span, tag));
}
// HTML Blocks
var htmlBlocks = descendants.OfType <HtmlBlock>();
foreach (var block in htmlBlocks)
{
// This prevents outlining for single line comments
if (block.Lines.Count == 1)
{
continue;
}
string text = "HTML Block";
string tooltip = new string(block.Lines.ToString().Take(800).ToArray());
var span = new SnapshotSpan(snapshot, block.ToSimpleSpan());
var tag = new OutliningRegionTag(false, false, text, tooltip);
yield return(new TagSpan <IOutliningRegionTag>(span, tag));
}
}
private ITagSpan <IOutliningRegionTag> OutlineBlock(IToken firstBrace, IToken lastBrace, ITextSnapshot snapshot)
{
Span span = Span.FromBounds(firstBrace.StartIndex, lastBrace.StopIndex + 1);
if (snapshot.GetLineNumberFromPosition(span.Start) == snapshot.GetLineNumberFromPosition(span.End))
{
return(null);
}
SnapshotSpan snapshotSpan = new SnapshotSpan(snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag("...", "...");
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
return(tagSpan);
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count > 0)
{
SnapshotRegions currentSnapshotRegions;
lock (this.resourceLock)
{
currentSnapshotRegions = this.snapshotRegions;
}
ITextSnapshot currentSnapshot = currentSnapshotRegions.Snapshot;
SnapshotSpan entire = new SnapshotSpan(spans[0].Start, spans[spans.Count - 1].End)
.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
int startLineNumber = entire.Start.GetContainingLine().LineNumber;
int endLineNumber = entire.End.GetContainingLine().LineNumber;
foreach (var region in currentSnapshotRegions.Regions)
{
if (region.StartLine <= endLineNumber && region.EndLine >= startLineNumber)
{
var startLine = currentSnapshot.GetLineFromLineNumber(region.StartLine);
string startLineText = startLine.GetText();
Match match = this.startExpressions.Select(regex => regex.Match(startLineText)).FirstOrDefault(m => m.Success);
if (match != null)
{
string text = match.Groups[ScanInfo.RegexCommentGroupName].Value;
if (text.StartsWith(RegionToken))
{
text = text.Substring(RegionToken.Length).Trim();
}
if (string.IsNullOrWhiteSpace(text))
{
text = RegionToken;
}
// The region starts at the beginning of the start expression and goes until the *end* of the line that contains the end expression.
var endLine = currentSnapshot.GetLineFromLineNumber(region.EndLine);
var regionSpan = new SnapshotSpan(startLine.Start + region.StartOffset, endLine.End);
string hoverText = region.GetHoverText(currentSnapshot, startLineText, match);
var regionTag = new OutliningRegionTag(false, false, text, hoverText);
yield return(new TagSpan <IOutliningRegionTag>(regionSpan, regionTag));
}
}
}
}
}
private void OutlineBlock(IToken startToken, IToken stopToken, object collapsedForm)
{
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
// don't collapse blocks that don't span multiple lines
if (_snapshot.GetLineNumberFromPosition(span.Start) == _snapshot.GetLineNumberFromPosition(span.End))
{
return;
}
SnapshotSpan snapshotSpan = new SnapshotSpan(_snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag(false, false, collapsedForm, snapshotSpan.GetText());
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
_outliningRegions.Add(tagSpan);
}
private void CreateTag(SyntaxToken startToken, SyntaxToken endToken)
{
if (startToken == null || !startToken.Span.IsInRootFile
|| endToken == null || !endToken.Span.IsInRootFile)
return;
var span = new Span(startToken.Span.End, endToken.Span.End - startToken.Span.End);
if (_snapshot.GetLineNumberFromPosition(span.Start) == _snapshot.GetLineNumberFromPosition(span.End))
return;
var snapshotSpan = new SnapshotSpan(_snapshot, span);
var tag = new OutliningRegionTag("...", snapshotSpan.GetText());
var tagSpan = new TagSpan<IOutliningRegionTag>(snapshotSpan, tag);
_results.Add(tagSpan);
}
private void OutlineBlock(CommonTree subchild)
{
if (subchild == null || subchild.Type != LBRACE)
return;
var startToken = _tokens[subchild.TokenStartIndex];
var stopToken = _tokens[subchild.TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
if (_snapshot.GetLineNumberFromPosition(span.Start) == _snapshot.GetLineNumberFromPosition(span.End))
return;
SnapshotSpan snapshotSpan = new SnapshotSpan(_snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag();
TagSpan<IOutliningRegionTag> tagSpan = new TagSpan<IOutliningRegionTag>(snapshotSpan, tag);
_outliningRegions.Add(tagSpan);
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
try
{
if (spans.Count == 0)
{
return(EmptyTagList);
}
var currentRegions = _regions;
var currentSnapshot = _snapshot;
var entire = new SnapshotSpan(spans[0].Start, spans[spans.Count - 1].End).TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
var startLineNumber = entire.Start.GetContainingLine().LineNumber;
var endLineNumber = entire.End.GetContainingLine().LineNumber;
var tags = new List <ITagSpan <IOutliningRegionTag> >();
foreach (var region in currentRegions)
{
if (region.StartLine <= endLineNumber && region.EndLine >= startLineNumber)
{
var startLine = currentSnapshot.GetLineFromLineNumber(region.StartLine);
var endLine = currentSnapshot.GetLineFromLineNumber(region.EndLine);
var snapshot = new SnapshotSpan(startLine.Start + region.StartOffset, endLine.End);
const bool isDefaultCollapsed = true;
const bool isImplementation = true;
var collapsedForm = region.Text;
var collapsedHintForm = snapshot.GetText();
var outliningRegionTag = new OutliningRegionTag(isDefaultCollapsed, isImplementation, collapsedForm, collapsedHintForm);
var tagSpan = new TagSpan <IOutliningRegionTag>(snapshot, outliningRegionTag);
tags.Add(tagSpan);
}
}
return(tags);
}
catch (Exception e)
{
Log.Push(e);
return(EmptyTagList);
}
}
IEnumerable <ITagSpan <IOutliningRegionTag> > ToRegionTags(IEnumerable <OutliningDefinition> outliningDefinitions, SyntaxTreeAndSnapshot syntaxTreeAndSnapshot)
{
foreach (var outliningDefinition in outliningDefinitions)
{
var foldingExtent = outliningDefinition.FoldingExtent;
var previewExtent = outliningDefinition.PreviewExtent;
var foldingSpan = new SnapshotSpan(new SnapshotPoint(syntaxTreeAndSnapshot.Snapshot, foldingExtent.Start), length: foldingExtent.Length);
var previewSpan = new SnapshotSpan(new SnapshotPoint(syntaxTreeAndSnapshot.Snapshot, previewExtent.Start), length: previewExtent.Length);
var tag = new OutliningRegionTag(
isDefaultCollapsed: outliningDefinition.IsDefaultCollapsed,
isImplementation: outliningDefinition.IsImplementation,
collapsedForm: outliningDefinition.CollapsedText,
collapsedHintForm: _codeContentControlProvider.CreateContentControlForOutlining(previewSpan));
yield return(new TagSpan <IOutliningRegionTag>(foldingSpan, tag));
}
}
private void HandleBackgroundParseComplete(object sender, ParseResultEventArgs e)
{
AntlrParseResultEventArgs antlrParseResultArgs = e as AntlrParseResultEventArgs;
List <ITagSpan <IOutliningRegionTag> > outliningRegions = new List <ITagSpan <IOutliningRegionTag> >();
if (antlrParseResultArgs != null)
{
IAstRuleReturnScope resultArgs = antlrParseResultArgs.Result as IAstRuleReturnScope;
CommonTree result = resultArgs != null ? resultArgs.Tree as CommonTree : null;
if (result != null && result.Children != null)
{
foreach (CommonTree child in result.Children)
{
if (child == null || string.IsNullOrEmpty(child.Text))
{
continue;
}
switch (child.Type)
{
case GoLexer.KW_IMPORT:
case GoLexer.KW_TYPE:
case GoLexer.KW_CONST:
case GoLexer.KW_FUNC:
var startToken = antlrParseResultArgs.Tokens[child.TokenStartIndex];
var stopToken = antlrParseResultArgs.Tokens[child.TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
SnapshotSpan snapshotSpan = new SnapshotSpan(e.Snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag();
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
outliningRegions.Add(tagSpan);
break;
default:
continue;
}
}
}
}
this._outliningRegions = outliningRegions;
OnTagsChanged(new SnapshotSpanEventArgs(new SnapshotSpan(e.Snapshot, new Span(0, e.Snapshot.Length))));
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
sectionsLock.EnterReadLock();
try
{
if (Settings.Default.DisableAllParsing || sections == null || sections.Count == 0 || spans.Count == 0)
{
yield break;
}
var snapshot = spans[0].Snapshot;
if (snapshot.TextBuffer != sections.First().TextBuffer)
{
// stop if spans and sections doesn't belong to the same TextBuffer
yield break;
}
foreach (var section in sections)
{
var sectionSpan = section.GetSpan(snapshot);
if (!spans.IntersectsWith(new NormalizedSnapshotSpanCollection(sectionSpan)))
{
continue;
}
var firstLine = sectionSpan.Start.GetContainingLine().GetText().TrimStart(' ', '\t', '#');
var collapsedHintText = sectionSpan.Length > 250
? snapshot.GetText(sectionSpan.Start, 247) + "..."
: sectionSpan.GetText();
var tag = new OutliningRegionTag(firstLine, collapsedHintText);
yield return(new TagSpan <IOutliningRegionTag>(sectionSpan, tag));
}
}
finally
{
sectionsLock.ExitReadLock();
}
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
var stylesheet = Editor.Document.Stylesheet;
var snapshot = Buffer.CurrentSnapshot;
if (spans.Count == 0 || stylesheet == null)
{
return(new List <ITagSpan <IOutliningRegionTag> >(0));
}
var results = new SortedList <int, ITagSpan <IOutliningRegionTag> >();
foreach (var block in GetBlocks(new ParseItemList {
stylesheet as Stylesheet
}, spans[0].Start, spans[spans.Count - 1].End))
{
var open = block.OpenCurlyBrace;
var close = block.CloseCurlyBrace;
if (open != null && close != null)
{
// if some of our values go over range, then we are done
if (open.Start > snapshot.Length || close.Start > snapshot.Length)
{
return(results.Values);
}
var startLine = snapshot.GetLineFromPosition(open.Start);
var endLine = snapshot.GetLineFromPosition(close.Start);
if (startLine.LineNumber != endLine.LineNumber)
{
var span = new SnapshotSpan(snapshot, new Span(open.End, close.Start - open.End));
var tag = new OutliningRegionTag(false, false, "...", "...");
results.Add(span.Start.Position, new TagSpan <IOutliningRegionTag>(span, tag));
}
}
}
return(results.Values);
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0 || !EnsureInitialized())
{
yield break;
}
var visitor = new CssItemCollector <UrlItem>();
_tree.StyleSheet.Accept(visitor);
foreach (UrlItem url in visitor.Items.Where(u => u.UrlString != null && u.Start >= spans[0].Start))
{
if (url.UrlString.Text.IndexOf("base64,") > -1 && buffer.CurrentSnapshot.Length >= url.UrlString.AfterEnd)
{
var items = new List <object>();
ImageQuickInfo.AddImageContent(items, url.UrlString.Text.Trim('"', '\''));
// Replace any TextBuffers into strings for the tooltip to display.
// This works because base64 images are loaded synchronously, so we
// can compute the size before returning. If they do change, we'll
// need to replace them with TextBlocks & handle the Changed event.
for (int i = 0; i < items.Count; i++)
{
var tipBuffer = items[i] as ITextBuffer;
if (tipBuffer == null)
{
continue;
}
items[i] = tipBuffer.CurrentSnapshot.GetText();
}
var content = new ItemsControl {
ItemsSource = items
};
var span = new SnapshotSpan(new SnapshotPoint(buffer.CurrentSnapshot, url.UrlString.Start), url.UrlString.Length);
var tag = new OutliningRegionTag(true, true, url.UrlString.Length + " characters", content);
yield return(new TagSpan <IOutliningRegionTag>(span, tag));
}
}
}
private void CreateTag(SyntaxToken startToken, SyntaxToken endToken)
{
if (startToken == null || !startToken.Span.IsInRootFile ||
endToken == null || !endToken.Span.IsInRootFile)
{
return;
}
var span = new Span(startToken.Span.End, endToken.Span.End - startToken.Span.End);
if (_snapshot.GetLineNumberFromPosition(span.Start) == _snapshot.GetLineNumberFromPosition(span.End))
{
return;
}
var snapshotSpan = new SnapshotSpan(_snapshot, span);
var tag = new OutliningRegionTag("...", snapshotSpan.GetText());
var tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
_results.Add(tagSpan);
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
var snapshot = CurrentSnapshot;
var regions = CurrentRegions;
var startLine = spans[0].Start.GetContainingLine().LineNumber;
var endLine = spans[spans.Count - 1].End.GetContainingLine().LineNumber;
foreach (var region in regions.Where(x => x.StartLine <= endLine && x.EndLine >= startLine))
{
var span = AsSnapshotSpan(region, snapshot);
var tag = new OutliningRegionTag(false, false, ellipsis, span.GetText());
yield return(new TagSpan <IOutliningRegionTag>(span, tag));
}
}
private void HandleBackgroundParseComplete(object sender, ParseResultEventArgs e)
{
List <ITagSpan <IOutliningRegionTag> > outliningRegions = new List <ITagSpan <IOutliningRegionTag> >();
AntlrParseResultEventArgs antlrParseResultArgs = e as AntlrParseResultEventArgs;
if (antlrParseResultArgs != null)
{
var result = antlrParseResultArgs.Result as StringTemplateBackgroundParser.TemplateGroupRuleReturnScope;
if (result != null)
{
foreach (var templateInfo in result.Group.GetTemplateInformation())
{
var template = templateInfo.Template;
if (template.IsAnonSubtemplate)
{
continue;
}
if (template.IsRegion && template.RegionDefType != Antlr4.StringTemplate.Template.RegionType.Explicit)
{
continue;
}
Interval sourceInterval = templateInfo.GroupInterval;
SnapshotSpan span = new SnapshotSpan(e.Snapshot, new Span(sourceInterval.Start, sourceInterval.Length));
if (e.Snapshot.GetLineNumberFromPosition(span.Start) == e.Snapshot.GetLineNumberFromPosition(span.End))
{
continue;
}
IOutliningRegionTag tag = new OutliningRegionTag();
outliningRegions.Add(new TagSpan <IOutliningRegionTag>(span, tag));
}
}
}
this._outliningRegions = outliningRegions;
OnTagsChanged(new SnapshotSpanEventArgs(new SnapshotSpan(e.Snapshot, new Span(0, e.Snapshot.Length))));
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0 || !EnsureInitialized())
{
yield break;
}
var visitor = new CssItemCollector <UrlItem>();
_tree.StyleSheet.Accept(visitor);
foreach (UrlItem url in visitor.Items.Where(u => u.UrlString != null && u.Start >= spans[0].Start))
{
if (url.UrlString.Text.IndexOf("base64,") > -1 && buffer.CurrentSnapshot.Length >= url.UrlString.AfterEnd)
{
var image = ImageQuickInfo.CreateImage(url.UrlString.Text.Trim('"', '\''));
var span = new SnapshotSpan(new SnapshotPoint(buffer.CurrentSnapshot, url.UrlString.Start), url.UrlString.Length);
var tag = new OutliningRegionTag(true, true, url.UrlString.Length + " characters", image);
yield return(new TagSpan <IOutliningRegionTag>(span, tag));
}
}
}
private void OutlineBlock(CommonTree subchild)
{
if (subchild == null || subchild.Type != LBRACE)
{
return;
}
var startToken = _tokens[subchild.TokenStartIndex];
var stopToken = _tokens[subchild.TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
if (_snapshot.GetLineNumberFromPosition(span.Start) == _snapshot.GetLineNumberFromPosition(span.End))
{
return;
}
SnapshotSpan snapshotSpan = new SnapshotSpan(_snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag();
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
_outliningRegions.Add(tagSpan);
}
public void Update(AmmyFile <Top> file)
{
_regionList = new List <ITagSpan <IOutliningRegionTag> >();
var snapshot = (ITextSnapshot)file.Meta.Snapshot;
var nodeCollector = new AstCollectorVisitor(ast => ast is Node || ast is Function || ast is TypeFunctionRef);
file.Ast.Accept(nodeCollector);
foreach (var item in nodeCollector.CollectedItems)
{
var location = item.Location;
if (location.StartLineColumn.Line == location.EndLineColumn.Line)
{
continue;
}
var start = location.StartPos;
var text = location.GetText();
var closingBracketPos = text.LastIndexOf('}');
var openingBraceIndex = text.IndexOf("{", StringComparison.InvariantCultureIgnoreCase);
var ellipsis = openingBraceIndex > -1
? text.Substring(0, openingBraceIndex)
: text.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None).FirstOrDefault();
var snapshotSpan = new SnapshotSpan(snapshot, start, closingBracketPos + 1);
var outliningRegionTag = new OutliningRegionTag(false, false, ellipsis, text);
var span = new TagSpan <IOutliningRegionTag>(snapshotSpan, outliningRegionTag);
_regionList.Add(span);
}
var args = new SnapshotSpanEventArgs(new SnapshotSpan(snapshot, 0, snapshot.Length));
TagsChanged?.Invoke(this, args);
}
private static void AddRegion(int spanStart, string text, ICollection<TagInformation<IOutliningRegionTag>> regions,
int start, int end, string collapsedText, string collapsedTooltip)
{
if (collapsedText == null)
{
collapsedText = "...";
}
var length = end - start;
if (collapsedTooltip == null)
{
collapsedTooltip = text.Substring(start, length);
}
if (text.IndexOf('\n', start, end - start) == -1)
{
return;
}
var tag = new OutliningRegionTag(false, false, collapsedText, collapsedTooltip);
regions.Add(new TagInformation<IOutliningRegionTag>(start + spanStart, length, tag));
}
private void UpdateTags(AntlrParseResultEventArgs antlrParseResultArgs)
{
List <ITagSpan <IOutliningRegionTag> > outliningRegions = new List <ITagSpan <IOutliningRegionTag> >();
if (antlrParseResultArgs != null)
{
ITextSnapshot snapshot = antlrParseResultArgs.Snapshot;
#if false
IAstRuleReturnScope resultArgs = antlrParseResultArgs.Result as IAstRuleReturnScope;
var result = resultArgs.Tree as CommonTree;
if (result != null)
{
foreach (CommonTree child in result.Children)
{
if (child == null || string.IsNullOrEmpty(child.Text))
{
continue;
}
if (child.Text == "rule" && child.ChildCount > 0 || child.Text.StartsWith("tokens") || child.Text.StartsWith("options"))
{
string blockHint = "...";
if (child.Text == "rule")
{
string ruleName = child.Children[0].Text;
// don't try to outline the artificial tokens rule
if (ruleName == "Tokens")
{
continue;
}
blockHint = child.Children[0].Text + "...";
}
else if (child.Text.StartsWith("tokens"))
{
// this is the special tokens{} block of a combined grammar
blockHint = "tokens {...}";
}
else if (child.Text.StartsWith("options"))
{
// this is the special options{} block of a grammar
blockHint = "options {...}";
}
var startToken = antlrParseResultArgs.Tokens[child.TokenStartIndex];
var stopToken = antlrParseResultArgs.Tokens[child.TokenStopIndex];
if (startToken.Type == ANTLRParser.DOC_COMMENT)
{
for (int index = child.TokenStartIndex; index <= child.TokenStopIndex; index++)
{
startToken = antlrParseResultArgs.Tokens[index];
if (startToken.Type != ANTLRParser.DOC_COMMENT && startToken.Channel != TokenChannels.Hidden)
{
break;
}
}
}
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
if (snapshot.GetLineNumberFromPosition(span.Start) == snapshot.GetLineNumberFromPosition(span.End))
{
continue;
}
SnapshotSpan snapshotSpan = new SnapshotSpan(antlrParseResultArgs.Snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag(blockHint, snapshotSpan.GetText());
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
outliningRegions.Add(tagSpan);
}
}
}
foreach (var token in antlrParseResultArgs.Tokens)
{
switch (token.Type)
{
case ANTLRParser.DOC_COMMENT:
case ANTLRParser.ML_COMMENT:
Span commentSpan = Span.FromBounds(token.StartIndex, token.StopIndex + 1);
if (snapshot.GetLineNumberFromPosition(commentSpan.Start) != snapshot.GetLineNumberFromPosition(commentSpan.End))
{
SnapshotSpan commentSnapshotSpan = new SnapshotSpan(antlrParseResultArgs.Snapshot, commentSpan);
IOutliningRegionTag commentTag = new OutliningRegionTag(string.Format("/*{0} ... */", token.Type == ANTLRParser.DOC_COMMENT ? "*" : string.Empty), commentSnapshotSpan.GetText());
TagSpan <IOutliningRegionTag> commentTagSpan = new TagSpan <IOutliningRegionTag>(commentSnapshotSpan, commentTag);
outliningRegions.Add(commentTagSpan);
}
break;
default:
continue;
}
}
#endif
}
this._outliningRegions = outliningRegions;
OnTagsChanged(new SnapshotSpanEventArgs(new SnapshotSpan(antlrParseResultArgs.Snapshot, new Span(0, antlrParseResultArgs.Snapshot.Length))));
}
private void UpdateTags(AntlrParseResultEventArgs antlrParseResultArgs)
{
List <ITagSpan <IOutliningRegionTag> > outliningRegions = new List <ITagSpan <IOutliningRegionTag> >();
IAstRuleReturnScope resultArgs = antlrParseResultArgs.Result as IAstRuleReturnScope;
var result = resultArgs != null ? resultArgs.Tree as CommonTree : null;
if (result != null)
{
ITextSnapshot snapshot = antlrParseResultArgs.Snapshot;
// outline all the imports
IList <ITree> children = result.Children ?? new ITree[0];
for (int i = 0; i < children.Count; i++)
{
/*
* ^('import' 'static'? IDENTIFIER+ '*'?)
*
* ^('import' 'static'? IDENTIFIER+ '*'? ';')
*
* ^('import' 'static'? IDENTIFIER+ '*'? ';') ^('import' 'static'? IDENTIFIER+ '*'? ';')+
*
* ^('import' .* ';') ^('import' .* ';')+
*/
if (children[i].Type != Java2Lexer.IMPORT)
{
continue;
}
int firstImport = i;
while (i < children.Count - 1 && children[i + 1].Type == Java2Lexer.IMPORT)
{
i++;
}
int lastImport = i;
// start 1 token after the first 'import' token
var startToken = antlrParseResultArgs.Tokens[children[firstImport].TokenStartIndex + 1];
var stopToken = antlrParseResultArgs.Tokens[children[lastImport].TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
if (snapshot.GetLineNumberFromPosition(span.Start) == snapshot.GetLineNumberFromPosition(span.End))
{
continue;
}
SnapshotSpan snapshotSpan = new SnapshotSpan(antlrParseResultArgs.Snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag("...", snapshotSpan.GetText());
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
outliningRegions.Add(tagSpan);
}
/*
* ^(TYPE_BODY .* '}')
*
* ^(METHOD_BODY .* '}')
*/
// outline the type and method bodies
for (CommonTreeNodeStream treeNodeStream = new CommonTreeNodeStream(result);
treeNodeStream.LA(1) != CharStreamConstants.EndOfFile;
treeNodeStream.Consume())
{
switch (treeNodeStream.LA(1))
{
case Java2Lexer.TYPE_BODY:
case Java2Lexer.METHOD_BODY:
CommonTree child = treeNodeStream.LT(1) as CommonTree;
if (child != null)
{
var startToken = antlrParseResultArgs.Tokens[child.TokenStartIndex];
var stopToken = antlrParseResultArgs.Tokens[child.TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
if (snapshot.GetLineNumberFromPosition(span.Start) == snapshot.GetLineNumberFromPosition(span.End))
{
continue;
}
SnapshotSpan snapshotSpan = new SnapshotSpan(antlrParseResultArgs.Snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag("...", snapshotSpan.GetText());
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
outliningRegions.Add(tagSpan);
}
break;
default:
continue;
}
}
}
this._outliningRegions = outliningRegions;
OnTagsChanged(new SnapshotSpanEventArgs(new SnapshotSpan(antlrParseResultArgs.Snapshot, new Span(0, antlrParseResultArgs.Snapshot.Length))));
}
private void UpdateTags(PhpOutliningParseResultEventArgs antlrParseResultArgs)
{
List <ITagSpan <IOutliningRegionTag> > outliningRegions = new List <ITagSpan <IOutliningRegionTag> >();
if (antlrParseResultArgs != null)
{
ITextSnapshot snapshot = antlrParseResultArgs.Snapshot;
foreach (ParserRuleContext child in antlrParseResultArgs.OutliningTrees)
{
Interval sourceInterval = child.SourceInterval;
if (sourceInterval.a < 0 || sourceInterval.b < 0 || sourceInterval.Length <= 0)
{
continue;
}
var startToken = antlrParseResultArgs.Tokens[sourceInterval.a];
var stopToken = antlrParseResultArgs.Tokens[sourceInterval.b];
PhpParser.CodeContext codeContext = child as PhpParser.CodeContext;
if (codeContext != null && codeContext.Eof() != null)
{
stopToken = antlrParseResultArgs.Tokens.Last();
}
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
if (snapshot.GetLineNumberFromPosition(span.Start) == snapshot.GetLineNumberFromPosition(span.End))
{
continue;
}
if (codeContext != null)
{
int start = span.Start;
int end = span.End;
if (codeContext.HTML_START_CODE() != null)
{
start = codeContext.HTML_START_CODE().Symbol.StopIndex + 1;
}
if (codeContext.CLOSE_PHP_TAG() != null)
{
end = codeContext.CLOSE_PHP_TAG().Symbol.StartIndex;
}
span = Span.FromBounds(start, end);
}
SnapshotSpan snapshotSpan = new SnapshotSpan(antlrParseResultArgs.Snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag("...", string.Empty);
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
outliningRegions.Add(tagSpan);
}
//IAstRuleReturnScope resultArgs = antlrParseResultArgs.Result as IAstRuleReturnScope;
//var result = resultArgs.Tree as CommonTree;
//if (result != null)
//{
// ITextSnapshot snapshot = antlrParseResultArgs.Snapshot;
// foreach (CommonTree child in result.Children)
// {
// if (child.Type == CharStreamConstants.EndOfFile)
// continue;
// var startToken = antlrParseResultArgs.Tokens[child.TokenStartIndex];
// var stopToken = antlrParseResultArgs.Tokens[child.TokenStopIndex];
// Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
// if (snapshot.GetLineNumberFromPosition(span.Start) == snapshot.GetLineNumberFromPosition(span.End))
// continue;
// SnapshotSpan snapshotSpan = new SnapshotSpan(antlrParseResultArgs.Snapshot, span);
// IOutliningRegionTag tag = new OutliningRegionTag("...", string.Empty);
// TagSpan<IOutliningRegionTag> tagSpan = new TagSpan<IOutliningRegionTag>(snapshotSpan, tag);
// outliningRegions.Add(tagSpan);
// }
//}
}
this._outliningRegions = outliningRegions;
OnTagsChanged(new SnapshotSpanEventArgs(new SnapshotSpan(antlrParseResultArgs.Snapshot, new Span(0, antlrParseResultArgs.Snapshot.Length))));
}
public GLSLOutlineTag(GLSLTokenTypes type, string collapseText = COLLAPSE_TEXT, string collapseHint = COLLAPSE_HINT)
{
TokenType = type;
RegionTag = new OutliningRegionTag(false, false, collapseText, collapseHint);
}
private static TagSpan <IOutliningRegionTag> CreateTag(SnapshotSpan span, string text, string tooltip = null)
{
var tag = new OutliningRegionTag(false, false, text, tooltip);
return(new TagSpan <IOutliningRegionTag>(span, tag));
}
