Exemple #1
0
 private void BufferGraph_GraphBufferContentTypeChanged(object sender, GraphBufferContentTypeChangedEventArgs e)
 {
     if (Update())
     {
         OnContextChanged();
     }
 }
Exemple #2
0
        private void OnGraphBufferContentTypeChange(object sender, GraphBufferContentTypeChangedEventArgs args)
        {
            if (args.BeforeContentType.IsOfType("text") && args.AfterContentType.IsOfType("text"))
            {
                // We won't get subject buffers connected/disconnected calls when both the before & after content
                // types are "text", but we still need to manage intellisense controllers in this situation.
                // The broker associated with the subjectBuffer in question remains the same.
                ITextBuffer subjectBuffer = args.TextBuffer;

                for (int f = 0; f < _componentContext.IntellisenseControllerFactories.Count; ++f)
                {
                    var  factory     = _componentContext.IntellisenseControllerFactories[f];
                    bool beforeMatch = false;
                    bool afterMatch  = false;
                    foreach (string factoryContentType in factory.Metadata.ContentTypes)
                    {
                        if (args.BeforeContentType.IsOfType(factoryContentType))
                        {
                            beforeMatch = true;
                        }
                        if (args.AfterContentType.IsOfType(factoryContentType))
                        {
                            afterMatch = true;
                        }
                    }
                    if (beforeMatch != afterMatch)
                    {
                        if (beforeMatch)
                        {
                            if (this.Controllers[f] != null)
                            {
                                // the controller will be null if its creation failed
                                this.Controllers[f].DisconnectSubjectBuffer(subjectBuffer);
                                // should we destroy the controller if it has no more buffers?
                            }
                        }

                        if (afterMatch)
                        {
                            if (this.Controllers[f] != null)
                            {
                                this.Controllers[f].ConnectSubjectBuffer(subjectBuffer);
                            }
                            else
                            {
                                this.Controllers[f] =
                                    this._componentContext.GuardedOperations.InstantiateExtension(
                                        factory,
                                        factory,
                                        provider => provider.TryCreateIntellisenseController
                                            (_associatedTextView, new FrugalList <ITextBuffer>()
                                {
                                    subjectBuffer
                                }));
                            }
                        }
                    }
                }
            }
        }
        /// <summary>
        /// If the content type of any of the source buffers changes, we need to dispose
        /// all the taggers on the buffer that we have cached (if they are disposable) and get
        /// new ones.
        /// </summary>
        void BufferGraph_GraphBufferContentTypeChanged(object sender, GraphBufferContentTypeChangedEventArgs e)
        {
            if (this.disposed || !this.initialized || (((TagAggregatorOptions2)this.options).HasFlag(TagAggregatorOptions2.NoProjection) && (e.TextBuffer != this.BufferGraph.TopBuffer)))
            {
                return;
            }

            DisposeAllTaggersOverBuffer(e.TextBuffer);
            taggers[e.TextBuffer] = GatherTaggers(e.TextBuffer);

            // Send out an event to say that tags have changed over the entire text buffer, to
            // be safe.
            ITextSnapshot snapshot       = e.TextBuffer.CurrentSnapshot;
            SnapshotSpan  entireSnapshot = new SnapshotSpan(snapshot, 0, snapshot.Length);
            IMappingSpan  span           = this.BufferGraph.CreateMappingSpan(entireSnapshot, SpanTrackingMode.EdgeInclusive);

            this.RaiseEvents(this, span);
        }
        private void OnGraphBufferContentTypeChanged(object sender, GraphBufferContentTypeChangedEventArgs args)
        {
            var connectedListeners    = new List <IWpfTextViewConnectionListener>();
            var disconnectedListeners = new List <IWpfTextViewConnectionListener>();

            foreach (Listener listener in this.listeners)
            {
                bool beforeMatch = Match(listener.Metadata, args.BeforeContentType);
                bool afterMatch  = Match(listener.Metadata, args.AfterContentType);
                if (beforeMatch != afterMatch)
                {
                    var instance = listener.Instance;
                    if (instance != null)
                    {
                        if (beforeMatch)
                        {
                            disconnectedListeners.Add(instance);
                        }
                        else
                        {
                            connectedListeners.Add(instance);
                        }
                    }
                }
            }

            Collection <ITextBuffer> subjectBuffers = new Collection <ITextBuffer>(new List <ITextBuffer>(1)
            {
                args.TextBuffer
            });

            foreach (var instance in disconnectedListeners)
            {
                _guardedOperations.CallExtensionPoint(instance,
                                                      () => instance.SubjectBuffersDisconnected(_textView, ConnectionReason.ContentTypeChange, subjectBuffers));
            }

            foreach (var instance in connectedListeners)
            {
                _guardedOperations.CallExtensionPoint(instance,
                                                      () => instance.SubjectBuffersConnected(_textView, ConnectionReason.ContentTypeChange, subjectBuffers));
            }
        }
Exemple #5
0
 private void OnGraphBufferContentTypeChanged(object sender, GraphBufferContentTypeChangedEventArgs e)
 {
     RefreshBufferGraphList();
 }
 private void OnGraphBufferContentTypeChanged(object sender, GraphBufferContentTypeChangedEventArgs e)
 {
     RefreshBufferGraphList();
 }