public Tagger(
CopyPasteAndPrintingClassificationBufferTaggerProvider owner,
ITextBuffer subjectBuffer,
IAsynchronousOperationListener asyncListener
) : base(owner.ThreadingContext)
{
_owner = owner;
_subjectBuffer = subjectBuffer;
const TaggerDelay Delay = TaggerDelay.Short;
// Note: because we use frozen-partial documents for semantic classification, we may end up with incomplete
// semantics (esp. during solution load). Because of this, we also register to hear when the full
// compilation is available so that reclassify and bring ourselves up to date.
_eventSource = new CompilationAvailableTaggerEventSource(
subjectBuffer,
Delay,
owner.ThreadingContext,
asyncListener,
TaggerEventSources.OnWorkspaceChanged(subjectBuffer, Delay, asyncListener),
TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer, Delay)
);
ConnectToEventSource();
}
public ViewSpanChangedEventSource(ITextView textView, TaggerDelay textChangeDelay, TaggerDelay scrollChangeDelay)
{
Debug.Assert(textView != null);
_textView = textView;
_textChangeDelay = textChangeDelay;
_scrollChangeDelay = scrollChangeDelay;
}
public EditorFormatMapChangedEventSource(
IEditorFormatMap editorFormatMap,
TaggerDelay delay
) : base(delay)
{
_editorFormatMap = editorFormatMap;
}
internal static int ComputeTimeDelay(this TaggerDelay behavior, ITextBuffer textBufferOpt)
{
if (TextBufferAssociatedViewService.AnyAssociatedViewHasFocus(textBufferOpt))
{
// TODO : should we remove TaggerBehavior enum all together and put NearImmediateDelay
// const in Interaction?
switch (behavior)
{
case TaggerDelay.NearImmediate:
return(NearImmediateDelay);
case TaggerDelay.Short:
return(ShortDelay);
case TaggerDelay.Medium:
return(MediumDelay);
case TaggerDelay.OnIdle:
default:
return(IdleDelay);
}
}
return(NonFocusDelay);
}
private void NotifyEditors(NormalizedSnapshotSpanCollection changes, TaggerDelay delay)
{
_tagSource.AssertIsForeground();
if (changes.Count == 0)
{
// nothing to do.
return;
}
if (delay == TaggerDelay.NearImmediate)
{
// if delay is immediate, we let notifier knows about the change right away
_batchChangeNotifier.EnqueueChanges(changes);
return;
}
// if delay is anything more than that, we let notifier knows about the change after given delay
// event notification is only cancellable when disposing of the tagger.
_tagSource.RegisterNotification(
() => _batchChangeNotifier.EnqueueChanges(changes),
(int)delay.ComputeTimeDelay(_subjectBuffer).TotalMilliseconds,
_cancellationTokenSource.Token
);
}
public static ITaggerEventSource OnDiagnosticsChanged(
ITextBuffer subjectBuffer,
IDiagnosticService service,
TaggerDelay delay)
{
return new DiagnosticsChangedEventSource(subjectBuffer, service, delay);
}
public static ITaggerEventSource OnCompletionClosed(
ITextView textView,
IIntellisenseSessionStack sessionStack,
TaggerDelay delay)
{
return new CompletionClosedEventSource(textView, sessionStack, delay);
}
public static ITaggerEventSource OnDiagnosticsChanged(
ITextBuffer subjectBuffer,
IDiagnosticService service,
TaggerDelay delay)
{
return(new DiagnosticsChangedEventSource(subjectBuffer, service, delay));
}
public static ITaggerEventSource OnOptionChanged(
ITextBuffer subjectBuffer,
IOption option,
TaggerDelay delay)
{
return new OptionChangedEventSource(subjectBuffer, option, delay);
}
public static ITaggerEventSource OnOptionChanged(
ITextBuffer subjectBuffer,
IOption option,
TaggerDelay delay)
{
return(new OptionChangedEventSource(subjectBuffer, option, delay));
}
public static ITaggerEventSource OnParseOptionChanged(
ITextBuffer subjectBuffer,
TaggerDelay delay
)
{
return(new ParseOptionChangedEventSource(subjectBuffer, delay));
}
protected override ITaggerEventSource CreateEventSource(
ITextView textView,
ITextBuffer subjectBuffer
)
{
this.AssertIsForeground();
const TaggerDelay Delay = TaggerDelay.Short;
// Note: we don't listen for OnTextChanged. They'll get reported by the ViewSpan changing and also the
// SemanticChange notification.
//
// Note: when the user scrolls, we will try to reclassify as soon as possible. That way we appear
// semantically unclassified for a very short amount of time.
//
// Note: because we use frozen-partial documents for semantic classification, we may end up with incomplete
// semantics (esp. during solution load). Because of this, we also register to hear when the full
// compilation is available so that reclassify and bring ourselves up to date.
return(new CompilationAvailableTaggerEventSource(
subjectBuffer,
Delay,
ThreadingContext,
AsyncListener,
TaggerEventSources.OnViewSpanChanged(
ThreadingContext,
textView,
textChangeDelay: Delay,
scrollChangeDelay: TaggerDelay.NearImmediate
),
TaggerEventSources.OnWorkspaceChanged(subjectBuffer, Delay, this.AsyncListener),
TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer, Delay)
));
}
public static ITaggerEventSource OnCompletionClosed(
ITextView textView,
IIntellisenseSessionStack sessionStack,
TaggerDelay delay)
{
return(new CompletionClosedEventSource(textView, sessionStack, delay));
}
public ViewSpanChangedEventSource(ITextView textView, TaggerDelay textChangeDelay, TaggerDelay scrollChangeDelay)
{
Debug.Assert(textView != null);
_textView = textView;
_textChangeDelay = textChangeDelay;
_scrollChangeDelay = scrollChangeDelay;
}
public TextChangedEventSource(ITextBuffer subjectBuffer, TaggerDelay delay)
: base(delay)
{
Contract.ThrowIfNull(subjectBuffer);
_subjectBuffer = subjectBuffer;
}
/// <summary>
/// Reports an event any time the workspace changes.
/// </summary>
public static ITaggerEventSource OnWorkspaceChanged(
ITextBuffer subjectBuffer,
TaggerDelay delay,
IAsynchronousOperationListener listener
)
{
return(new WorkspaceChangedEventSource(subjectBuffer, delay, listener));
}
public TextChangedEventSource(ITextBuffer subjectBuffer, TaggerDelay delay, bool reportChangedSpans)
: base(delay)
{
Contract.ThrowIfNull(subjectBuffer);
_subjectBuffer = subjectBuffer;
_reportChangedSpans = reportChangedSpans;
}
public TextChangedEventSource(ITextBuffer subjectBuffer, TaggerDelay delay, bool reportChangedSpans)
: base(delay)
{
Contract.ThrowIfNull(subjectBuffer);
_subjectBuffer = subjectBuffer;
_reportChangedSpans = reportChangedSpans;
}
public CaretPositionChangedEventSource(ITextView textView, ITextBuffer subjectBuffer, TaggerDelay delay)
: base(delay)
{
Contract.ThrowIfNull(textView);
Contract.ThrowIfNull(subjectBuffer);
_textView = textView;
}
public ViewSpanChangedEventSource(IThreadingContext threadingContext, ITextView textView, TaggerDelay textChangeDelay, TaggerDelay scrollChangeDelay)
{
Debug.Assert(textView != null);
_foregroundObject = new ForegroundThreadAffinitizedObject(threadingContext);
_textView = textView;
_textChangeDelay = textChangeDelay;
_scrollChangeDelay = scrollChangeDelay;
}
public static ITaggerEventSource OnReadOnlyRegionsChanged(
ITextBuffer subjectBuffer,
TaggerDelay delay
)
{
Contract.ThrowIfNull(subjectBuffer);
return(new ReadOnlyRegionsChangedEventSource(subjectBuffer, delay));
}
internal TaggerEventArgs(
string kind,
TaggerDelay delay,
TextContentChangedEventArgs textChangeEventArgs = null)
{
this.Kind = kind;
this.Delay = delay;
this.TextChangeEventArgs = textChangeEventArgs;
}
public DiagnosticsChangedEventSource(
ITextBuffer subjectBuffer,
IDiagnosticService service,
TaggerDelay delay
) : base(delay)
{
_subjectBuffer = subjectBuffer;
_service = service;
}
public CompletionClosedEventSource(
IIntellisenseSessionStack sessionStack,
TaggerDelay delay)
: base(delay)
{
Contract.ThrowIfNull(sessionStack);
_sessionStack = sessionStack;
}
internal TaggerEventArgs(
string kind,
TaggerDelay delay,
TextContentChangedEventArgs textChangeEventArgs = null)
{
this.Kind = kind;
this.Delay = delay;
this.TextChangeEventArgs = textChangeEventArgs;
}
protected AbstractWorkspaceTrackingTaggerEventSource(
ITextBuffer subjectBuffer,
TaggerDelay delay
) : base(delay)
{
this.SubjectBuffer = subjectBuffer;
_workspaceRegistration = Workspace.GetWorkspaceRegistration(
subjectBuffer.AsTextContainer()
);
}
internal static TimeSpan ComputeTimeDelay(this TaggerDelay behavior, ITextBuffer textBufferOpt)
{
if (TextBufferAssociatedViewService.AnyAssociatedViewHasFocus(textBufferOpt))
{
// TODO : should we remove TaggerBehavior enum all together and put NearImmediateDelay
// const in Interaction?
return(ComputeTimeDelay(behavior));
}
return(TimeSpan.FromMilliseconds(NonFocusDelay));
}
public CaretPositionChangedEventSource(
ITextView textView,
ITextBuffer subjectBuffer,
TaggerDelay delay
) : base(delay)
{
Contract.ThrowIfNull(textView);
Contract.ThrowIfNull(subjectBuffer);
_textView = textView;
}
public static ITaggerEventSource OnViewSpanChanged(
IThreadingContext threadingContext,
ITextView textView,
TaggerDelay textChangeDelay,
TaggerDelay scrollChangeDelay
) =>
new ViewSpanChangedEventSource(
threadingContext,
textView,
textChangeDelay,
scrollChangeDelay
);
public CompletionClosedEventSource(
ITextView textView,
IIntellisenseSessionStack sessionStack,
TaggerDelay delay)
: base(delay)
{
Contract.ThrowIfNull(textView);
Contract.ThrowIfNull(sessionStack);
_textView = textView;
_sessionStack = sessionStack;
}
public Tagger(SemanticClassificationBufferTaggerProvider owner, ITextBuffer subjectBuffer)
{
_owner = owner;
_subjectBuffer = subjectBuffer;
const TaggerDelay Delay = TaggerDelay.Short;
_eventSource = TaggerEventSources.Compose(
TaggerEventSources.OnSemanticChanged(subjectBuffer, Delay, _owner._semanticChangeNotificationService),
TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer, Delay));
ConnectToEventSource();
}
public CompilationAvailableTaggerEventSource(
ITextBuffer subjectBuffer,
TaggerDelay delay,
IThreadingContext threadingContext,
IAsynchronousOperationListener asyncListener,
params ITaggerEventSource[] eventSources)
{
_subjectBuffer = subjectBuffer;
_delay = delay;
_asyncListener = asyncListener;
_underlyingSource = TaggerEventSources.Compose(eventSources);
_workQueue = new AsynchronousSerialWorkQueue(threadingContext, asyncListener);
}
public BatchChangeNotifier(
ITextBuffer subjectBuffer,
IAsynchronousOperationListener listener,
IForegroundNotificationService notificationService,
Action <SnapshotSpan> reportChangedSpan,
TaggerDelay throttleDelay = TaggerDelay.Short)
{
Contract.ThrowIfNull(reportChangedSpan);
_subjectBuffer = subjectBuffer;
_listener = listener;
_notificationService = notificationService;
_reportChangedSpan = reportChangedSpan;
_throttleDelay = throttleDelay;
}
public BatchChangeNotifier(
ITextBuffer subjectBuffer,
IAsynchronousOperationListener listener,
IForegroundNotificationService notificationService,
Action<SnapshotSpan> reportChangedSpan,
TaggerDelay throttleDelay = TaggerDelay.Short)
{
Contract.ThrowIfNull(reportChangedSpan);
_subjectBuffer = subjectBuffer;
_listener = listener;
_notificationService = notificationService;
_reportChangedSpan = reportChangedSpan;
_throttleDelay = throttleDelay;
}
protected override ITaggerEventSource CreateEventSource(ITextView textView, ITextBuffer subjectBuffer)
{
this.AssertIsForeground();
const TaggerDelay Delay = TaggerDelay.Short;
// Note: we don't listen for OnTextChanged. They'll get reported by the ViewSpan changing
// and also the SemanticChange nodification.
//
// Note: when the user scrolls, we will try to reclassify as soon as possible. That way
// we appear semantically unclassified for a very short amount of time.
return(TaggerEventSources.Compose(
TaggerEventSources.OnViewSpanChanged(textView, textChangeDelay: Delay, scrollChangeDelay: TaggerDelay.NearImmediate),
TaggerEventSources.OnSemanticChanged(subjectBuffer, Delay, _semanticChangeNotificationService)));
}
public void EnqueueWork(
Func <Task> workAsync,
TaggerDelay delay,
IAsyncToken asyncToken,
CancellationToken cancellationToken)
{
lock (this)
{
_eventWorkQueue = _eventWorkQueue.ContinueWithAfterDelayFromAsync(
_ => workAsync(),
cancellationToken,
(int)delay.ComputeTimeDelay().TotalMilliseconds,
TaskContinuationOptions.None,
TaskScheduler.Default).CompletesAsyncOperation(asyncToken);
}
}
private void EnqueueNotificationRequest(TaggerDelay delay)
{
AssertIsForeground();
if (_notificationRequestEnqueued)
{
// we already have a pending task to update the UI. No need to do anything at this
// point.
return;
}
var currentTick = Environment.TickCount;
if (
Math.Abs(currentTick - _lastReportTick)
> TaggerDelay.NearImmediate.ComputeTimeDelay(_subjectBuffer).TotalMilliseconds
)
{
_lastReportTick = currentTick;
this.NotifyEditor();
}
else
{
// enqueue a task to update the UI with all the changed spans at some time in the
// future.
_notificationRequestEnqueued = true;
// Note: this operation is uncancellable. We already updated our internal state in
// RecomputeTags. We must eventually notify the editor about these changes so that the
// UI reaches parity with our internal model. Also, if we cancel it, then
// 'reportTagsScheduled' will stay 'true' forever and we'll never notify the UI.
_notificationService.RegisterNotification(
() =>
{
AssertIsForeground();
// First, clear the flag. That way any new changes we hear about will enqueue a task
// to run at a later point.
_notificationRequestEnqueued = false;
this.NotifyEditor();
},
(int)delay.ComputeTimeDelay(_subjectBuffer).TotalMilliseconds,
_listener.BeginAsyncOperation("EnqueueNotificationRequest"),
_cancellationToken
);
}
}
public Tagger(
SemanticClassificationBufferTaggerProvider owner,
ITextBuffer subjectBuffer,
IAsynchronousOperationListener asyncListener)
: base(owner.ThreadingContext)
{
_owner = owner;
_subjectBuffer = subjectBuffer;
const TaggerDelay Delay = TaggerDelay.Short;
_eventSource = TaggerEventSources.Compose(
TaggerEventSources.OnWorkspaceChanged(subjectBuffer, Delay, asyncListener),
TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer, Delay));
ConnectToEventSource();
}
internal static TimeSpan ComputeTimeDelay(this TaggerDelay behavior)
{
switch (behavior)
{
case TaggerDelay.NearImmediate:
return(TimeSpan.FromMilliseconds(NearImmediateDelay));
case TaggerDelay.Short:
return(TimeSpan.FromMilliseconds(ShortDelay));
case TaggerDelay.Medium:
return(TimeSpan.FromMilliseconds(MediumDelay));
case TaggerDelay.OnIdle:
default:
return(TimeSpan.FromMilliseconds(IdleDelay));
}
}
public static ITaggerEventSource OnSelectionChanged(
ITextView textView,
TaggerDelay delay)
{
return new SelectionChangedEventSource(textView, delay);
}
/// <summary>
/// Reports an event any time the semantics have changed such that this
/// <paramref name="subjectBuffer"/> should be retagged. Semantics are considered changed
/// for a buffer if an edit happens directly in that buffer, or if a top level visible
/// change happens in any sibling document or in any dependent projects' documents.
/// </summary>
public static ITaggerEventSource OnSemanticChanged(ITextBuffer subjectBuffer, TaggerDelay delay, ISemanticChangeNotificationService notificationService)
{
return new SemanticChangedEventSource(subjectBuffer, delay, notificationService);
}
public static ITaggerEventSource OnDocumentActiveContextChanged(ITextBuffer subjectBuffer, TaggerDelay delay)
{
return new DocumentActiveContextChangedEventSource(subjectBuffer, delay);
}
public static ITaggerEventSource OnCaretPositionChanged(ITextView textView, ITextBuffer subjectBuffer, TaggerDelay delay)
{
return new CaretPositionChangedEventSource(textView, subjectBuffer, delay);
}
protected AbstractWorkspaceTrackingTaggerEventSource(ITextBuffer subjectBuffer, TaggerDelay delay) : base(delay)
{
this.SubjectBuffer = subjectBuffer;
_workspaceRegistration = Workspace.GetWorkspaceRegistration(subjectBuffer.AsTextContainer());
}
public WorkspaceRegistrationChangedEventSource(ITextBuffer subjectBuffer, TaggerDelay delay)
: base(subjectBuffer, delay)
{
}
public static ITaggerEventSource OnWorkspaceRegistrationChanged(ITextBuffer subjectBuffer, TaggerDelay delay)
{
return new WorkspaceRegistrationChangedEventSource(subjectBuffer, delay);
}
public static ITaggerEventSource OnParseOptionChanged(
ITextBuffer subjectBuffer,
TaggerDelay delay)
{
return new ParseOptionChangedEventSource(subjectBuffer, delay);
}
/// <summary>
/// Creates a new <see cref="TaggerEventArgs"/>
/// </summary>
public TaggerEventArgs(TaggerDelay delay)
{
this.Delay = delay;
}
public OptionChangedEventSource(ITextBuffer subjectBuffer, IOption option, TaggerDelay delay) : base(subjectBuffer, delay)
{
_option = option;
}
public static ITaggerEventSource OnReadOnlyRegionsChanged(ITextBuffer subjectBuffer, TaggerDelay delay)
{
Contract.ThrowIfNull(subjectBuffer);
return new ReadOnlyRegionsChangedEventSource(subjectBuffer, delay);
}
public SelectionChangedEventSource(ITextView textView, TaggerDelay delay)
: base(delay)
{
_textView = textView;
}
public SemanticChangedEventSource(ITextBuffer subjectBuffer, TaggerDelay delay, ISemanticChangeNotificationService notificationService) :
base(subjectBuffer, delay)
{
_notificationService = notificationService;
}
protected AbstractTaggerEventSource(TaggerDelay delay)
{
_delay = delay;
}
/// <summary>
/// Creates a new <see cref="TaggerEventArgs"/>
/// </summary>
public TaggerEventArgs(TaggerDelay delay) : this("", delay)
{
}
public DiagnosticsChangedEventSource(ITextBuffer subjectBuffer, IDiagnosticService service, TaggerDelay delay)
: base(delay)
{
_subjectBuffer = subjectBuffer;
_service = service;
}
public static ITaggerEventSource OnTextChanged(ITextBuffer subjectBuffer, TaggerDelay delay, bool reportChangedSpans = false)
{
Contract.ThrowIfNull(subjectBuffer);
return new TextChangedEventSource(subjectBuffer, delay, reportChangedSpans);
}
public static ITaggerEventSource OnViewSpanChanged(ITextView textView, TaggerDelay textChangeDelay, TaggerDelay scrollChangeDelay)
{
return new ViewSpanChangedEventSource(textView, textChangeDelay, scrollChangeDelay);
}
private void RaiseChanged(TaggerDelay delay)
{
this.Changed?.Invoke(this, new TaggerEventArgs(delay));
}
public DocumentActiveContextChangedEventSource(ITextBuffer subjectBuffer, TaggerDelay delay)
: base(subjectBuffer, delay)
{
}
