示例#1
0
        internal AsyncTaggerType.TrackingCacheData CreateTrackingCacheData(SnapshotSpan source, params SnapshotSpan[] tagSpans)
        {
            var snapshot     = source.Snapshot;
            var trackingSpan = snapshot.CreateTrackingSpan(source, SpanTrackingMode.EdgeInclusive);
            var tag          = new TextMarkerTag("my tag");
            var all          = tagSpans
                               .Select(span => Tuple.Create(snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeInclusive), tag))
                               .ToReadOnlyCollection();

            return(new AsyncTaggerType.TrackingCacheData(
                       trackingSpan,
                       all));
        }
示例#2
0
        private TrackingCacheData <TextMarkerTag> CreateTrackingCacheData(SnapshotSpan source, params SnapshotSpan[] tagSpans)
        {
            var snapshot     = source.Snapshot;
            var trackingSpan = snapshot.CreateTrackingSpan(source, SpanTrackingMode.EdgeInclusive);
            var tag          = new TextMarkerTag("my tag");
            var all          = tagSpans
                               .Select(span => Tuple.Create(snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeInclusive), tag))
                               .ToFSharpList();

            return(new TrackingCacheData <TextMarkerTag>(
                       trackingSpan,
                       all));
        }
示例#3
0
        // Brace matching
        public IEnumerable<ITagSpan<TextMarkerTag>> GetBraceTags(ITextBuffer buffer, SnapshotPoint point)
        {
            var tokens = GetSemanticModel(buffer);
            var token = tokens.GetToken(point.Position - 1);
            var tag = new TextMarkerTag(Classifications.BraceHighlight);

            if (token?.MatchingToken != null && token.IsOpen == false)
            {
                yield return new TagSpan<TextMarkerTag>(new SnapshotSpan(point.Snapshot, token.Start, 1), tag);
                yield return new TagSpan<TextMarkerTag>(new SnapshotSpan(point.Snapshot, token.MatchingToken.Start, 1), tag);
            }
            else
            {
                token = tokens.GetToken(point.Position);

                if (token?.MatchingToken != null && token.IsOpen)
                {
                    yield return new TagSpan<TextMarkerTag>(new SnapshotSpan(point.Snapshot, token.Start, 1), tag);
                    yield return new TagSpan<TextMarkerTag>(new SnapshotSpan(point.Snapshot, token.MatchingToken.Start, 1), tag);
                }
            }
        }
示例#4
0
            private void AddWordsOnLine(List <ITagSpan <TextMarkerTag> > tags, ITextSnapshotLine snapshotLine)
            {
                var snapshot = snapshotLine.Snapshot;
                var tag      = new TextMarkerTag(Constants.FormatName);

                var i = 0;

                while (i < snapshotLine.Length)
                {
                    var point = snapshot.GetPoint(i + snapshotLine.Start.Position);
                    if (IsWord(point))
                    {
                        var span = new SnapshotSpan(snapshot, snapshotLine.Start.Position + i, _word.Length);
                        tags.Add(new TagSpan <TextMarkerTag>(span, tag));
                        i += _word.Length;
                    }
                    else
                    {
                        i++;
                    }
                }
            }
