internal void UpdateErrors(ITextSnapshot currentSnapshot, ErrorSnapShot errors)
{
ErrorSnapShot oldErrors = _errors;
_errors = errors;
EventHandler <SnapshotSpanEventArgs> h = this.TagsChanged;
if (h != null)
{
// Raise a single tags changed event over the span that could have been affected by the change in the errors.
int start = int.MaxValue;
int end = int.MinValue;
if ((oldErrors != null) && (oldErrors.Errors.Count > 0))
{
start = oldErrors.Errors[0].Span.Start.TranslateTo(currentSnapshot, PointTrackingMode.Negative);
end = oldErrors.Errors[oldErrors.Errors.Count - 1].Span.End.TranslateTo(currentSnapshot, PointTrackingMode.Positive);
}
if (errors.Count > 0)
{
start = Math.Min(start, errors.Errors[0].Span.Start.Position);
end = Math.Max(end, errors.Errors[errors.Errors.Count - 1].Span.End.Position);
}
if (start < end)
{
h(this, new SnapshotSpanEventArgs(new SnapshotSpan(currentSnapshot, Span.FromBounds(start, end))));
}
}
}
private void OnBufferChange(object sender, TextContentChangedEventArgs e)
{
_currentSnapshot = e.After;
// Translate all errors to the new snapshot (and remove anything that is a dirty region since we will need to check that again).
var oldErrors = this._factory.CurrentSnapshot;
var newErrors = new ErrorSnapShot(this._filePath, oldErrors.VersionNumber + 1);
// Copy all of the old errors to the new errors unless the error was affected by the text change
foreach (var error in oldErrors.Errors)
{
Debug.Assert(error.NextIndex == -1);
ErrorSpan newError = ErrorSpan.CloneAndTranslateTo(error, e.After);
if (newError != null)
{
Debug.Assert(newError.Span.Length == error.Span.Length);
error.NextIndex = newErrors.Errors.Count;
newErrors.Errors.Add(newError);
}
}
this.UpdateErrors(newErrors);
this.KickUpdate();
}
internal ErrorHighLightTagger(ErrorHighLightChecker errorChecker)
{
_errorChecker = errorChecker;
_errors = errorChecker.LastError;
errorChecker.AddTagger(this);
}
private void DoUpdate()
{
// It would be good to do all of this work on a background thread but we can't:
// _classifier.GetClassificationSpans() should only be called on the UI thread because some classifiers assume they are called from the UI thread.
// Raising the TagsChanged event from the taggers needs to happen on the UI thread (because some consumers might assume it is being raised on the UI thread).
//
// Updating the snapshot for the factory and calling the sink can happen on any thread but those operations are so fast that there is no point.
if (!_isDisposed)
{
if (_buffer.Equals(_textview.TextBuffer))
{
ErrorSnapShot oldErrors = this._factory.CurrentSnapshot;
ErrorSnapShot newErrors = new ErrorSnapShot(this._filePath, oldErrors.VersionNumber + 1);
List <ErrorInformation> newSpanErrors;
// Go through the existing errors. If they are on the line we are currently parsing then
// copy them to oldLineErrors, otherwise they go to the new errors.
newSpanErrors = this.GetErrorInformation(_buffer.CurrentSnapshot.GetText());
if (!newSpanErrors.Equals(_spanErrors))
{
_spanErrors.Clear();
_spanErrors.AddRange(newSpanErrors);
foreach (ErrorInformation spanError in _spanErrors)
{
if (spanError.Length >= 0)
{
SnapshotSpan newSpan = new SnapshotSpan(_buffer.CurrentSnapshot, spanError.StartIndex, spanError.Length);
ErrorSpan oldError = oldErrors.Errors.Find((e) => e.Span == newSpan);
if (oldError != null)
{
// There was a error at the same span as the old one so we should be able to just reuse it.
oldError.NextIndex = newErrors.Errors.Count;
newErrors.Errors.Add(ErrorSpan.Clone(oldError)); // Don't clone the old error yet
}
else
{
newErrors.Errors.Add(new ErrorSpan(newSpan, spanError.ErrorMessage, spanError.ErrorCode));
}
}
}
this.UpdateErrors(newErrors);
}
else
{
foreach (var error in oldErrors.Errors)
{
error.NextIndex = -1;
}
}
}
}
_isUpdating = false;
}
private void UpdateErrors(ErrorSnapShot errors)
{
// Tell our factory to snap to a new snapshot.
this._factory.UpdateErrors(errors);
// Tell the provider to mark all the sinks dirty (so, as a side-effect, they will start an update pass that will get the new snapshot
// from the factory).
_provider.UpdateAllSinks();
foreach (var tagger in _activeTaggers)
{
tagger.UpdateErrors(_currentSnapshot, errors);
}
this.LastError = errors;
}
internal void UpdateErrors(ErrorSnapShot errors)
{
this.CurrentSnapshot.NextSnapshot = errors;
this.CurrentSnapshot = errors;
}
public ErrorFactory(ErrorHighLightChecker errorChecker, ErrorSnapShot errors)
{
_errorChecker = errorChecker;
this.CurrentSnapshot = errors;
}