private void OnContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
// It is possible we have a situation where we are contained in another tagger. We both subscribe to the buffers content type changed event
// but the other tagger is disposed of first (and it disposes of us) so we need to guard against handling the event after being disposed of.
if (!this.disposed)
{
if (this.bufferStates.TryGetValue(e.After.TextBuffer, out BufferState state))
{
foreach (var tagger in state.Taggers)
{
this.UnregisterTagger(tagger);
}
state.Taggers.Clear();
this.AddTaggers(e.After.TextBuffer, state.Taggers);
}
// Send out an event to say that tags have changed over the entire text buffer, to
// be safe.
SnapshotSpan entireSnapshot = new SnapshotSpan(e.After, 0, e.After.Length);
IMappingSpan span = this.BufferGraph.CreateMappingSpan(entireSnapshot, SpanTrackingMode.EdgeInclusive);
this.RaiseEvents(this, span);
}
}
void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
if (!e.AfterContentType.IsOfType(ContentType))
{
Dispose();
}
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
// TODO: Should we be detaching here?
_spanCache = null;
_buffer.OnContentTypeChanged -= BufferContentTypeChanged;
_buffer.OnNewAnalysis -= OnNewAnalysis;
}
internal void OnSourceBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
TextContentChangedEventArgs args = new TextContentChangedEventArgs(e.Before, e.After, EditOptions.None, e.EditTag);
this.pendingContentChangedEventArgs.Add(args);
this.group.ScheduleIndependentEdit(this);
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
_tokenCache.Clear();
_buffer.OnChanged -= BufferChanged;
_buffer.OnContentTypeChanged -= BufferContentTypeChanged;
_buffer.OnNewAnalysisEntry -= NewAnalysisEntry;
}
private void Buffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
if (!_isDisposed)
{
OnContentTypeChanged?.Invoke(this, e);
}
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
_spanCache = null;
_buffer.ContentTypeChanged -= BufferContentTypeChanged;
_buffer.Properties.RemoveProperty(typeof(PythonAnalysisClassifier));
_buffer.UnregisterForNewAnalysis(OnNewAnalysis);
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
_tokenCache.Clear();
_buffer.Changed -= BufferChanged;
_buffer.ContentTypeChanged -= BufferContentTypeChanged;
_buffer.Properties.RemoveProperty(typeof(Genero4glClassifier));
}
/// <summary>
/// Invalidate our cached navigator.
/// </summary>
void OnContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
ITextBuffer buffer = e.Before.TextBuffer;
buffer.Properties.RemoveProperty(typeof(ITextStructureNavigator));
buffer.ContentTypeChanged -= OnContentTypeChanged;
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
_tokenCache.Clear();
_buffer.Changed -= BufferChanged;
_buffer.ContentTypeChanged -= BufferContentTypeChanged;
_buffer.Properties.RemoveProperty(typeof(PythonClassifier));
_buffer.UnregisterForNewAnalysisEntry(NewAnalysisEntry);
}
protected override void ContentTypeChanged(ITextBuffer buffer, ContentTypeChangedEventArgs e)
{
base.ContentTypeChanged(buffer, e);
// Update the content type and force the options to be re-cached.
this.contentType = e.AfterContentType;
this.OptionsChanged(null);
}
private void DocumentBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
if (ContentTypeChanged != null)
{
var ne = new TextDataModelContentTypeChangedEventArgs(e.BeforeContentType, e.AfterContentType);
ContentTypeChanged(sender, ne);
}
}
private void TextBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
var buffer = sender as ITextBuffer;
Debug.Assert(buffer != null, "buffer is null");
EnsureBufferHasTokenizer(e.AfterContentType, buffer);
}
private void ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
if (e.BeforeContentType.TypeName != e.AfterContentType.TypeName)
{
this.SetLanguage(e.After);
this.UpdateBraceList(new SnapshotPoint(e.After, 0));
}
}
private void DocumentBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
if (ContentTypeChanged != null)
{
var ne = new TextDataModelContentTypeChangedEventArgs(e.BeforeContentType, e.AfterContentType);
ContentTypeChanged(sender, ne);
}
}
void ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
if (!e.AfterContentType.IsOfType(MSBuildContentType.Name))
{
var buffer = (ITextBuffer)sender;
buffer.ContentTypeChanged -= ContentTypeChanged;
buffer.Properties.RemoveProperty(typeof(MSBuildSpellChecker));
}
}
static void TextBuffer_ContentTypeChanged(object?sender, ContentTypeChangedEventArgs e)
{
var textBuffer = (ITextBuffer)sender !;
textBuffer.ContentTypeChanged -= TextBuffer_ContentTypeChanged;
bool b = textBuffer.Properties.RemoveProperty(typeof(ITextStructureNavigator));
Debug.Assert(b);
}
private void OnVisualBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
// A content type change can (?) generate a new snapshot. In that case the change events are not
// raised, so the cache is not cleared and that causes an assertion since there is a new
// snapshot in the editor.
// This case is now detected and the new snapshot is taken.
OnVisualBufferChanged(null, e.After);
}
private void OnSourceBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
BufferGraph targetGraph = this.GetTargetGraph();
if (targetGraph != null)
{
targetGraph.ContentTypeChanged(sender, e);
}
}
private void OnSourceBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
BaseProjectionBuffer targetBuffer = this.GetTargetBuffer();
if (targetBuffer != null)
{
targetBuffer.OnSourceBufferContentTypeChanged(sender, e);
}
}
private void OnDocumentBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
EventHandler <TextDataModelContentTypeChangedEventArgs> handler = ContentTypeChanged;
if (handler != null)
{
handler(this, new TextDataModelContentTypeChangedEventArgs(e.BeforeContentType, e.AfterContentType));
}
}
public void RaiseEvent(BaseBuffer baseBuffer, bool immediate)
{
EventHandler <ContentTypeChangedEventArgs> handler = immediate ? baseBuffer.ContentTypeChangedImmediate : baseBuffer.ContentTypeChanged;
if (handler != null)
{
var eventArgs = new ContentTypeChangedEventArgs(this.beforeSnapshot, this.afterSnapshot, this.beforeContentType, this.afterContentType, this.editTag);
baseBuffer.guardedOperations.RaiseEvent(baseBuffer, handler, eventArgs);
}
}
protected void ContentTypeChanged(object sender, ContentTypeChangedEventArgs args)
{
// we do not subscribe to the immediate form of the sender's content type changed
// event, so we do not need to queue this event
var handler = GraphBufferContentTypeChanged;
if (handler != null)
{
handler(this, new GraphBufferContentTypeChangedEventArgs((ITextBuffer)sender, args.BeforeContentType, args.AfterContentType));
}
}
void TextBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
_textBuffer.ContentTypeChanged -= TextBuffer_ContentTypeChanged;
if (_textBuffer.Properties.ContainsProperty(typeof(PowerShellBraceMatchingTagger)))
{
_textBuffer.Properties.RemoveProperty(typeof(PowerShellBraceMatchingTagger).Name);
}
_textView.Caret.PositionChanged -= CaretPositionChanged;
_textView.LayoutChanged -= ViewLayoutChanged;
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
_spanCache = null;
_buffer.Changed -= BufferChanged;
_buffer.ContentTypeChanged -= BufferContentTypeChanged;
if (_entry != null)
{
_entry.OnNewAnalysis -= OnNewAnalysis;
_entry = null;
}
_buffer.Properties.RemoveProperty(typeof(PythonAnalysisClassifier));
}
void ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
if (!e.AfterContentType.IsOfType(MSBuildContentType.Name))
{
var buffer = (ITextBuffer)sender;
buffer.ContentTypeChanged -= ContentTypeChanged;
if (buffer.Properties.TryGetProperty(typeof(MSBuildBackgroundParser), out MSBuildBackgroundParser parser))
{
parser.Dispose();
}
buffer.Properties.RemoveProperty(typeof(MSBuildBackgroundParser));
}
}
// The REPL window might change content type to host command content type (when a host command is typed at the beginning of the buffer).
private void LanguageBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
// It's not clear whether this situation will ever happen, but just in case.
if (e.BeforeContentType == e.AfterContentType)
{
return;
}
var buffer = e.Before.TextBuffer;
var contentTypeName = this.ContentType.TypeName;
var afterIsLanguage = e.AfterContentType.IsOfType(contentTypeName);
var afterIsInteractiveCommand = e.AfterContentType.IsOfType(PredefinedInteractiveCommandsContentTypes.InteractiveCommandContentTypeName);
var beforeIsLanguage = e.BeforeContentType.IsOfType(contentTypeName);
var beforeIsInteractiveCommand = e.BeforeContentType.IsOfType(PredefinedInteractiveCommandsContentTypes.InteractiveCommandContentTypeName);
Debug.Assert((afterIsLanguage && beforeIsInteractiveCommand) ||
(beforeIsLanguage && afterIsInteractiveCommand));
// We're switching between the target language and the Interactive Command "language".
// First, remove the current submission from the solution.
var oldSolution = _workspace.CurrentSolution;
var newSolution = oldSolution;
foreach (var documentId in _workspace.GetRelatedDocumentIds(buffer.AsTextContainer()))
{
Debug.Assert(documentId != null);
newSolution = newSolution.RemoveDocument(documentId);
// TODO (tomat): Is there a better way to remove mapping between buffer and document in REPL?
// Perhaps TrackingWorkspace should implement RemoveDocumentAsync?
_workspace.ClearOpenDocument(documentId);
}
// Next, remove the previous submission project and update the workspace.
newSolution = newSolution.RemoveProject(_currentSubmissionProjectId);
_workspace.SetCurrentSolution(newSolution);
// Add a new submission with the correct language for the current buffer.
var languageName = afterIsLanguage
? this.LanguageName
: InteractiveLanguageNames.InteractiveCommand;
AddSubmission(buffer, languageName);
}
static void TextBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
var buffer = sender as ITextBuffer;
if (buffer == null)
{
return;
}
if (e.AfterContentType.IsOfType("PowerShell") && !buffer.Properties.ContainsProperty("HasTokenizer"))
{
var psts = new PowerShellTokenizationService(buffer);
_gotoDefinitionCommand.AddTextBuffer(buffer);
buffer.ChangedLowPriority += (o, args) => psts.StartTokenization();
buffer.Properties.AddProperty("HasTokenizer", true);
}
}
private void OnContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
var buffer = (ITextBuffer)sender;
buffer.ContentTypeChanged -= OnContentTypeChanged;
var bufferSources = (IEnumerable <TSource>)_bufferCache[buffer];
if (bufferSources != null)
{
foreach (TSource source in bufferSources)
{
source.Dispose();
}
}
_bufferCache.Remove(buffer);
}
// The REPL window might change content type to host command content type (when a host command is typed at the beginning of the buffer).
private void LanguageBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
var buffer = e.Before.TextBuffer;
var afterIsCSharp = e.AfterContentType.IsOfType(ContentTypeNames.CSharpContentType);
var beforeIsCSharp = e.BeforeContentType.IsOfType(ContentTypeNames.CSharpContentType);
if (afterIsCSharp == beforeIsCSharp)
{
return;
}
if (afterIsCSharp)
{
// add a new document back to the project
var project = _workspace.CurrentSolution.GetProject(_currentSubmissionProjectId);
Debug.Assert(project != null);
SetSubmissionDocument(buffer, project);
}
else
{
Debug.Assert(beforeIsCSharp);
// remove document from the project
foreach (var documentId in _workspace.GetRelatedDocumentIds(buffer.AsTextContainer()))
{
Debug.Assert(documentId != null);
_workspace.SetCurrentSolution(_workspace.CurrentSolution.RemoveDocument(documentId));
// TODO (tomat): Is there a better way to remove mapping between buffer and document in REPL?
// Perhaps TrackingWorkspace should implement RemoveDocumentAsync?
_workspace.ClearOpenDocument(documentId);
// Ensure sure our buffer is still registered with the workspace. This allows consumers
// to get back to the interactive workspace from the Interactive Command buffer.
_workspace.RegisterText(buffer.AsTextContainer());
}
}
}
void TextBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e) => realContentTypeChanged?.Invoke(this, new TextDataModelContentTypeChangedEventArgs(e.BeforeContentType, e.AfterContentType));
static void TextBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e) {
var textBuffer = (ITextBuffer)sender;
textBuffer.ContentTypeChanged -= TextBuffer_ContentTypeChanged;
bool b = textBuffer.Properties.RemoveProperty(typeof(ITextStructureNavigator));
Debug.Assert(b);
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e) {
_tokenCache.Clear();
_buffer.Changed -= BufferChanged;
_buffer.ContentTypeChanged -= BufferContentTypeChanged;
_buffer.Properties.RemoveProperty(typeof(PythonClassifier));
_buffer.UnregisterForNewAnalysisEntry(NewAnalysisEntry);
}
// The REPL window might change content type to host command content type (when a host command is typed at the beginning of the buffer).
private void LanguageBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
var buffer = e.Before.TextBuffer;
var afterIsCSharp = e.AfterContentType.IsOfType(ContentTypeNames.CSharpContentType);
var beforeIsCSharp = e.BeforeContentType.IsOfType(ContentTypeNames.CSharpContentType);
if (afterIsCSharp == beforeIsCSharp)
{
return;
}
if (afterIsCSharp)
{
// add a new document back to the project
var project = _workspace.CurrentSolution.GetProject(_currentSubmissionProjectId);
Debug.Assert(project != null);
SetSubmissionDocument(buffer, project);
}
else
{
Debug.Assert(beforeIsCSharp);
// remove document from the project
foreach (var documentId in _workspace.GetRelatedDocumentIds(buffer.AsTextContainer()))
{
Debug.Assert(documentId != null);
_workspace.SetCurrentSolution(_workspace.CurrentSolution.RemoveDocument(documentId));
// TODO (tomat): Is there a better way to remove mapping between buffer and document in REPL?
// Perhaps TrackingWorkspace should implement RemoveDocumentAsync?
_workspace.ClearOpenDocument(documentId);
// Ensure sure our buffer is still registered with the workspace. This allows consumers
// to get back to the interactive workspace from the Interactive Command buffer.
_workspace.RegisterText(buffer.AsTextContainer());
}
}
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e) {
_spanCache = null;
_buffer.Changed -= BufferChanged;
_buffer.ContentTypeChanged -= BufferContentTypeChanged;
if (_entry != null) {
_entry.OnNewAnalysis -= OnNewAnalysis;
_entry = null;
}
_buffer.Properties.RemoveProperty(typeof(PythonAnalysisClassifier));
}
// The REPL window might change content type to host command content type (when a host command is typed at the beginning of the buffer).
private void LanguageBufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
// It's not clear whether this situation will ever happen, but just in case.
if (e.BeforeContentType == e.AfterContentType)
{
return;
}
var buffer = e.Before.TextBuffer;
var contentTypeName = this.ContentType.TypeName;
var afterIsLanguage = e.AfterContentType.IsOfType(contentTypeName);
var afterIsInteractiveCommand = e.AfterContentType.IsOfType(PredefinedInteractiveCommandsContentTypes.InteractiveCommandContentTypeName);
var beforeIsLanguage = e.BeforeContentType.IsOfType(contentTypeName);
var beforeIsInteractiveCommand = e.BeforeContentType.IsOfType(PredefinedInteractiveCommandsContentTypes.InteractiveCommandContentTypeName);
Debug.Assert((afterIsLanguage && beforeIsInteractiveCommand)
|| (beforeIsLanguage && afterIsInteractiveCommand));
// We're switching between the target language and the Interactive Command "language".
// First, remove the current submission from the solution.
var oldSolution = _workspace.CurrentSolution;
var newSolution = oldSolution;
foreach (var documentId in _workspace.GetRelatedDocumentIds(buffer.AsTextContainer()))
{
Debug.Assert(documentId != null);
newSolution = newSolution.RemoveDocument(documentId);
// TODO (tomat): Is there a better way to remove mapping between buffer and document in REPL?
// Perhaps TrackingWorkspace should implement RemoveDocumentAsync?
_workspace.ClearOpenDocument(documentId);
}
// Next, remove the previous submission project and update the workspace.
newSolution = newSolution.RemoveProject(_currentSubmissionProjectId);
_workspace.SetCurrentSolution(newSolution);
// Add a new submission with the correct language for the current buffer.
var languageName = afterIsLanguage
? this.LanguageName
: InteractiveLanguageNames.InteractiveCommand;
AddSubmission(_currentTextView, buffer, languageName);
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
_tokenCache.Clear();
_buffer.Changed -= BufferChanged;
_buffer.ContentTypeChanged -= BufferContentTypeChanged;
_buffer.Properties.RemoveProperty(typeof(JClassifier));
}
private void ContentTypeChanged(object sender, ContentTypeChangedEventArgs e)
{
if ( e.BeforeContentType.TypeName != e.AfterContentType.TypeName ) {
this.SetLanguage(e.AfterContentType);
this.UpdateBraceList(new SnapshotPoint(e.After, 0));
}
}
void TextBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e) {
// The value is cached, make sure it uses the latest snapshot
OnImplicitCaretPositionChanged();
}
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e) {
_spanCache = null;
_buffer.ContentTypeChanged -= BufferContentTypeChanged;
_buffer.Properties.RemoveProperty(typeof(PythonAnalysisClassifier));
_buffer.UnregisterForNewAnalysis(OnNewAnalysis);
}
void TextBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e) => // The value is cached, make sure it uses the latest snapshot OnImplicitCaretPositionChanged();
void TextBuffer_ContentTypeChanged(object sender, ContentTypeChangedEventArgs e) {
var buffer = (ITextBuffer)sender;
GraphBufferContentTypeChanged?.Invoke(this, new GraphBufferContentTypeChangedEventArgs(buffer, e.BeforeContentType, e.AfterContentType));
}