示例#5
0
        // Brace matching
        public IEnumerable <ITagSpan <TextMarkerTag> > GetBraceTags(ITextBuffer buffer, SnapshotPoint point)
        {
            var tokens = GetSemanticModel(buffer);
            var token  = tokens.GetToken(point.Position - 1);
            var tag    = new TextMarkerTag(Classifications.BraceHighlight);

            if (token?.MatchingToken != null && token.IsOpen == false)
            {
                yield return(new TagSpan <TextMarkerTag>(new SnapshotSpan(point.Snapshot, token.Start, 1), tag));

                yield return(new TagSpan <TextMarkerTag>(new SnapshotSpan(point.Snapshot, token.MatchingToken.Start, 1), tag));
            }
            else
            {
                token = tokens.GetToken(point.Position);

                if (token?.MatchingToken != null && token.IsOpen)
                {
                    yield return(new TagSpan <TextMarkerTag>(new SnapshotSpan(point.Snapshot, token.Start, 1), tag));

                    yield return(new TagSpan <TextMarkerTag>(new SnapshotSpan(point.Snapshot, token.MatchingToken.Start, 1), tag));
                }
            }
        }
        public void VsTextViewCreated(IVsTextView text_view)
        {
            if (ALanguageUtility.s_service_provider == null)
            {
                ALanguageUtility.s_service_provider = m_service_provider;
            }

            if (m_factory == null)
            {
                return;
            }

            SaveAdapterFactory();
            m_factory.Init(m_service_provider, m_adapters_factory);

            // 获取系统单例,用于打开文件
            if (m_open_document == null)
            {
                m_open_document = m_service_provider.GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
            }

            // 获取视窗
            IWpfTextView view = m_adapters_factory.GetWpfTextView(text_view);

            if (view == null)
            {
                return;
            }

            // 添加关闭监听
            view.Closed += OnViewClosed;

            // 创建ABnf
            if (m_abnf == null)
            {
                m_abnf = ALanguageUtility.CreateABnf(m_factory);
            }
            if (m_abnf == null)
            {
                return;
            }
            if (m_abnf_ui == null)
            {
                m_abnf_ui = ALanguageUtility.CreateABnf(m_factory);
            }
            if (m_abnf_ui == null)
            {
                return;
            }

            // 获取高亮tag
            if (m_highlight_tag == null)
            {
                m_highlight_tag = m_factory.CreateTextMarkerTag();
            }

            if (m_highlight_tag != null)
            {
                view.Properties.AddProperty(nameof(TextMarkerTag), m_highlight_tag);
            }

            // 获取全路径
            string full_path = ALanguageUtility.GetFilePath(view);

            if (full_path == null)
            {
                return;
            }

            var solution = m_factory.GetSolution();

            if (solution == null)
            {
                return;
            }

            var server = solution.GetServer();

            if (server != null)
            {
                view.Properties.AddProperty(nameof(ALanguageServer), server);
                view.TextBuffer.Properties.AddProperty(nameof(ALanguageServer), server);
            }
            view.Properties.AddProperty(nameof(IVsTextView), text_view);

            // 获取所在的工程
            m_open_document.IsDocumentInAProject(full_path, out IVsUIHierarchy project, out uint item_id, out Microsoft.VisualStudio.OLE.Interop.IServiceProvider _ppSP, out int _pDocInProj);
            UIProjectInfo project_info = null;

            if (project != null)
            {
                solution.GetProjects().TryGetValue(project, out project_info);
            }

            // 创建信息,并作为属性给view
            var info = new UIViewItem(m_abnf, m_abnf_ui, view, m_service_provider, m_adapters_factory, project_info, item_id, full_path, m_factory, m_factory.GetLineCommentBegin());

            view.Properties.AddProperty(nameof(UIViewItem), info);
            view.TextBuffer.Properties.AddProperty(nameof(UIViewItem), info);

            // 提前添加各种source
            {
                if (!view.TextBuffer.Properties.TryGetProperty(nameof(ALanguageCompletionSource), out ALanguageCompletionSource source))
                {
                    source = new ALanguageCompletionSource(view.TextBuffer);
                    view.TextBuffer.Properties.AddProperty(nameof(ALanguageCompletionSource), source);
                }
            }
            {
                if (!view.TextBuffer.Properties.TryGetProperty(nameof(ALanguageQuickInfoSource), out ALanguageQuickInfoSource source))
                {
                    source = new ALanguageQuickInfoSource(view.TextBuffer);
                    view.TextBuffer.Properties.AddProperty(nameof(ALanguageQuickInfoSource), source);
                }
            }
            {
                if (!view.TextBuffer.Properties.TryGetProperty(nameof(ALanguageSignatureHelpSource), out ALanguageSignatureHelpSource source))
                {
                    source = new ALanguageSignatureHelpSource(view.TextBuffer);
                    view.TextBuffer.Properties.AddProperty(nameof(ALanguageSignatureHelpSource), source);
                }
            }

            {
                if (!view.Properties.TryGetProperty(nameof(ALanguageErrorTagger), out ALanguageErrorTagger tagger))
                {
                    tagger = new ALanguageErrorTagger(view);
                    view.Properties.AddProperty(nameof(ALanguageErrorTagger), tagger);
                }
            }

            {
                if (!view.Properties.TryGetProperty(nameof(ALanguageReferenceTagger), out ALanguageReferenceTagger tagger))
                {
                    tagger = new ALanguageReferenceTagger(view);
                    view.Properties.AddProperty(nameof(ALanguageReferenceTagger), tagger);
                }
            }

            {
                if (!view.Properties.TryGetProperty(nameof(ALanguageHighlightWordTagger), out ALanguageHighlightWordTagger tagger))
                {
                    tagger = new ALanguageHighlightWordTagger(view);
                    view.Properties.AddProperty(nameof(ALanguageHighlightWordTagger), tagger);
                }
            }

            // 添加命令
            {
                ALanguageGotoDefinitionCommand filter = new ALanguageGotoDefinitionCommand(view);
                text_view.AddCommandFilter(filter, out IOleCommandTarget next);
                filter.Next = next;
                view.Properties.AddProperty(nameof(ALanguageGotoDefinitionCommand) + "Target", next);
            }

            {
                ALanguageCompletionCommand filter = new ALanguageCompletionCommand(view, m_completion_broker);
                text_view.AddCommandFilter(filter, out IOleCommandTarget next);
                filter.Next = next;
                view.Properties.AddProperty(nameof(ALanguageCompletionCommand) + "Target", next);
                view.Properties.AddProperty(nameof(ALanguageCompletionCommand), filter);
            }
        }
