private void OnTagsChanged(SnapshotSpanEventArgs e)
{
Contract.Requires(e != null);
var t = TagsChanged;
if (t != null)
{
t(this, e);
}
}
protected virtual void OnTagsChanged([NotNull] SnapshotSpanEventArgs e)
{
Requires.NotNull(e, nameof(e));
var t = TagsChanged;
if (t != null)
{
t(this, e);
}
}
protected virtual void OnTagsChanged(SnapshotSpanEventArgs e)
{
Contract.Requires <ArgumentNullException>(e != null, "e");
var t = TagsChanged;
if (t != null)
{
t(this, e);
}
}
private void OnTagsChanged(SnapshotSpanEventArgs e)
{
Debug.Assert(e != null);
var t = TagsChanged;
if (t != null)
{
t(this, e);
}
}
/// <summary>
/// When a source tagger sends out a change event, we translate the SnapshotSpan
/// that was changed into a mapping span for our consumers.
/// </summary>
void SourceTaggerTagsChanged(object sender, SnapshotSpanEventArgs e)
{
if (this.disposed)
{
return;
}
// Create a mapping span for the region and return that in our own event
IMappingSpan span = this.BufferGraph.CreateMappingSpan(e.Span, SpanTrackingMode.EdgeExclusive);
RaiseEvents(sender, span);
}
private void OnDebuggerCurrentStatementChanged(object sender, EventArgs eventArgs)
{
var handler = TagsChanged;
if (handler != null)
{
var snapshot = textBuffer.CurrentSnapshot;
var snapshotSpan = new SnapshotSpan(snapshot, 0, snapshot.Length);
var args = new SnapshotSpanEventArgs(snapshotSpan);
handler(this, args);
}
}
public void RaiseEvent(BaseBuffer baseBuffer, bool immediate)
{
// there is no immediate form of this event since it does not create a snapshot
Debug.Assert(!immediate);
EventHandler <SnapshotSpanEventArgs> handler = baseBuffer.ReadOnlyRegionsChanged;
if (handler != null)
{
var args = new SnapshotSpanEventArgs(affectedSpan);
baseBuffer.guardedOperations.RaiseEvent(baseBuffer, handler, args);
}
}
public virtual void ForceRetagLines(int startLine, int endLine)
{
_firstDirtyLine = _firstDirtyLine.HasValue ? Math.Min(_firstDirtyLine.Value, startLine) : startLine;
_lastDirtyLine = _lastDirtyLine.HasValue ? Math.Max(_lastDirtyLine.Value, endLine) : endLine;
ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
int start = snapshot.GetLineFromLineNumber(startLine).Start;
int end = snapshot.GetLineFromLineNumber(endLine).EndIncludingLineBreak;
var e = new SnapshotSpanEventArgs(new SnapshotSpan(_textBuffer.CurrentSnapshot, Span.FromBounds(start, end)));
OnTagsChanged(e);
}
protected virtual void ForceRetagLines(TaggerState taggerState, int startLine, int endLine)
{
taggerState._firstDirtyLine = Math.Min(taggerState._firstDirtyLine ?? startLine, startLine);
taggerState._lastDirtyLine = Math.Max(taggerState._lastDirtyLine ?? endLine, endLine);
ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
int start = snapshot.GetLineFromLineNumber(startLine).Start;
int end = snapshot.GetLineFromLineNumber(endLine).EndIncludingLineBreak;
var e = new SnapshotSpanEventArgs(new SnapshotSpan(_textBuffer.CurrentSnapshot, Span.FromBounds(start, end)));
OnTagsChanged(e);
}
protected override void OnParseResultChanged(object sender, SnapshotSpanEventArgs e)
{
var syntaxTreeAndSnapshot = ParserService.SyntaxTreeAndSnapshot;
if (syntaxTreeAndSnapshot == null)
{
return;
}
UpdateOutliningRegionTags(syntaxTreeAndSnapshot);
TagsChanged?.Invoke(this, e);
}
private void UpdateAtCaretPosition(CaretPosition caretPosition)
{
this.currentChar = caretPosition.Point.GetPoint(this.sourceBuffer, caretPosition.Affinity);
if (this.currentChar != null)
{
if (this.TagsChanged != null)
{
var curSs = this.sourceBuffer.CurrentSnapshot;
var args = new SnapshotSpanEventArgs(new SnapshotSpan(curSs, 0, curSs.Length));
this.TagsChanged(this, args);
}
}
}
/// <summary>
/// Task to reparse the whole text and fires a TagsChanged event.
/// </summary>
/// <param name="snapshot">
/// The snapshot.
/// </param>
private void Parse(ITextSnapshot snapshot)
{
Parse();
var startPoint = new SnapshotPoint(snapshot, 0);
var endPoint = new SnapshotPoint(snapshot, snapshot.Length);
var expandedSpan = new SnapshotSpan(startPoint, endPoint);
var args = new SnapshotSpanEventArgs(expandedSpan);
if (TagsChanged != null)
{
TagsChanged(this, args);
}
}
void Storage_TagsChanged(Object sender, SnapshotSpanEventArgs e)
{
if (m_bufferIsModified)
{
return;
}
var handler = TagsChanged;
if (handler != null)
{
handler(this, e);
}
}
private void OnUnderlyingTaggerTagsChanged(object sender, SnapshotSpanEventArgs args)
{
this.AssertIsForeground();
if (_disposed)
{
return;
}
var tagsChanged = this.TagsChanged;
if (tagsChanged != null)
{
tagsChanged(sender, args);
}
}
internal virtual void OnSourceBufferReadOnlyRegionsChanged(object sender, SnapshotSpanEventArgs e)
{
NormalizedSpanCollection mappedAffectedSpans = new NormalizedSpanCollection(this.CurrentBaseSnapshot.MapFromSourceSnapshot(e.Span));
if (mappedAffectedSpans.Count > 0)
{
ITextEventRaiser raiser =
new ReadOnlyRegionsChangedEventRaiser(new SnapshotSpan(this.currentSnapshot,
Span.FromBounds(mappedAffectedSpans[0].Start,
mappedAffectedSpans[mappedAffectedSpans.Count - 1].End)));
this.group.BeginEdit();
this.group.EnqueueEvents(raiser, this);
this.group.FinishEdit();
}
}
public void OnSelectionChanged_ChangeLevelIsNotLocation_EditorIsNotified(SelectionChangeLevel changeLevel)
{
var selectionServiceMock = new Mock <IAnalysisIssueSelectionService>();
var testSubject = new SelectedIssueLocationTagger(ValidAggregator, ValidBuffer, selectionServiceMock.Object);
var tagsChangedEventCount = 0;
SnapshotSpanEventArgs actualEventArgs = null;
testSubject.TagsChanged += (sender, args) => { tagsChangedEventCount++; actualEventArgs = args; };
// Act
selectionServiceMock.Raise(x => x.SelectionChanged += null, new SelectionChangedEventArgs(changeLevel, null, null, null));
tagsChangedEventCount.Should().Be(1);
actualEventArgs.Should().NotBeNull();
actualEventArgs.Span.Start.Position.Should().Be(0);
actualEventArgs.Span.End.Position.Should().Be(ValidBuffer.CurrentSnapshot.Length);
actualEventArgs.Span.Snapshot.Should().Be(ValidBuffer.CurrentSnapshot);
}
public void OnAggregatorTagsChanged_NotifiesEditorOfChange()
{
var aggregatorMock = new Mock <ITagAggregator <TrackedTag> >();
var testSubject = new TestableFilteringTagger(aggregatorMock.Object, ValidBuffer);
SnapshotSpanEventArgs suppliedArgs = null;
int eventCount = 0;
SnapshotSpan expectedSnapshotSpan = new SnapshotSpan(ValidBuffer.CurrentSnapshot, new Span(0, ValidBuffer.CurrentSnapshot.Length));
testSubject.TagsChanged += (sender, args) => { eventCount++; suppliedArgs = args; };
// Act
aggregatorMock.Raise(x => x.BatchedTagsChanged += null, new BatchedTagsChangedEventArgs(Array.Empty <IMappingSpan>()));
eventCount.Should().Be(1);
suppliedArgs.Should().NotBeNull();
suppliedArgs.Span.Should().Be(expectedSnapshotSpan);
}
public void AddAdornment(UIElement uiElement, SnapshotPoint targetLoc)
{
if (Dispatcher.CurrentDispatcher != _dispatcher)
{
_dispatcher.BeginInvoke(new Action(() => AddAdornment(uiElement, targetLoc)));
return;
}
var targetLine = targetLoc.GetContainingLine();
_tags.Add(new Tuple <SnapshotPoint, UIElement>(targetLoc, uiElement));
var handler = TagsChanged;
if (handler != null)
{
var span = new SnapshotSpan(_textView.TextSnapshot, targetLine.Start, targetLine.LengthIncludingLineBreak);
var args = new SnapshotSpanEventArgs(span);
handler(this, args);
}
}
private void CheckIfTagsChanged(SnapshotRegions oldSnapshotRegions, SnapshotRegions newSnapshotRegions)
{
ITextSnapshot oldSnapshot = oldSnapshotRegions.Snapshot;
IReadOnlyList <Region> oldRegions = oldSnapshotRegions.Regions;
ITextSnapshot newSnapshot = newSnapshotRegions.Snapshot;
IReadOnlyList <Region> newRegions = newSnapshotRegions.Regions;
// Determine the changed spans and send a changed event with the new spans.
List <Span> oldSpans = new List <Span>(
oldRegions.Select(r => AsSnapshotSpan(r, oldSnapshot).TranslateTo(newSnapshot, SpanTrackingMode.EdgeExclusive).Span));
List <Span> newSpans = new List <Span>(newRegions.Select(r => AsSnapshotSpan(r, newSnapshot).Span));
NormalizedSpanCollection oldSpanCollection = new NormalizedSpanCollection(oldSpans);
NormalizedSpanCollection newSpanCollection = new NormalizedSpanCollection(newSpans);
// The changed regions are regions that appear in one set or the other, but not both.
NormalizedSpanCollection removed = NormalizedSpanCollection.Difference(oldSpanCollection, newSpanCollection);
int changeStart = int.MaxValue;
int changeEnd = -1;
if (removed.Count > 0)
{
changeStart = removed[0].Start;
changeEnd = removed[removed.Count - 1].End;
}
if (newSpans.Count > 0)
{
changeStart = Math.Min(changeStart, newSpans[0].Start);
changeEnd = Math.Max(changeEnd, newSpans[newSpans.Count - 1].End);
}
if (changeStart <= changeEnd)
{
var handler = this.TagsChanged;
if (handler != null)
{
var args = new SnapshotSpanEventArgs(new SnapshotSpan(newSnapshot, Span.FromBounds(changeStart, changeEnd)));
handler(this, args);
}
}
}
public void AddAdornment(ZoomableInlineAdornment uiElement)
{
if (Dispatcher.CurrentDispatcher != _dispatcher)
{
_dispatcher.BeginInvoke(new Action(() => AddAdornment(uiElement)));
return;
}
var caretPos = _textView.Caret.Position.BufferPosition;
var caretLine = caretPos.GetContainingLine();
_tags.Add(new Tuple <int, ZoomableInlineAdornment>(caretPos.Position, uiElement));
var handler = TagsChanged;
if (handler != null)
{
var span = new SnapshotSpan(_textView.TextSnapshot, caretLine.Start, caretLine.Length);
var args = new SnapshotSpanEventArgs(span);
handler(this, args);
}
}
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 void OnColorizingTaggerTagsChanged(object sender, SnapshotSpanEventArgs e)
{
RaiseTagsChanged();
}
/// <summary>
/// When we get a TagsChnaged event we need to queue up an external edit check to examine the
/// changes
/// </summary>
private void OnTagsChanged(object sender, SnapshotSpanEventArgs e)
{
QueueCheck(CheckKind.Tags);
}
//=====================================================================
/// <summary>
/// Update the current state when notified that the spelling tags have changed
/// </summary>
/// <param name="sender">The sender of the event</param>
/// <param name="e">The event arguments</param>
private void tagger_TagsChanged(object sender, SnapshotSpanEventArgs e)
{
this.UpdateState();
}
protected override void OnSemanticModelChanged(object sender, SnapshotSpanEventArgs e) {
ClassificationChanged?.Invoke(this, new ClassificationChangedEventArgs(e.Span));
}
//=====================================================================
/// <summary>
/// Update the list of spelling errors when notified that the spelling tags have changed
/// </summary>
/// <param name="sender">The sender of the event</param>
/// <param name="e">The event arguments</param>
private void tagger_TagsChanged(object sender, SnapshotSpanEventArgs e)
{
misspellings = currentTagger.CurrentMisspellings.ToList();
this.UpdateState();
}
private void OnReadOnlyRegionsChanged(object sender, SnapshotSpanEventArgs e)
{
this.RaiseChanged();
}
protected virtual void OnParseResultChanged(object sender, SnapshotSpanEventArgs e) {
}
protected override void OnSemanticModelChanged(object sender, SnapshotSpanEventArgs e) {
_dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(UpdateNavigationItems));
}
//=====================================================================
/// <summary>
/// Update the list of spelling errors when notified that the spelling tags have changed
/// </summary>
/// <param name="sender">The sender of the event</param>
/// <param name="e">The event arguments</param>
private void tagger_TagsChanged(object sender, SnapshotSpanEventArgs e)
{
misspellings = currentTagger.CurrentMisspellings.ToList();
this.UpdateState();
}
protected override void OnParseResultChanged(object sender, SnapshotSpanEventArgs e) {
ClassificationChanged?.Invoke(this, new ClassificationChangedEventArgs(e.Span));
}
public void RaiseTagsChanged(SnapshotSpanEventArgs snapshotSpanEventArgs)
{
TagsChanged?.Invoke(this, snapshotSpanEventArgs);
}
void Tagger_TagsChanged(object sender, SnapshotSpanEventArgs e) => // Use original sender, not us RaiseTagsChanged(e.Span, sender);
private void OnTagsChanged(SnapshotSpanEventArgs e)
{
TagsChanged?.Invoke(this, e);
}
protected virtual void OnSemanticModelChanged(object sender, SnapshotSpanEventArgs e) {
}
private void OnTokensChanged(SnapshotSpan span)
{
var eventArgs = new SnapshotSpanEventArgs(span);
var handler = TokensChanged;
if (handler != null)
{
handler(this, eventArgs);
}
}
protected void InvokeTagsChanged(object sender, SnapshotSpanEventArgs args)
{
TagsChanged?.Invoke(sender, args);
}
private void OnTagsChanged(object sender, SnapshotSpanEventArgs e)
{
TagsChanged?.Invoke(this, e);
}
private void RaiseTagsChanged(SnapshotSpanEventArgs args)
{
this.TagsChanged?.Invoke(this, args);
}
/// <summary>
/// When we get a TagsChnaged event we need to queue up an external edit check to examine the
/// changes
/// </summary>
private void OnTagsChanged(object sender, SnapshotSpanEventArgs e)
{
QueueCheck(CheckKind.Tags);
}
void textBuffer_ReadOnlyRegionsChanged(object sender, SnapshotSpanEventArgs e)
{
// We need to call this event when read-only regions are added, so they will be grayed out.
OnClassificationChanged(new SnapshotSpan(textBuffer.CurrentSnapshot, e.Span));
}
private void OnTagsChanged(object source, SnapshotSpanEventArgs e)
{
WordsChanged(this, EventArgs.Empty);
}
protected override void OnParseResultChanged(object sender, SnapshotSpanEventArgs e) {
Invalidate();
}
void OnSemanticModelChanged(SnapshotSpanEventArgs e) {
_waitingForAnalysis = false;
SemanticModelChanged?.Invoke(this, e);
}
void OnParseResultChanged(SnapshotSpanEventArgs e) {
_waitingForAnalysis = false;
ParseResultChanged?.Invoke(this, e);
}
