void CreateAndAddAdornment(ITextViewLine line, SnapshotSpan span, Brush brush, bool extendToRight)
{
var markerGeometry = _view.TextViewLines.GetMarkerGeometry(span);
double left = 0;
double width = _view.ViewportWidth + _view.MaxTextRightCoordinate;
if (markerGeometry != null)
{
left = markerGeometry.Bounds.Left;
if (!extendToRight) width = markerGeometry.Bounds.Width;
}
Rect rect = new Rect(left, line.Top, width, line.Height);
RectangleGeometry geometry = new RectangleGeometry(rect);
GeometryDrawing drawing = new GeometryDrawing(brush, new Pen(), geometry);
drawing.Freeze();
DrawingImage drawingImage = new DrawingImage(drawing);
drawingImage.Freeze();
Image image = new Image();
image.Source = drawingImage;
Canvas.SetLeft(image, geometry.Bounds.Left);
Canvas.SetTop(image, geometry.Bounds.Top);
_layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, null, image, null);
}
public IEnumerable<SuggestedActionSet> GetSuggestedActions(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken)
{
var span = new SnapshotSpan(_view.Selection.Start.Position, _view.Selection.End.Position);
var startLine = span.Start.GetContainingLine().Extent;
var endLine = span.End.GetContainingLine().Extent;
var selectionStart = _view.Selection.Start.Position.Position;
var selectionEnd = _view.Selection.End.Position.Position;
var SelectedSpan = new SnapshotSpan(span.Snapshot, selectionStart, selectionEnd - selectionStart);
var list = new List<SuggestedActionSet>();
if (!_view.Selection.IsEmpty && startLine == endLine)
{
var convertToLink = new ConvertToLinkAction(SelectedSpan, _view);
var convertToImage = new ConvertToImageAction(SelectedSpan, _file);
list.AddRange(CreateActionSet(convertToLink, convertToImage));
}
var convertToQuote = new ConvertToQuoteAction(SelectedSpan, _view);
var convertToCodeBlock = new ConvertToCodeBlockAction(SelectedSpan, _view);
list.AddRange(CreateActionSet(convertToQuote, convertToCodeBlock));
return list;
}
public void ExtendToFullLineIncludingLineBreak2()
{
Create("dog", "cat", "chicken", "pig");
var span = new SnapshotSpan(_buffer.GetLine(1).Start, 0);
span = SnapshotSpanUtil.ExtendToFullLineIncludingLineBreak(span);
Assert.AreEqual(_buffer.GetLineRange(1).ExtentIncludingLineBreak, span);
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
List<ClassificationSpan> spans = new List<ClassificationSpan>();
if (!WESettings.GetBoolean(WESettings.Keys.SyncVendorValues) || !EnsureInitialized())
return spans;
var declarations = Cache.Where(d => span.End <= d.AfterEnd && d.Start >= span.Start);
foreach (Declaration dec in Cache.Where(d => d.PropertyName.Text.Length > 0 && span.Snapshot.Length >= d.AfterEnd))
{
if (dec.IsVendorSpecific())
{
var ss = new SnapshotSpan(span.Snapshot, dec.Start, dec.Length);
var s = new ClassificationSpan(ss, _decClassification);
spans.Add(s);
}
int start = dec.Colon.AfterEnd;
int length = dec.AfterEnd - start;
if (span.Snapshot.Length > start + length)
{
var ss2 = new SnapshotSpan(span.Snapshot, start, length);
var s2 = new ClassificationSpan(ss2, _valClassification);
spans.Add(s2);
}
}
return spans;
}
public Task<bool> HasSuggestedActionsAsync(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken)
{
return Task.Factory.StartNew(() =>
{
return !_view.Selection.IsEmpty;
});
}
public void AddDecorationError(BasePropertyDeclarationSyntax _property, string textFull, string toolTipText, FixErrorCallback errorCallback)
{
var lineSpan = tree.GetLineSpan(_property.Span, usePreprocessorDirectives: false);
int lineNumber = lineSpan.StartLinePosition.Line;
var line = _textView.TextSnapshot.GetLineFromLineNumber(lineNumber);
var textViewLine = _textView.GetTextViewLineContainingBufferPosition(line.Start);
int startSpace = textFull.Length - textFull.TrimStart().Length;
int endSpace = textFull.Length - textFull.TrimEnd().Length;
SnapshotSpan span = new SnapshotSpan(_textView.TextSnapshot, Span.FromBounds(line.Start.Position + startSpace, line.End.Position - endSpace));
Geometry g = _textView.TextViewLines.GetMarkerGeometry(span);
if (g != null)
{
rects.Add(g.Bounds);
GeometryDrawing drawing = new GeometryDrawing(_brush, _pen, g);
drawing.Freeze();
DrawingImage drawingImage = new DrawingImage(drawing);
drawingImage.Freeze();
Image image = new Image();
image.Source = drawingImage;
//image.Visibility = Visibility.Hidden;
Canvas.SetLeft(image, g.Bounds.Left);
Canvas.SetTop(image, g.Bounds.Top);
_layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, null, image, (t, ui) =>
{
rects.Remove(g.Bounds);
});
DrawIcon(span, g.Bounds.Left - 30, g.Bounds.Top, toolTipText, errorCallback);
}
}
protected void EnterSelect(int start, int length)
{
var span = new SnapshotSpan(_textBuffer.CurrentSnapshot, start, length);
_textView.SelectAndMoveCaret(span);
_context.RunAll();
Assert.Equal(ModeKind.SelectCharacter, _vimBuffer.ModeKind);
}
public IEnumerable<SuggestedActionSet> GetSuggestedActions(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken)
{
return
(
// code fixes
from tagSpan in _aggregator.GetTags(range)
where tagSpan.Tag is DiagnosticErrorTag
let diagnostic = tagSpan.Tag as DiagnosticErrorTag
from provider in _codeFixProviders
where provider.CanFix(diagnostic.Id)
let span = tagSpan.Span.GetSpans(_buffer).First()
from fix in provider.GetFixes(span)
group fix by provider into set
where set.Any()
select set as IEnumerable<CodeAction>
).Union(
// code refactorings
from provider in _refactoringProviders
from refactoring in provider.GetRefactorings(range)
group refactoring by provider into set
where set.Any()
select set as IEnumerable<CodeAction>
)
.Select(s => s.Select(ca => ca.ToSuggestedAction()))
.Select(s => new SuggestedActionSet(s))
;
}
private void ToggleCurrent() {
var caretPosition = _textView.Caret.Position.BufferPosition;
var snapshot = _textView.TextBuffer.CurrentSnapshot;
var span = new SnapshotSpan(snapshot, new Span(caretPosition, 0));
var regions = OutliningManager.GetAllRegions(span);
// Find innermost one
ICollapsible region = null;
int regionStart = 0;
int regionEnd = snapshot.Length;
foreach (ICollapsible c in regions) {
int start = c.Extent.GetStartPoint(snapshot);
int end = c.Extent.GetEndPoint(snapshot);
if (start >= regionStart && end < regionEnd) {
regionStart = start;
regionEnd = end;
region = c;
}
}
if (region != null) {
if (region.IsCollapsed)
OutliningManager.Expand(region as ICollapsed);
else
OutliningManager.TryCollapse(region);
}
}
public TranslationAdornment(SnapshotSpan span, TranslationRequest request, Size viewportSize)
{
Span = span.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive);
Request = request;
Request.TranslationComplete += request_TranslationComplete;
InitializeComponent();
DataContext = this;
SetMaxSize(viewportSize);
_menu = spListBox.ContextMenu;
_menu.KeyUp += (sender, args) =>
{
if (args.Key == Key.Left || args.Key == Key.Escape)
{
CloseMenu();
}
};
_menu.Opened += (sender, args) => { _closeMenuRequested = false; };
_menu.Closed += (sender, args) => { _ignoreItemCommand = !_closeMenuRequested; };
ItemCommand = new RelayCommand<ItemCommandParameter>(ItemCommandExecute);
ItemOptionsCommand = new RelayCommand<ItemCommandParameter>(ItemOptionsCommandExecute);
MenuCommand = new RelayCommand<MenuItem>(MenuCommandExecute);
}
private IList<ClassificationSpan> DoGetClassificationSpans(SnapshotSpan span)
{
List<ClassificationSpan> spans = null;
object prop;
if (span.Snapshot.TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out prop))
{
var doc = (ITextDocument)prop;
string fileName = System.IO.Path.GetFileName(doc.FilePath);
Language lang = Languages.FindLanguage(fileName);
if (lang != null)
{
List<ClassificationSpan> strings = new List<ClassificationSpan>();
List<ClassificationSpan> comments = new List<ClassificationSpan>();
DoGetStringSpans(lang, span, strings, comments);
spans = new List<ClassificationSpan>();
if (!strings.Any(s => s.Span.Contains(span) && !comments.Any(t => t.Span.Contains(span))))
{
IEnumerable<ClassificationSpan> mine = lang.GetClassificationSpans(span);
spans.AddRange(from c in mine where !strings.Any(d => d.Span.OverlapsWith(c.Span)) && !comments.Any(d => d.Span.OverlapsWith(c.Span)) select c);
}
spans.AddRange(strings);
spans.AddRange(comments);
}
}
return spans ?? ms_noSpans;
}
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
{
if (!session.TextView.Properties.ContainsProperty(SessionKey))
{
return;
}
// At the moment there is a bug in the javascript provider which causes it to
// repeatedly insert the same Signature values into an ISignatureHelpSession
// instance. There is no way, other than reflection, for us to prevent this
// from happening. Instead we just ensure that our provider runs after
// Javascript and then remove the values they add here
signatures.Clear();
// Map the trigger point down to our buffer.
var subjectTriggerPoint = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);
if (!subjectTriggerPoint.HasValue)
{
return;
}
var currentSnapshot = subjectTriggerPoint.Value.Snapshot;
var querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
var applicableToSpan = currentSnapshot.CreateTrackingSpan(
querySpan.Start.Position,
0,
SpanTrackingMode.EdgeInclusive);
string encouragement = encouragements.GetRandomEncouragement();
if (encouragement != null)
{
var signature = new Signature(applicableToSpan, encouragement, "", "");
signatures.Add(signature);
}
}
private static int CalculateDeletionEndFromRuleEndPosition(ITextSnapshot snapshot, int endPosition)
{
var position = endPosition;
var committedPosition = position;
while (true)
{
if (position < snapshot.Length)
{
var ss = new SnapshotSpan(snapshot, position, 1);
var text = ss.GetText();
if (text != null)
{
if ("\r\n".Contains(text))
{
committedPosition = ++position;
continue;
}
if (string.IsNullOrWhiteSpace(text))
{
++position;
continue;
}
}
}
return committedPosition;
}
}
public ReplSpan(bool wasCommand, bool wasException, SnapshotSpan input, SnapshotSpan? output)
{
WasCommand = wasCommand;
WasException = wasException;
Input = input;
Output = output;
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
IList<ClassificationSpan> list = new List<ClassificationSpan>();
if (!_isRobotsTxt)
return list;
string text = span.GetText();
int index = text.IndexOf("#");
if (index > -1)
{
var result = new SnapshotSpan(span.Snapshot, span.Start + index, text.Length - index);
list.Add(new ClassificationSpan(result, _comment));
}
if (index == -1 || index > 0)
{
string[] args = text.Split(':');
if (args.Length >= 2 && _valid.Contains(args[0].Trim().ToLowerInvariant()))
{
var result = new SnapshotSpan(span.Snapshot, span.Start, args[0].Length);
list.Add(new ClassificationSpan(result, _keyword));
}
}
return list;
}
internal ExternalEditMarker(
ExternalEditKind kind,
SnapshotSpan span)
{
ExternalEditKind = kind;
Span = span;
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
if (fileNode != null)
return fileNode.GetClassificationSpans(span);
return new List<ClassificationSpan>();
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
List<ClassificationSpan> spans = new List<ClassificationSpan>();
if (!WESettings.Instance.Css.SyncBase64ImageValues)
return spans;
foreach (Declaration dec in Cache.Where(d => d.PropertyName.Text.EndsWith("background-image", StringComparison.OrdinalIgnoreCase) && span.Start <= d.Start && span.End >= d.AfterEnd))
{
if (dec.PropertyName.Text.StartsWith("*background", StringComparison.OrdinalIgnoreCase))
{
var ss = new SnapshotSpan(span.Snapshot, dec.Start, dec.Length);
var s = new ClassificationSpan(ss, _decClassification);
spans.Add(s);
}
if (dec.Semicolon == null)
continue;
int start = dec.Colon.AfterEnd;
int length = dec.AfterEnd - start;
if (span.Snapshot.Length > start + length)
{
var ss2 = new SnapshotSpan(span.Snapshot, start, length);
var s2 = new ClassificationSpan(ss2, _valClassification);
spans.Add(s2);
}
}
return spans;
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
try
{
var spans = new List<ClassificationSpan>();
var snapshot = span.Snapshot;
if (snapshot == null || snapshot.Length == 0)
{
return spans;
}
LoadSettings();
var start = span.Start.GetContainingLine().LineNumber;
var end = (span.End - 1).GetContainingLine().LineNumber;
for (var i = start; i <= end; i++)
{
var line = snapshot.GetLineFromLineNumber(i);
var snapshotSpan = new SnapshotSpan(line.Start, line.Length);
var text = line.Snapshot.GetText(snapshotSpan);
if (string.IsNullOrEmpty(text) == false)
{
var classificationName = _classifiers.First(classifier => classifier.Test(text)).Type;
var type = _classificationTypeRegistry.GetClassificationType(classificationName);
spans.Add(new ClassificationSpan(line.Extent, type));
}
}
return spans;
}
catch (Exception ex)
{
LogError(ex.ToString());
throw;
}
}
/// <summary>
/// Classify the given spans
/// </summary>
/// <param name="span">The span of interest in this projection buffer.</param>
/// <returns>The list of <see cref="ClassificationSpan"/> as contributed by the source buffers.</returns>
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
ITextSnapshot snapshot = span.Snapshot;
List<ClassificationSpan> spans = new List<ClassificationSpan>();
if (snapshot.Length == 0)
return spans;
var text = span.GetText();
if (text.StartsWith("System.Windows.Data Error", StringComparison.OrdinalIgnoreCase))
{
IClassificationType type = _classificationTypeRegistry.GetClassificationType("output.wpfbindingalert");
spans.Add(new ClassificationSpan(span, type));
}
else if (text.IndexOf("error ", StringComparison.OrdinalIgnoreCase) >= 0 ||
text.IndexOf("error:", StringComparison.OrdinalIgnoreCase) >= 0)
{
//error followed by a space is the typical error of the build.
IClassificationType type = _classificationTypeRegistry.GetClassificationType("output.alert");
spans.Add(new ClassificationSpan(span, type));
}
else if (text.IndexOf("INFO:", StringComparison.OrdinalIgnoreCase) >= 0)
{
//error followed by a space is the typical error of the build.
IClassificationType type = _classificationTypeRegistry.GetClassificationType("output.info");
spans.Add(new ClassificationSpan(span, type));
}
return spans;
}
// This does not work properly for multiline fenced code-blocks,
// since we get each line separately. If I can assume that this
// always runs sequentially without skipping, I can add state to
// track whether we're in a fenced block.
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
string text = span.GetText();
var codeBlocks = FindMatches(span, text, _reCode, _code).ToList();
if (codeBlocks.Any())
{
// Flatten all code blocks to avoid matching text within them
var nonCodeBuilder = text.ToCharArray();
foreach (var code in codeBlocks)
{
for (int i = code.Span.Start; i < code.Span.End; i++)
{
nonCodeBuilder[i - span.Start] = 'Q';
}
}
text = new String(nonCodeBuilder);
}
var quotes = FindMatches(span, text, _reQuote, _quote);
var bolds = FindMatches(span, text, _reBold, _bold);
var italics = FindMatches(span, text, _reItalic, _italic);
var headers = FindMatches(span, text, _reHeader, _header);
return bolds.Concat(italics).Concat(headers).Concat(codeBlocks).Concat(quotes).ToList();
}
/// <summary>
/// Within the given line add the scarlet box behind the a
/// </summary>
private void CreateVisuals(ITextViewLine line)
{
//grab a reference to the lines in the current TextView
IWpfTextViewLineCollection textViewLines = _view.TextViewLines;
int start = line.Start;
int end = line.End;
//Loop through each character, and place a box around any a
for (int i = start; (i < end); ++i)
{
if (_view.TextSnapshot[i] == 'a')
{
SnapshotSpan span = new SnapshotSpan(_view.TextSnapshot, Span.FromBounds(i, i + 1));
Geometry g = textViewLines.GetMarkerGeometry(span);
if (g != null)
{
GeometryDrawing drawing = new GeometryDrawing(_brush, _pen, g);
drawing.Freeze();
DrawingImage drawingImage = new DrawingImage(drawing);
drawingImage.Freeze();
Image image = new Image();
image.Source = drawingImage;
//Align the image with the top of the bounds of the text geometry
Canvas.SetLeft(image, g.Bounds.Left);
Canvas.SetTop(image, g.Bounds.Top);
_layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, null, image, null);
}
}
}
}
/// <summary>
/// Is the current selection that of the C# event add pattern?
/// </summary>
internal bool IsEventAddSelection(ITextView textView)
{
var textSelection = textView.Selection;
if (textSelection.IsEmpty || textSelection.Mode != TextSelectionMode.Stream)
{
return false;
}
var span = textView.Selection.StreamSelectionSpan.SnapshotSpan;
var lineRange = SnapshotLineRangeUtil.CreateForSpan(span);
if (lineRange.Count != 1)
{
return false;
}
// Include the character after the selection. Needed to disambiguate a couple
// of cases
var endPoint = span.End;
if (endPoint.Position < lineRange.End.Position)
{
endPoint = endPoint.Add(1);
}
var beforeSpan = new SnapshotSpan(lineRange.Start, endPoint);
return IsPreceededByEventAddSyntax(beforeSpan);
}
private IEnumerable<SnapshotSpan> GetAllTags()
{
var snapshot = _textView.TextBuffer.CurrentSnapshot;
var snapshotSpan = new SnapshotSpan(snapshot, 0, snapshot.Length);
var tags = GetTags(snapshotSpan);
return tags;
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
IList<ClassificationSpan> spans = new List<ClassificationSpan>();
string text = span.GetText();
int index = text.IndexOf("#", StringComparison.Ordinal);
if (index > -1)
{
var result = new SnapshotSpan(span.Snapshot, span.Start + index, text.Length - index);
spans.Add(new ClassificationSpan(result, comment));
}
if (index == -1 || index > 0)
{
var trimmed = text.TrimStart();
var offset = text.Length - trimmed.Length;
string[] args = trimmed.Split(' ');
if (args.Length >= 2 && ValidKeywords.Contains(args[0].Trim().ToLowerInvariant()))
{
var result = new SnapshotSpan(span.Snapshot, span.Start + offset, args[0].Trim().Length);
spans.Add(new ClassificationSpan(result, keyword));
}
}
return spans;
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
var results = new List<ClassificationSpan>();
var snapshot = Buffer.CurrentSnapshot;
var stylesheet = Editor.Document.Stylesheet;
if (stylesheet != null)
{
try
{
foreach (var current in GetItems(stylesheet.Children, span))
{
if (current.Start > span.End)
break;
var type = ClassifierContextCache.Get(current.ClassifierType).GetClassification(Registry);
if (type == null)
continue;
var start = Math.Max(0, current.Start);
var length = Math.Min(snapshot.Length - start, current.Length);
results.Add(new ClassificationSpan(new SnapshotSpan(snapshot, new Span(start, length)), type));
}
}
catch (Exception ex)
{
Logger.Log(ex, "Failed to classify");
}
}
return results;
}
private static int CalculateDeletionStartFromStartPosition(ITextSnapshot snapshot, int startPosition)
{
var position = startPosition - 1;
if (position < 0)
{
return 0;
}
while (true)
{
if (position > 0)
{
var ss = new SnapshotSpan(snapshot, position, 1);
var text = ss.GetText();
if (text != null && !"\r\n".Contains(text) && string.IsNullOrWhiteSpace(text))
{
--position;
continue;
}
++position;
}
return position;
}
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span) {
var result = new List<ClassificationSpan>();
var semanticModelResult = SemanticModelService.SemanticModelResult;
if(semanticModelResult == null) {
return result;
}
var classificationType = ClassificationTypeRegistryService.GetClassificationType(ClassificationTypeNames.DeadCode);
var extent = TextExtent.FromBounds(span.Start.Position, span.End.Position);
var diagnostics = semanticModelResult.CompilationUnit.Diagnostics;
var candidates = diagnostics.Where(diagnostic => diagnostic.Category == DiagnosticCategory.DeadCode)
.Where(d => d.Location.Extent.IntersectsWith(extent));
foreach (var diagnostic in candidates) {
var diagnosticSpan = new SnapshotSpan(semanticModelResult.Snapshot, new Span(diagnostic.Location.Start, diagnostic.Location.Length));
var classification = new ClassificationSpan(
diagnosticSpan.TranslateTo(span.Snapshot, SpanTrackingMode.EdgeExclusive),
classificationType);
result.Add(classification);
}
return result;
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
IList<ClassificationSpan> list = new List<ClassificationSpan>();
string text = span.GetText();
if (text.StartsWith("/// <binding"))
{
foreach (Match match in _binding.Matches(text))
{
var value = match.Groups["value"];
var result = new SnapshotSpan(span.Snapshot, span.Start + value.Index, value.Length);
list.Add(new ClassificationSpan(result, _formatDefinition));
}
}
else
{
int index = text.IndexOf(_searchText, StringComparison.Ordinal);
if (index == -1)
return list;
foreach (Match match in _task.Matches(text))
{
var name = match.Groups["name"];
var result = new SnapshotSpan(span.Snapshot, span.Start + name.Index, name.Length);
list.Add(new ClassificationSpan(result, _formatDefinition));
}
}
return list;
}
/// <summary>
/// Is the provided SnapshotPoint preceded by the '+= SomeEventType(Some_HandlerName' line
/// </summary>
private bool IsPreceededByEventAddSyntax(SnapshotSpan span)
{
// First find the last + character
var snapshot = span.Snapshot;
SnapshotPoint? plusPoint = null;
for (int i = span.Length - 1; i >= 0; i--)
{
var position = span.Start.Position + i;
var point = new SnapshotPoint(snapshot, position);
if (point.GetChar() == '+')
{
plusPoint = point;
break;
}
}
if (plusPoint == null)
{
return false;
}
var eventSpan = new SnapshotSpan(plusPoint.Value, span.End);
var eventText = eventSpan.GetText();
return
s_fullEventSyntaxRegex.IsMatch(eventText) ||
s_shortEventSyntaxRegex.IsMatch(eventText);
}
/// <returns>True if the adornment was updated and should be kept. False to have the adornment removed from the view.</returns> protected abstract bool UpdateAdornment(TAdornment adornment, TData data, SnapshotSpan snapshot, SnapshotSpan containSpan);
public void OnClassificationChanged(SnapshotSpan span)
{
ClassificationChanged(this, new ClassificationChangedEventArgs(span));
}
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{ // there is no content in the buffer
yield break;
}
bool labelGraph_Enabled = this._labelGraph.Enabled;
bool asmSimulator_Enabled = this._asmSimulator.Enabled;
if (!labelGraph_Enabled && !asmSimulator_Enabled)
{ // nothing to decorate
yield break;
}
DateTime time1 = DateTime.Now;
//TODO move the followign boolean to constructor
bool Decorate_Undefined_Labels = labelGraph_Enabled && Settings.Default.IntelliSense_Decorate_Undefined_Labels;
bool Decorate_Clashing_Labels = labelGraph_Enabled && Settings.Default.IntelliSense_Decorate_Clashing_Labels;
bool Decorate_Undefined_Includes = labelGraph_Enabled && Settings.Default.IntelliSense_Show_Undefined_Includes;
bool Decorate_Registers_Known_Register_Values = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Registers;
bool Decorate_Syntax_Errors = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Syntax_Errors;
bool Decorate_Unimplemented = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Unimplemented;
bool Decorate_Usage_Of_Undefined = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Usage_Of_Undefined;
bool Decorate_Redundant_Instructions = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Redundant_Instructions;
bool Decorate_Unreachable_Instructions = asmSimulator_Enabled && Settings.Default.AsmSim_Decorate_Unreachable_Instructions;
bool Show_Syntax_Error_Error_List = asmSimulator_Enabled && Settings.Default.AsmSim_Show_Syntax_Errors;
bool Show_Usage_Of_Undefined = asmSimulator_Enabled && Settings.Default.AsmSim_Show_Usage_Of_Undefined;
AssemblerEnum usedAssember = AsmDudeToolsStatic.Used_Assembler;
foreach (IMappingTagSpan <AsmTokenTag> asmTokenTag in this._aggregator.GetTags(spans))
{
SnapshotSpan tagSpan = asmTokenTag.Span.GetSpans(this._sourceBuffer)[0];
//AsmDudeToolsStatic.Output_INFO(string.Format("SquigglesTagger:GetTags: found keyword \"{0}\"", tagSpan.GetText()));
int lineNumber = AsmDudeToolsStatic.Get_LineNumber(tagSpan);
switch (asmTokenTag.Tag.Type)
{
case AsmTokenType.Label:
{
if (Decorate_Undefined_Labels)
{
string label = tagSpan.GetText();
string full_Qualified_Label = AsmDudeToolsStatic.Make_Full_Qualified_Label(asmTokenTag.Tag.Misc, label, usedAssember);
if (this._labelGraph.Has_Label(full_Qualified_Label))
{
// Nothing to report
}
else
{
//AsmDudeToolsStatic.Output_INFO(string.Format("SquigglesTagger:GetTags: found label \"{0}\"; full-label \"{1}\"", label, full_Qualified_Label));
if (usedAssember == AssemblerEnum.MASM)
{
if (this._labelGraph.Has_Label(label))
{
// TODO: is this always a valid label? Nothing to report
}
else
{
var toolTipContent = this.Undefined_Label_Tool_Tip_Content();
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, toolTipContent)));
}
}
else
{
var toolTipContent = this.Undefined_Label_Tool_Tip_Content();
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, toolTipContent)));
}
}
}
break;
}
case AsmTokenType.LabelDef:
{
if (Decorate_Clashing_Labels)
{
string label = tagSpan.GetText();
string full_Qualified_Label = AsmDudeToolsStatic.Make_Full_Qualified_Label(asmTokenTag.Tag.Misc, label, usedAssember);
if (this._labelGraph.Has_Label_Clash(full_Qualified_Label))
{
var toolTipContent = this.Label_Clash_Tool_Tip_Content(full_Qualified_Label);
//PredefinedErrorTypeNames.Warning is green
//PredefinedErrorTypeNames.SyntaxError is red
//PredefinedErrorTypeNames.CompilerError is blue
//PredefinedErrorTypeNames.Suggestion is NOTHING
//PredefinedErrorTypeNames.OtherError is purple
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, toolTipContent)));
}
}
break;
}
case AsmTokenType.Register:
{
if (Decorate_Registers_Known_Register_Values)
{
Rn regName = RegisterTools.ParseRn(tagSpan.GetText());
//AsmDudeToolsStatic.Output_INFO("SquigglesTagger:GetTags: found register " + regName + " at line " + lineNumber);
bool preCompute = false;
var(HasValue1, Bussy1) = this._asmSimulator.Has_Register_Value(regName, lineNumber, true, preCompute);
if (!Bussy1)
{
var(HasValue2, Bussy2) = this._asmSimulator.Has_Register_Value(regName, lineNumber, false, preCompute);
if (!Bussy2)
{
if ((HasValue1 || HasValue2))
{ // only show squiggles to indicate that information is available
//AsmDudeToolsStatic.Output_INFO("SquigglesTagger:GetTags: adding squiggles for register " + regName + " at line " + lineNumber);
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.Warning)));
}
}
}
}
break;
}
case AsmTokenType.Mnemonic:
{
if (Decorate_Syntax_Errors || Decorate_Unimplemented)
{
if (this._asmSimulator.Is_Implemented(lineNumber))
{
if (Decorate_Syntax_Errors && this._asmSimulator.Has_Syntax_Error(lineNumber))
{
string message = AsmSourceTools.Linewrap("Syntax Error: " + this._asmSimulator.Get_Syntax_Error(lineNumber).Message, AsmDudePackage.maxNumberOfCharsInToolTips);
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, message)));
}
}
else if (Decorate_Unimplemented)
{
string message = AsmSourceTools.Linewrap("Info: Instruction " + tagSpan.GetText() + " is not (yet) supported by the simulator.", AsmDudePackage.maxNumberOfCharsInToolTips);
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.CompilerError, message)));
}
}
if (Decorate_Usage_Of_Undefined)
{
if (this._asmSimulator.Has_Usage_Undefined_Warning(lineNumber))
{
string message = AsmSourceTools.Linewrap("Semantic Warning: " + this._asmSimulator.Get_Usage_Undefined_Warning(lineNumber).Message, AsmDudePackage.maxNumberOfCharsInToolTips);
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.OtherError, message)));
}
}
if (Decorate_Redundant_Instructions)
{
if (this._asmSimulator.Has_Redundant_Instruction_Warning(lineNumber))
{
string message = AsmSourceTools.Linewrap("Semantic Warning: " + this._asmSimulator.Get_Redundant_Instruction_Warning(lineNumber).Message, AsmDudePackage.maxNumberOfCharsInToolTips);
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.OtherError, message)));
}
}
if (Decorate_Unreachable_Instructions)
{
if (this._asmSimulator.Has_Unreachable_Instruction_Warning(lineNumber))
{
string message = AsmSourceTools.Linewrap("Semantic Warning: " + this._asmSimulator.Get_Unreachable_Instruction_Warning(lineNumber).Message, AsmDudePackage.maxNumberOfCharsInToolTips);
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.OtherError, message)));
}
}
break;
}
case AsmTokenType.Constant:
{
if (Decorate_Undefined_Includes)
{
foreach (var tup in this._labelGraph.Undefined_Includes)
{
if (tup.LineNumber == lineNumber) //TODO this is inefficient!
{
var toolTipContent = "Could not resolve include \"" + tagSpan.GetText() + "\"";
yield return(new TagSpan <IErrorTag>(tagSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, toolTipContent)));
break; // leave the foreach loop
}
}
}
break;
}
default: break;
}
}
AsmDudeToolsStatic.Print_Speed_Warning(time1, "SquiggleTagger");
}
/// <summary>
/// Initializes a new instance of <see cref="RegionsChangedEventArgs"/> with the specified <see cref="SnapshotSpan" />.
/// </summary>
/// <param name="affectedSpan">The <see cref="SnapshotSpan"/> over which collapsible regions have changed.</param>
public RegionsChangedEventArgs(SnapshotSpan affectedSpan)
{
this.AffectedSpan = affectedSpan;
}
public static NormalizedSnapshotSpanCollection GetSpanInView(this ITextView textView, SnapshotSpan span)
{
return(textView.BufferGraph.MapUpToSnapshot(span, SpanTrackingMode.EdgeInclusive, textView.TextSnapshot));
}
public static bool IsReadOnlyOnSurfaceBuffer(this ITextView textView, SnapshotSpan span)
{
var spansInView = textView.BufferGraph.MapUpToBuffer(span, SpanTrackingMode.EdgeInclusive, textView.TextBuffer);
return(spansInView.Any(spanInView => textView.TextBuffer.IsReadOnly(spanInView.Span)));
}
/// <summary>
/// Get misspelled words in the given set of spans
/// </summary>
/// <param name="spans">The spans to check</param>
/// <returns>An enumerable list of misspelling tags</returns>
private IEnumerable <MisspellingTag> GetMisspellingsInSpans(NormalizedSnapshotSpanCollection spans)
{
List <Match> xmlTags = null;
SnapshotSpan errorSpan, deleteWordSpan;
Microsoft.VisualStudio.Text.Span lastWord;
string text, textToParse;
var ignoredWords = wordsIgnoredOnce;
foreach (var span in spans)
{
text = span.GetText();
// Note the location of all XML elements if needed
if (configuration.IgnoreXmlElementsInText)
{
xmlTags = reXml.Matches(text).OfType <Match>().ToList();
}
lastWord = new Microsoft.VisualStudio.Text.Span();
foreach (var word in GetWordsInText(text))
{
textToParse = text.Substring(word.Start, word.Length);
// Spell check the word if it looks like one and is not ignored
if (IsProbablyARealWord(textToParse) && (xmlTags == null || xmlTags.Count == 0 ||
!xmlTags.Any(match => word.Start >= match.Index &&
word.Start <= match.Index + match.Length - 1)))
{
// Check for a doubled word. This isn't perfect as it won't detected doubled words
// across a line break.
if (lastWord.Length != 0 && text.Substring(lastWord.Start, lastWord.Length).Equals(
textToParse, StringComparison.OrdinalIgnoreCase) && String.IsNullOrWhiteSpace(
text.Substring(lastWord.Start + lastWord.Length, word.Start - lastWord.Start - lastWord.Length)))
{
errorSpan = new SnapshotSpan(span.Start + word.Start, word.Length);
// If the doubled word is not being ignored at the current location, return it
if (!ignoredWords.Any(w => w.StartPoint == errorSpan.Start && w.Word.Equals(textToParse,
StringComparison.OrdinalIgnoreCase)))
{
// Delete the whitespace ahead of it too
deleteWordSpan = new SnapshotSpan(span.Start + lastWord.Start + lastWord.Length,
word.Length + word.Start - lastWord.Start - lastWord.Length);
yield return(new MisspellingTag(errorSpan, deleteWordSpan));
lastWord = word;
continue;
}
}
lastWord = word;
if (!_dictionary.ShouldIgnoreWord(textToParse) && !_dictionary.IsSpelledCorrectly(textToParse))
{
// Sometimes it flags a word as misspelled if it ends with "'s". Try checking the
// word without the "'s". If ignored or correct without it, don't flag it. This
// appears to be caused by the definitions in the dictionary rather than Hunspell.
if (textToParse.EndsWith("'s", StringComparison.OrdinalIgnoreCase))
{
textToParse = textToParse.Substring(0, textToParse.Length - 2);
if (_dictionary.ShouldIgnoreWord(textToParse) ||
_dictionary.IsSpelledCorrectly(textToParse))
{
continue;
}
textToParse += "'s";
}
// Some dictionaries include a trailing period on certain words such as "etc." which
// we don't include. If the word is followed by a period, try it with the period to
// see if we get a match. If so, consider it valid.
if (word.Start + word.Length < text.Length && text[word.Start + word.Length] == '.')
{
if (_dictionary.ShouldIgnoreWord(textToParse + ".") ||
_dictionary.IsSpelledCorrectly(textToParse + "."))
{
continue;
}
}
errorSpan = new SnapshotSpan(span.Start + word.Start, word.Length);
// If the word is not being ignored at the current location, return it and its
// suggested corrections.
if (!ignoredWords.Any(w => w.StartPoint == errorSpan.Start && w.Word.Equals(textToParse,
StringComparison.OrdinalIgnoreCase)))
{
yield return(new MisspellingTag(errorSpan, _dictionary.SuggestCorrections(textToParse)));
}
}
}
}
}
}
/// <summary>
/// Adds the scarlet box behind the 'a' characters within the given line
/// </summary>
/// <param name="line">Line to add the adornments</param>
private void CreateVisuals(SnapshotSpan leftItem, SnapshotSpan rightItem)
{
if (VSPackage.Options != null)
{
this.layer.RemoveAllAdornments();
var swapColor = (Color)ColorConverter.ConvertFromString(VSPackage.Options.ArrowColor);
var swapPenBrush = new SolidColorBrush(swapColor);
swapPenBrush.Freeze();
var swapPen = new Pen(swapPenBrush, 2);
swapPen.Freeze();
var textViewLines = this.view.TextViewLines;
renderAdorner(leftItem, false);
renderAdorner(rightItem, true);
void renderAdorner(SnapshotSpan snapshotSpan, bool isRight)
{
var geometry = textViewLines.GetMarkerGeometry(snapshotSpan);
if (geometry != null)
{
var swapRect = new Rect(geometry.Bounds.Location, geometry.Bounds.Size);
swapRect.Inflate(4, 4);
var swapLine = new GeometryGroup();
switch (VSPackage.Options.AdornmentType)
{
case 1:
swapLine = MakeSwapArrow(swapRect);
break;
case 2:
swapLine = MakeSwapBracket(swapRect);
break;
case 3:
swapLine = MakeSwapBadge(swapRect);
break;
}
var drawing = new GeometryDrawing(new SolidColorBrush(swapColor), swapPen, swapLine);
drawing.Freeze();
var drawingImage = new DrawingImage(drawing);
drawingImage.Freeze();
var swapImage = new Image {
Source = drawingImage,
};
if (isRight)
{
Canvas.SetLeft(swapImage, swapRect.Right - drawing.Bounds.Width);
Canvas.SetTop(swapImage, swapRect.Top);
swapImage.RenderTransformOrigin = new Point(0.5, 0.5);
var flipTrans = new ScaleTransform(-1, 1);
swapImage.RenderTransform = flipTrans;
}
else
{
Canvas.SetLeft(swapImage, swapRect.Left);
Canvas.SetTop(swapImage, swapRect.Top);
}
this.layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, snapshotSpan, null, swapImage, null);
}
}
}
}
public InlineRenameSession(
IThreadingContext threadingContext,
InlineRenameService renameService,
Workspace workspace,
SnapshotSpan triggerSpan,
IInlineRenameInfo renameInfo,
SymbolRenameOptions options,
bool previewChanges,
IUIThreadOperationExecutor uiThreadOperationExecutor,
ITextBufferAssociatedViewService textBufferAssociatedViewService,
ITextBufferFactoryService textBufferFactoryService,
IFeatureServiceFactory featureServiceFactory,
IEnumerable <IRefactorNotifyService> refactorNotifyServices,
IAsynchronousOperationListener asyncListener)
{
// This should always be touching a symbol since we verified that upon invocation
_threadingContext = threadingContext;
_renameInfo = renameInfo;
_triggerSpan = triggerSpan;
_triggerDocument = triggerSpan.Snapshot.GetOpenDocumentInCurrentContextWithChanges();
if (_triggerDocument == null)
{
throw new InvalidOperationException(EditorFeaturesResources.The_triggerSpan_is_not_included_in_the_given_workspace);
}
_inlineRenameSessionDurationLogBlock = Logger.LogBlock(FunctionId.Rename_InlineSession, CancellationToken.None);
_workspace = workspace;
_workspace.WorkspaceChanged += OnWorkspaceChanged;
_textBufferFactoryService = textBufferFactoryService;
_textBufferAssociatedViewService = textBufferAssociatedViewService;
_textBufferAssociatedViewService.SubjectBuffersConnected += OnSubjectBuffersConnected;
// Disable completion when an inline rename session starts
_featureService = featureServiceFactory.GlobalFeatureService;
_completionDisabledToken = _featureService.Disable(PredefinedEditorFeatureNames.Completion, this);
RenameService = renameService;
_uiThreadOperationExecutor = uiThreadOperationExecutor;
_refactorNotifyServices = refactorNotifyServices;
_asyncListener = asyncListener;
_triggerView = textBufferAssociatedViewService.GetAssociatedTextViews(triggerSpan.Snapshot.TextBuffer).FirstOrDefault(v => v.HasAggregateFocus) ??
textBufferAssociatedViewService.GetAssociatedTextViews(triggerSpan.Snapshot.TextBuffer).First();
_options = options;
_previewChanges = previewChanges;
_initialRenameText = triggerSpan.GetText();
this.ReplacementText = _initialRenameText;
_baseSolution = _triggerDocument.Project.Solution;
this.UndoManager = workspace.Services.GetService <IInlineRenameUndoManager>();
if (_renameInfo is IInlineRenameInfoWithFileRename renameInfoWithFileRename)
{
FileRenameInfo = renameInfoWithFileRename.GetFileRenameInfo();
}
else
{
FileRenameInfo = InlineRenameFileRenameInfo.NotAllowed;
}
InitializeOpenBuffers(triggerSpan);
}
private String GetDocText(SnapshotSpan span)
{
return(span.Snapshot.GetText());
}
public IEnumerable <SuggestedActionSet> GetSuggestedActions(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken)
{
lock (_currentLock) {
if (_currentSpan == range)
{
return(_current);
}
}
return(null);
}
public async Task <bool> HasSuggestedActionsAsync(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken)
{
var pos = _view.Caret.Position.BufferPosition;
if (pos.Position < pos.GetContainingLine().End.Position)
{
pos += 1;
}
var targetPoint = _view.BufferGraph.MapDownToFirstMatch(pos, PointTrackingMode.Positive, EditorExtensions.IsPythonContent, PositionAffinity.Successor);
if (targetPoint == null)
{
return(false);
}
var textBuffer = targetPoint.Value.Snapshot.TextBuffer;
var lineStart = targetPoint.Value.GetContainingLine().Start;
var span = targetPoint.Value.Snapshot.CreateTrackingSpan(
lineStart,
targetPoint.Value.Position - lineStart.Position,
SpanTrackingMode.EdgePositive,
TrackingFidelityMode.Forward
);
var imports = await _uiThread.InvokeTask(() => VsProjectAnalyzer.GetMissingImportsAsync(_provider, _view, textBuffer.CurrentSnapshot, span));
if (imports == MissingImportAnalysis.Empty)
{
return(false);
}
var suggestions = new List <SuggestedActionSet>();
var availableImports = await imports.GetAvailableImportsAsync(cancellationToken);
suggestions.Add(new SuggestedActionSet(
availableImports.Select(s => new PythonSuggestedImportAction(this, textBuffer, s))
.OrderBy(k => k)
.Distinct()
));
cancellationToken.ThrowIfCancellationRequested();
if (!suggestions.SelectMany(s => s.Actions).Any())
{
return(false);
}
lock (_currentLock) {
cancellationToken.ThrowIfCancellationRequested();
_current = suggestions;
_currentSpan = range;
}
return(true);
}
public static IList <ClassificationSpan> GetClassificationSpans(this IGherkinFileScope gherkinFileScope, SnapshotSpan snapshotSpan)
{
if (gherkinFileScope == null)
{
return(new ClassificationSpan[0]);
}
var result = new List <ClassificationSpan>();
foreach (var gherkinFileBlock in gherkinFileScope.GetAllBlocks())
{
result.AddRange(gherkinFileBlock.ClassificationSpans); //TODO: optimize
}
return(result);
}
public IEnumerable <ITagSpan <AsmTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
DateTime time1 = DateTime.Now;
if (spans.Count == 0)
{ //there is no content in the buffer
yield break;
}
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
string line = containingLine.GetText().ToUpper();
var pos = new List <(int BeginPos, int Length, bool IsLabel)>(AsmSourceTools.SplitIntoKeywordPos(line));
int offset = containingLine.Start.Position;
int nKeywords = pos.Count;
for (int k = 0; k < nKeywords; k++)
{
string asmToken = NasmIntelTokenTagger.Keyword(pos[k], line);
// keyword starts with a remark char
if (AsmSourceTools.IsRemarkChar(asmToken[0]))
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._remark));
continue;
}
// keyword k is a label definition
if (pos[k].IsLabel)
{
SnapshotSpan labelDefSpan = NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan);
//AsmDudeToolsStatic.Output_INFO("MasmTokenTagger:GetTags: found label " + asmToken +" at line "+containingLine.LineNumber);
if (asmToken.Equals("@@"))
{
// TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc.
}
else
{
var v = Make_AsmTokenTag_LabelDef(containingLine.LineNumber);
yield return(new TagSpan <AsmTokenTag>(labelDefSpan, v));
}
continue;
}
AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Intel(asmToken);
switch (keywordType)
{
case AsmTokenType.Jump:
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._jump));
k++; // goto the next word
if (k == nKeywords)
{
break;
}
string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line);
switch (asmToken2)
{
case "$":
case "@B":
case "@F":
{
// TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc.
break;
}
case "WORD":
case "DWORD":
case "QWORD":
case "SHORT":
case "NEAR":
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc));
k++;
if (k == nKeywords)
{
break;
}
string asmToken3 = NasmIntelTokenTagger.Keyword(pos[k], line);
switch (asmToken3)
{
case "$":
case "@B":
case "@F":
{
// TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc.
break;
}
case "PTR":
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc));
break;
}
default:
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber)));
break;
}
}
break;
}
default:
{
if (RegisterTools.IsRegister(asmToken2))
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._register));
}
else
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber)));
}
break;
}
}
break;
}
case AsmTokenType.UNKNOWN: // asmToken is not a known keyword, check if it is numerical
{
//if (AsmTools.AsmSourceTools.Evaluate_Constant(asmToken, true).Valid)
if (AsmTools.AsmSourceTools.Parse_Constant(asmToken, true).Valid)
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant));
}
else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\""))
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant));
}
else
{
bool isUnknown = true;
// do one word lookahead; see whether we can understand the current unknown word
if ((k + 1) < nKeywords)
{
k++;
string nextKeyword = NasmIntelTokenTagger.Keyword(pos[k], line);
switch (nextKeyword)
{
case "PROC":
case "EQU":
case "LABEL":
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef));
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive));
isUnknown = false;
break;
}
case "PROTO":
{ // a proto is considered a label definition but it should not clash with other label definitions
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef_PROTO));
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive));
isUnknown = false;
break;
}
default:
{
k--;
break;
}
}
}
// do one word look back; see whether we can understand the current unknown word
if (k > 0)
{
string previousKeyword = NasmIntelTokenTagger.Keyword(pos[k - 1], line);
switch (previousKeyword)
{
case "ALIAS":
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef));
isUnknown = false;
break;
}
case "INCLUDE":
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant));
isUnknown = false;
break;
}
default:
{
break;
}
}
}
if (isUnknown)
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN));
}
}
break;
}
case AsmTokenType.Directive:
{
AssemblerEnum assember = this._asmDudeTools.Get_Assembler(asmToken);
if (assember.HasFlag(AssemblerEnum.MASM)) // this MASM token-tagger only tags MASM directives
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive));
switch (asmToken)
{
case "INVOKE":
{
k++; // goto the next word
if (k == nKeywords)
{
break;
}
string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line);
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), Make_AsmTokenTag_Label(containingLine.LineNumber)));
break;
}
case "EXTRN":
case "EXTERN":
{
k++; // goto the next word
if (k == nKeywords)
{
break;
}
string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line);
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef_PROTO));
break;
}
}
}
}
break;
default:
{
yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType)));
break;
}
}
}
}
AsmDudeToolsStatic.Print_Speed_Warning(time1, "MasmTokenTagger");
}
internal bool TryGetSpanOnHigherBuffer(SnapshotSpan snapshotSpan, ITextBuffer targetBuffer, out SnapshotSpan span)
{
var spanCollection = TextView.BufferGraph.MapUpToBuffer(snapshotSpan, SpanTrackingMode.EdgeExclusive, targetBuffer);
// Bail if a snippet span does not map up to exactly one span.
if (spanCollection.Count == 1)
{
span = spanCollection.Single();
return(true);
}
span = default(SnapshotSpan);
return(false);
}
private IEnumerable <ITagSpan <TTag> > GetTagsForLargeNumberOfSpans(NormalizedSnapshotSpanCollection requestedSpans)
{
// we are asked with bunch of spans. rather than asking same question again and again, ask once with big span
// which will return superset of what we want. and then filter them out in O(m+n) cost.
// m == number of requested spans, n = number of returned spans
var mergedSpan = new SnapshotSpan(requestedSpans[0].Start, requestedSpans[requestedSpans.Count - 1].End);
var result = GetIntersectingSpans(mergedSpan);
int requestIndex = 0;
var enumerator = result.GetEnumerator();
try
{
if (!enumerator.MoveNext())
{
return(SpecializedCollections.EmptyEnumerable <ITagSpan <TTag> >());
}
var hashSet = new HashSet <ITagSpan <TTag> >();
while (true)
{
var currentTag = enumerator.Current;
var currentRequestSpan = requestedSpans[requestIndex];
var currentTagSpan = currentTag.Span;
if (currentRequestSpan.Start > currentTagSpan.End)
{
if (!enumerator.MoveNext())
{
break;
}
}
else if (currentTagSpan.Start > currentRequestSpan.End)
{
requestIndex++;
if (requestIndex >= requestedSpans.Count)
{
break;
}
}
else
{
if (currentTagSpan.Length > 0)
{
hashSet.Add(currentTag);
}
if (!enumerator.MoveNext())
{
break;
}
}
}
return(hashSet);
}
finally
{
enumerator.Dispose();
}
}
private static bool TryMapToSingleSnapshotSpan(IMappingSpan mappingSpan, ITextSnapshot viewSnapshot, out SnapshotSpan span)
{
// IMappingSpan.GetSpans is a surprisingly expensive function that allocates multiple
// lists and collection if the view buffer is same as anchor we could just map the
// anchor to the viewSnapshot however, since the _anchor is not available, we have to
// map start and end TODO: verify that affinity is correct. If it does not matter we
// should use the cheapest.
if (viewSnapshot != null && mappingSpan.AnchorBuffer == viewSnapshot.TextBuffer)
{
var mappedStart = mappingSpan.Start.GetPoint(viewSnapshot, PositionAffinity.Predecessor).Value;
var mappedEnd = mappingSpan.End.GetPoint(viewSnapshot, PositionAffinity.Successor).Value;
span = new SnapshotSpan(mappedStart, mappedEnd);
return(true);
}
// TODO: actually adornments do not make much sense on "cropped" spans either - Consider line separator on "nd Su"
// is it possible to cheaply detect cropping?
var spans = mappingSpan.GetSpans(viewSnapshot);
if (spans.Count != 1)
{
span = default;
return(false); // span is unmapped or disjoint.
}
span = spans[0];
return(true);
}
protected virtual SnapshotSpan AdjustSnapshotSpan(SnapshotSpan span, int minimumLength) => AdjustSnapshotSpan(span, minimumLength, int.MaxValue);
private void AddClassifiedSpansForPreviousTree <TClassificationService>(
IClassificationDelegationService <TClassificationService> delegationService,
TClassificationService classificationService,
SnapshotSpan span,
ITextSnapshot lastSnapshot,
Document lastDocument,
List <ClassifiedSpan> classifiedSpans)
{
// Slightly more complicated case. They're asking for the classifications for a
// different snapshot than what we have a parse tree for. So we first translate the span
// that they're asking for so that is maps onto the tree that we have spans for. We then
// get the classifications from that tree. We then take the results and translate them
// back to the snapshot they want. Finally, as some of the classifications may have
// changed, we check for some common cases and touch them up manually so that things
// look right for the user.
// Note the handling of SpanTrackingModes here: We do EdgeExclusive while mapping back ,
// and EdgeInclusive mapping forward. What I've convinced myself is that EdgeExclusive
// is best when mapping back over a deletion, so that we don't end up classifying all of
// the deleted code. In most addition/modification cases, there will be overlap with
// existing spans, and so we'll end up classifying well. In the worst case, there is a
// large addition that doesn't exist when we map back, and so we don't have any
// classifications for it. That's probably okay, because:
// 1. If it's that large, it's likely that in reality there are multiple classification
// spans within it.
// 2.We'll eventually call ClassificationsChanged and re-classify that region anyway.
// When mapping back forward, we use EdgeInclusive so that in the common typing cases we
// don't end up with half a token colored differently than the other half.
// See bugs like http://vstfdevdiv:8080/web/wi.aspx?id=6176 for an example of what can
// happen when this goes wrong.
// 1) translate the requested span onto the right span for the snapshot that corresponds
// to the syntax tree.
var translatedSpan = span.TranslateTo(lastSnapshot, SpanTrackingMode.EdgeExclusive);
if (translatedSpan.IsEmpty)
{
// well, there is no information we can get from previous tree, use lexer to
// classify given span. soon we will re-classify the region.
AddClassifiedSpansForTokens(delegationService, classificationService, span, classifiedSpans);
return;
}
var tempList = ClassificationUtilities.GetOrCreateClassifiedSpanList();
AddClassifiedSpansForCurrentTree(
delegationService, classificationService, translatedSpan, lastDocument, tempList);
var currentSnapshot = span.Snapshot;
var currentText = currentSnapshot.AsText();
foreach (var lastClassifiedSpan in tempList)
{
// 2) Translate those classifications forward so that they correspond to the true
// requested snapshot.
var lastSnapshotSpan = lastClassifiedSpan.TextSpan.ToSnapshotSpan(lastSnapshot);
var currentSnapshotSpan = lastSnapshotSpan.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeInclusive);
var currentClassifiedSpan = new ClassifiedSpan(lastClassifiedSpan.ClassificationType, currentSnapshotSpan.Span.ToTextSpan());
// 3) The classifications may be incorrect due to changes in the text. For example,
// if "clss" becomes "class", then we want to changes the classification from
// 'identifier' to 'keyword'.
currentClassifiedSpan = delegationService.AdjustStaleClassification(
classificationService, currentText, currentClassifiedSpan);
classifiedSpans.Add(currentClassifiedSpan);
}
ClassificationUtilities.ReturnClassifiedSpanList(tempList);
}
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));
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
var snapshot = span.Snapshot;
var workspace = snapshot.TextBuffer.GetWorkspace();
if (workspace == null)
{
return(Array.Empty <ClassificationSpan>());
}
var result = new List <ClassificationSpan>(16);
var semanticModel = ThreadHelper.JoinableTaskFactory.Run(() => workspace.GetDocument(span).GetSemanticModelAsync());
var textSpan = new TextSpan(span.Start.Position, span.Length);
var unitCompilation = semanticModel.SyntaxTree.GetCompilationUnitRoot();
var classifiedSpans = Classifier.GetClassifiedSpans(semanticModel, textSpan, workspace);
var lastTriviaSpan = default(TextSpan);
GetAttributeNotationSpan(snapshot, result, textSpan, unitCompilation);
foreach (var item in classifiedSpans)
{
var ct = item.ClassificationType;
switch (ct)
{
case "keyword": {
var node = unitCompilation.FindNode(item.TextSpan, true, true);
if (node is MemberDeclarationSyntax)
{
var token = unitCompilation.FindToken(item.TextSpan.Start);
if (token != null)
{
switch (token.Kind())
{
case SyntaxKind.SealedKeyword:
case SyntaxKind.OverrideKeyword:
case SyntaxKind.AbstractKeyword:
case SyntaxKind.VirtualKeyword:
case SyntaxKind.NewKeyword:
result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _Classifications.AbstractionKeyword));
continue;
}
}
continue;
}
const SyntaxKind ThrowExpression = (SyntaxKind)9052;
switch (node.Kind())
{
case SyntaxKind.BreakStatement:
if (node.Parent is SwitchSectionSyntax == false)
{
goto case SyntaxKind.ReturnStatement;
}
continue;
// highlights: return, yield return, yield break, throw and continue
case SyntaxKind.ReturnKeyword:
case SyntaxKind.GotoCaseStatement:
case SyntaxKind.GotoDefaultStatement:
case SyntaxKind.GotoStatement:
case SyntaxKind.ContinueStatement:
case SyntaxKind.ReturnStatement:
case SyntaxKind.YieldReturnStatement:
case SyntaxKind.YieldBreakStatement:
case SyntaxKind.ThrowStatement:
case ThrowExpression:
result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _GeneralClassifications.ControlFlowKeyword));
continue;
case SyntaxKind.IfStatement:
case SyntaxKind.ElseClause:
case SyntaxKind.SwitchStatement:
case SyntaxKind.CaseSwitchLabel:
case SyntaxKind.DefaultSwitchLabel:
result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _GeneralClassifications.BranchingKeyword));
continue;
case SyntaxKind.ForStatement:
case SyntaxKind.ForEachStatement:
case SyntaxKind.WhileStatement:
case SyntaxKind.DoStatement:
case SyntaxKind.SelectClause:
result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _GeneralClassifications.LoopKeyword));
continue;
case SyntaxKind.UsingStatement:
case SyntaxKind.FixedStatement:
case SyntaxKind.LockStatement:
case SyntaxKind.UnsafeStatement:
case SyntaxKind.TryStatement:
case SyntaxKind.CatchClause:
case SyntaxKind.CatchFilterClause:
case SyntaxKind.FinallyClause:
result.Add(CreateClassificationSpan(snapshot, item.TextSpan, _Classifications.ResourceKeyword));
continue;
}
}
continue;
case Constants.CodePunctuation:
if (item.TextSpan.Length == 1)
{
ClassifyPunctuation(item.TextSpan, snapshot, result, semanticModel, unitCompilation);
}
continue;
default:
if (ct == Constants.XmlDocDelimiter)
{
if (lastTriviaSpan.Contains(item.TextSpan))
{
continue;
}
var node = unitCompilation.FindTrivia(item.TextSpan.Start);
if (node != null)
{
switch (node.Kind())
{
case SyntaxKind.SingleLineDocumentationCommentTrivia:
case SyntaxKind.MultiLineDocumentationCommentTrivia:
case SyntaxKind.DocumentationCommentExteriorTrivia:
lastTriviaSpan = node.FullSpan;
result.Add(CreateClassificationSpan(snapshot, lastTriviaSpan, _Classifications.XmlDoc));
continue;
}
}
}
else if (ct == Constants.CodeIdentifier ||
ct.EndsWith("name", StringComparison.Ordinal))
{
var itemSpan = item.TextSpan;
var node = unitCompilation.FindNode(itemSpan, true);
foreach (var type in GetClassificationType(node, semanticModel))
{
result.Add(CreateClassificationSpan(snapshot, itemSpan, type));
}
}
break;
}
}
return(result);
}
public IEnumerable <TrackingTokenInfo> GetTokens(SnapshotSpan span)
{
return(GetTrackingTokens(span));
}
/// <summary>
/// Convert the SnapshotSpan into an EditSpan
/// </summary>
public static EditSpan ToEditSpan(this SnapshotSpan span)
{
return(EditSpan.NewSingle(span));
}
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> quickInfoContent, out ITrackingSpan applicableToSpan)
{
applicableToSpan = null;
if (session == null || quickInfoContent == null)
{
return;
}
if (session.TextView.TextBuffer == this.TextBuffer)
{
ITextSnapshot currentSnapshot = this.TextBuffer.CurrentSnapshot;
SnapshotPoint?triggerPoint = session.GetTriggerPoint(currentSnapshot);
if (!triggerPoint.HasValue)
{
return;
}
#region experimental
/* use the experimental model to locate and process the expression */
Stopwatch stopwatch = Stopwatch.StartNew();
// lex the entire document
var input = new SnapshotCharStream(currentSnapshot, new Span(0, currentSnapshot.Length));
var lexer = new GoLexer(input);
var tokenSource = new GoSemicolonInsertionTokenSource(lexer);
var tokens = new CommonTokenStream(tokenSource);
tokens.Fill();
// locate the last token before the trigger point
while (true)
{
IToken nextToken = tokens.LT(1);
if (nextToken.Type == CharStreamConstants.EndOfFile)
{
break;
}
if (nextToken.StartIndex > triggerPoint.Value.Position)
{
break;
}
tokens.Consume();
}
switch (tokens.LA(-1))
{
case GoLexer.IDENTIFIER:
//case GoLexer.KW_THIS:
//case GoLexer.KW_UNIV:
//case GoLexer.KW_IDEN:
//case GoLexer.KW_INT2:
//case GoLexer.KW_SEQINT:
break;
default:
return;
}
Network network = NetworkBuilder <GoSimplifiedAtnBuilder> .GetOrBuildNetwork();
RuleBinding memberSelectRule = network.GetRule(GoSimplifiedAtnBuilder.RuleNames.PrimaryExpr);
#if false
HashSet <Transition> memberSelectTransitions = new HashSet <Transition>();
GetReachableTransitions(memberSelectRule, memberSelectTransitions);
#endif
NetworkInterpreter interpreter = new NetworkInterpreter(network, tokens);
interpreter.BoundaryRules.Add(memberSelectRule);
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.Label));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.TypeSwitchGuard));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.FieldName));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.Receiver));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.FunctionDecl));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.BaseTypeName));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.TypeSpec));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.IdentifierList));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.MethodName));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.ParameterDecl));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.FieldIdentifierList));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.PackageName));
interpreter.BoundaryRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.TypeName));
interpreter.ExcludedStartRules.Add(network.GetRule(GoSimplifiedAtnBuilder.RuleNames.Block));
while (interpreter.TryStepBackward())
{
if (interpreter.Contexts.Count == 0)
{
break;
}
/* we want all traces to start outside the binOpExpr18 rule, which means all
* traces with a transition reachable from binOpExpr18 should contain a push
* transition with binOpExpr18's start state as its target.
*/
if (interpreter.Contexts.All(context => context.BoundedStart))
{
break;
}
}
interpreter.CombineBoundedStartContexts();
IOutputWindowPane pane = Provider.OutputWindowService.TryGetPane(PredefinedOutputWindowPanes.TvlIntellisense);
if (pane != null)
{
pane.WriteLine(string.Format("Located {0} QuickInfo expression(s) in {1}ms.", interpreter.Contexts.Count, stopwatch.ElapsedMilliseconds));
}
HashSet <string> finalResult = new HashSet <string>();
SnapshotSpan? contextSpan = null;
foreach (var context in interpreter.Contexts)
{
Span?span = null;
//List<string> results = AnalyzeInterpreterTrace(context, memberSelectRule, out span);
foreach (var transition in context.Transitions)
{
if (!transition.Transition.IsMatch)
{
continue;
}
IToken token = transition.Token;
Span tokenSpan = new Span(token.StartIndex, token.StopIndex - token.StartIndex + 1);
if (span == null)
{
span = tokenSpan;
}
else
{
span = Span.FromBounds(Math.Min(span.Value.Start, tokenSpan.Start), Math.Max(span.Value.End, tokenSpan.End));
}
}
if (span.HasValue && !span.Value.IsEmpty)
{
contextSpan = new SnapshotSpan(currentSnapshot, span.Value);
}
//if (results.Count > 0)
//{
// finalResult.UnionWith(results);
// applicableToSpan = currentSnapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive);
//}
}
foreach (var result in finalResult)
{
quickInfoContent.Add(result);
}
#endregion
#if false
var selection = session.TextView.Selection.StreamSelectionSpan;
if (selection.IsEmpty || !selection.Contains(new VirtualSnapshotPoint(triggerPoint.Value)))
{
SnapshotSpan?expressionSpan = Provider.IntellisenseCache.GetExpressionSpan(triggerPoint.Value);
if (expressionSpan.HasValue)
{
selection = new VirtualSnapshotSpan(expressionSpan.Value);
}
}
#endif
VirtualSnapshotSpan selection = new VirtualSnapshotSpan();
if (contextSpan.HasValue)
{
selection = new VirtualSnapshotSpan(contextSpan.Value);
}
if (!selection.IsEmpty && selection.Contains(new VirtualSnapshotPoint(triggerPoint.Value)))
{
applicableToSpan = selection.Snapshot.CreateTrackingSpan(selection.SnapshotSpan, SpanTrackingMode.EdgeExclusive);
quickInfoContent.Add(selection.GetText());
//try
//{
// Expression currentExpression = Provider.IntellisenseCache.ParseExpression(selection);
// if (currentExpression != null)
// {
// SnapshotSpan? span = currentExpression.Span;
// if (span.HasValue)
// applicableToSpan = span.Value.Snapshot.CreateTrackingSpan(span.Value, SpanTrackingMode.EdgeExclusive);
// quickInfoContent.Add(currentExpression.ToString());
// }
// else
// {
// quickInfoContent.Add("Could not parse expression.");
// }
//}
//catch (Exception ex)
//{
// if (ErrorHandler.IsCriticalException(ex))
// throw;
// quickInfoContent.Add(ex.Message);
//}
}
}
}
public static SnapshotSpan?MapUpOrDownToBuffer(this IBufferGraph bufferGraph, SnapshotSpan span, ITextBuffer targetBuffer)
{
var direction = ClassifyBufferMapDirection(span.Snapshot.TextBuffer, targetBuffer);
switch (direction)
{
case BufferMapDirection.Identity:
return(span);
case BufferMapDirection.Down:
{
var spans = bufferGraph.MapDownToBuffer(span, SpanTrackingMode.EdgeExclusive, targetBuffer);
return(spans.Select(s => (SnapshotSpan?)s).FirstOrDefault());
}
case BufferMapDirection.Up:
{
var spans = bufferGraph.MapUpToBuffer(span, SpanTrackingMode.EdgeExclusive, targetBuffer);
return(spans.Select(s => (SnapshotSpan?)s).FirstOrDefault());
}
default:
return(null);
}
}
// Produces tags on the snapshot that this tagger is current with.
private IEnumerable <TagSpan <IntraTextAdornmentTag> > GetAdornmentTagsOnSnapshot(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
ITextSnapshot snapshot = spans[0].Snapshot;
if (snapshot != this._snapshot)
{
yield break;
}
// Since WPF UI objects have state (like mouse hover or animation) and are relatively expensive to create and lay out,
// this code tries to reuse controls as much as possible.
// The controls are stored in this.adornmentCache between the calls.
// Mark which adornments fall inside the requested spans with Keep=false
// so that they can be removed from the cache if they no longer correspond to data tags.
HashSet <SnapshotSpan> toRemove = new HashSet <SnapshotSpan>();
foreach (var ar in _adornmentCache)
{
if (spans.IntersectsWith(new NormalizedSnapshotSpanCollection(ar.Key)))
{
toRemove.Add(ar.Key);
}
}
foreach (var spanDataPair in GetAdornmentData(spans).Distinct(new Comparer()))
{
// Look up the corresponding adornment or create one if it's new.
TAdornment adornment;
SnapshotSpan snapshotSpan = spanDataPair.Item1;
PositionAffinity?affinity = spanDataPair.Item2;
TData adornmentData = spanDataPair.Item3;
SnapshotSpan containSpan = spanDataPair.Item4;
if (_adornmentCache.TryGetValue(snapshotSpan, out adornment))
{
if (UpdateAdornment(adornment, adornmentData, snapshotSpan, containSpan))
{
toRemove.Remove(snapshotSpan);
}
}
else
{
adornment = CreateAdornment(adornmentData, snapshotSpan, containSpan);
if (adornment == null)
{
continue;
}
// Get the adornment to measure itself. Its DesiredSize property is used to determine
// how much space to leave between text for this adornment.
// Note: If the size of the adornment changes, the line will be reformatted to accommodate it.
// Note: Some adornments may change size when added to the view's visual tree due to inherited
// dependency properties that affect layout. Such options can include SnapsToDevicePixels,
// UseLayoutRounding, TextRenderingMode, TextHintingMode, and TextFormattingMode. Making sure
// that these properties on the adornment match the view's values before calling Measure here
// can help avoid the size change and the resulting unnecessary re-format.
adornment.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
_adornmentCache.Add(snapshotSpan, adornment);
}
yield return(new TagSpan <IntraTextAdornmentTag>(snapshotSpan, new IntraTextAdornmentTag(adornment, null, affinity)));
}
foreach (var snapshotSpan in toRemove)
{
_adornmentCache.Remove(snapshotSpan);
}
}
public static SnapshotSpan?MapUpOrDownToFirstMatch(this IBufferGraph bufferGraph, SnapshotSpan span, Predicate <ITextSnapshot> match)
{
var spans = bufferGraph.MapDownToFirstMatch(span, SpanTrackingMode.EdgeExclusive, match);
if (!spans.Any())
{
spans = bufferGraph.MapUpToFirstMatch(span, SpanTrackingMode.EdgeExclusive, match);
}
return(spans.Select(s => (SnapshotSpan?)s).FirstOrDefault());
}
/// <param name="span">这个装饰将会消失的文本范围.</param> /// <returns>Adornment corresponding to given data. May be null.</returns> protected abstract TAdornment CreateAdornment(TData data, SnapshotSpan span, SnapshotSpan containSpan);
private TagSpan <TextMarkerTag> Mark(IMappingTagSpan <LexTag> tagSpan, SnapshotSpan snapshotSpan)
{
var tagSpans = tagSpan.Span.GetSpans(snapshotSpan.Snapshot);
return(new TagSpan <TextMarkerTag>(tagSpans[0], new TextMarkerTag("blue")));
}
/// <summary>
/// Causes intra-text adornments to be updated synchronously.
/// </summary>
protected void RaiseTagsChanged(SnapshotSpan span)
{
TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(span));
}