示例#7
0
        protected override ITagSpan <ITextMarkerTag> CreateTagSpan(ITextSnapshot snapshot, SnapshotSpan rawTag)
        {
            var tag = new TextMarkerTag(@"bracehighlight");

            return(new TagSpan <ITextMarkerTag>(rawTag, tag));
        }
示例#8
0
        string DisplayStringForTag(ITag tag, out object toolTipContent)
        {
            toolTipContent = null;

            List <string> content = new List <string>();

            ClassificationTag classification = tag as ClassificationTag;

            if (classification != null)
            {
                content.Add(classification.ClassificationType.ToString());
            }

            ErrorTag error = tag as ErrorTag;

            if (error != null)
            {
                toolTipContent = error.ToolTipContent;
                content.Add(error.ErrorType);
            }

            IOutliningRegionTag region = tag as IOutliningRegionTag;

            if (region != null)
            {
                toolTipContent = region.CollapsedHintForm;
                content.Add(string.Format("IsImplementation: {0}, IsDefaultCollapsed: {1}", region.IsImplementation, region.IsDefaultCollapsed));
            }

            TextMarkerTag marker = tag as TextMarkerTag;

            if (marker != null)
            {
                content.Add(marker.Type);
            }

            SpaceNegotiatingAdornmentTag snat = tag as SpaceNegotiatingAdornmentTag;

            if (snat != null)
            {
                content.Add(string.Format("TextHeight: {0}, Width: {1}, Affinity: {2}", snat.TextHeight, snat.Width, snat.Affinity));
            }

            IntraTextAdornmentTag itat = tag as IntraTextAdornmentTag;

            if (itat != null)
            {
                content.Add("Content: " + itat.Adornment.ToString());
            }

            IUrlTag url = tag as IUrlTag;

            if (url != null)
            {
                content.Add(url.Url.ToString());
            }

            if (content.Count > 0)
            {
                return(string.Join(Environment.NewLine, content));
            }
            else
            {
                return(tag?.ToString());
            }
        }