Esempio n. 1
0
        public ITagger <T> CreateTagger <T>(ITextBuffer buffer) where T : ITag
        {
            if (!buffer.GetFeatureOnOffOption(InternalFeatureOnOffOptions.SyntacticColorizer))
            {
                return(null);
            }

            if (!_tagComputers.TryGetValue(buffer, out var tagComputer))
            {
                tagComputer = new TagComputer(buffer, _notificationService, _listener, _typeMap, this);
                _tagComputers.Add(buffer, tagComputer);
            }

            tagComputer.IncrementReferenceCount();

            var tagger = new Tagger(tagComputer);

            if (!(tagger is ITagger <T> typedTagger))
            {
                // Oops, we can't actually return this tagger, so just clean up
                tagger.Dispose();
                return(null);
            }
            else
            {
                return(typedTagger);
            }
        }
 public void Dispose()
 {
     Combiner = null;
     Changer  = null;
     Tagger?.Dispose();
     Tagger = null;
 }
        public ITagger <T> CreateTagger <T>(ITextBuffer buffer) where T : ITag
        {
            if (!buffer.GetFeatureOnOffOption(InternalFeatureOnOffOptions.SyntacticColorizer))
            {
                return(null);
            }

            if (!_tagComputers.TryGetValue(buffer, out var tagComputer))
            {
                var asyncListener = new AggregateAsynchronousOperationListener(_asyncListeners, FeatureAttribute.Classification);
                tagComputer = new TagComputer(buffer, _notificationService, asyncListener, _typeMap, this);
                _tagComputers.Add(buffer, tagComputer);
            }

            tagComputer.IncrementReferenceCount();

            var tagger      = new Tagger(tagComputer);
            var typedTagger = tagger as ITagger <T>;

            if (typedTagger == null)
            {
                // Oops, we can't actually return this tagger, so just clean up
                tagger.Dispose();
                return(null);
            }
            else
            {
                return(typedTagger);
            }
        }
 protected static void ClassCleanup()
 {
     Combiner = null;
     Changer  = null;
     Tagger?.Dispose();
     Tagger = null;
 }
        public void TaggerCrossClick(object tagger)
        {
            Tagger       TaggerObject  = (Tagger)tagger;
            DialogResult PerformRemove = MessageBox.Show("Do you really want to remove " + TaggerObject.Text + " tag?", "Remove Tag", MessageBoxButtons.YesNo, MessageBoxIcon.Question);

            if (PerformRemove == DialogResult.Yes)
            {
                int index = FinalString.FindIndex(t => (t.Item2 == TaggerObject.ID) && (t.Item3 == TaggerObject.Text));
                FinalString.RemoveAt(index);
                TaggerObject.Dispose();
                count--;
            }
        }
        public void TaggerCrossClick(object tagger)
        {
            Tagger       TaggerObject  = (Tagger)tagger;
            DialogResult PerformRemove = MessageBox.Show("Do you really want to remove " + TaggerObject.Text + " tag?", "Remove Tag", MessageBoxButtons.YesNo, MessageBoxIcon.Question);

            if (PerformRemove == DialogResult.Yes)
            {
                count--;
                int index = TagGroupList.FindIndex(t => t.Item1 == TaggerObject.ID);
                TagGroupList.RemoveAt(index);
                TaggerObject.Dispose();
            }
        }
        public ITagger <T> CreateTagger <T>(ITextBuffer buffer) where T : ITag
        {
            if (!buffer.GetOption(InternalFeatureOnOffOptions.SyntacticColorizer))
            {
                return(null);
            }

            TagComputer tagComputer;

            if (!_tagComputers.TryGetValue(buffer, out tagComputer))
            {
                var asyncListener = new AggregateAsynchronousOperationListener(_asyncListeners, FeatureAttribute.Classification);

                var languageName = _contentTypesToLanguageNames.FirstOrDefault(x => buffer.ContentType.MatchesAny(x.Metadata.DefaultContentType))?.Metadata.Language;
                var editorClassificationService = _editorClassificationLanguageServices.FirstOrDefault(x => x.Metadata.Language == languageName).Value as IEditorClassificationService;

                if (editorClassificationService == null)
                {
                    return(null);
                }

                tagComputer = new TagComputer(
                    buffer,
                    _notificationService,
                    asyncListener,
                    _typeMap,
                    this,
                    _viewSupportsClassificationServiceOpt,
                    _associatedViewService,
                    editorClassificationService,
                    languageName);

                _tagComputers.Add(buffer, tagComputer);
            }

            tagComputer.IncrementReferenceCount();

            var tagger      = new Tagger(tagComputer);
            var typedTagger = tagger as ITagger <T>;

            if (typedTagger == null)
            {
                // Oops, we can't actually return this tagger, so just clean up
                tagger.Dispose();
                return(null);
            }
            else
            {
                return(typedTagger);
            }
        }
        public TextStyleChanger()
        {
            try
            {
                var dir = Path.GetDirectoryName(GetType().Assembly.Location);
                Tagger = Tagger <WNode> .Create(() => new WNode(), Path.Combine(dir, "UniDic-CWJ"));

                Changer  = new LanguageStyleChanger(Tagger);
                Combiner = new TokenCombiner <WNode>(n => n.Surface, n => n.RLength != n.Length);
            }
            catch (Exception)
            {
                Tagger?.Dispose();
                throw;
            }
        }
        public ITagger <T> CreateTagger <T>(ITextBuffer buffer) where T : ITag
        {
            if (!tagComputers.TryGetValue(buffer, out var tagComputer))
            {
                tagComputer = new TagComputer(buffer, _typeMap, _listener, this);
                tagComputers.Add(buffer, tagComputer);
            }

            tagComputer.IncrementReferenceCount();

            var tagger = new Tagger(tagComputer);

            if (tagger is ITagger <T> typedTagger)
            {
                return(typedTagger);
            }

            // Oops, we can't actually return this tagger, so just clean up
            // (This seems like it should be impossible in practice, but Roslyn
            // was hardened against it so we are as well.)
            tagger.Dispose();
            return(null);
        }
Esempio n. 10
0
 protected override void OnDestroyed()
 {
     Tagger.Dispose();
     base.OnDestroyed();
 }