public ILineTransformSource Create(IWpfTextView textView)
{
Contract.Assume(textView != null);
if (VSServiceProvider.Current == null || VSServiceProvider.Current.ExtensionHasFailed)
{
//If the VSServiceProvider is not initialize, we can't do anything.
return(null);// new DummyLineTransformSource();
}
try {
VSServiceProvider.Current.ExtensionFailed += OnFailed;
if (hasFailed)
{
return(null);
}
Contract.Assume(this.OutliningManagerService != null, "Import attribute guarantees this.");
var outliningManager = OutliningManagerService.GetOutliningManager(textView);
if (outliningManager == null)
{
return(null);//new DummyLineTransformSource();
}
var inheritanceManager = AdornmentManager.GetOrCreateAdornmentManager(textView, "InheritanceAdornments", outliningManager, VSServiceProvider.Current.Logger);
var metadataManager = AdornmentManager.GetOrCreateAdornmentManager(textView, "MetadataAdornments", outliningManager, VSServiceProvider.Current.Logger);
return(new LineTransformSource(VSServiceProvider.Current.Logger, inheritanceManager.Adornments.Values, metadataManager.Adornments.Values));
} catch (Exception exn) {
VSServiceProvider.Current.Logger.PublicEntryException(exn, "Create");
return(null);// new DummyLineTransformSource();
}
}
public void VsTextViewCreated(IVsTextView textViewAdapter)
{
IComponentModel componentModel = (IComponentModel)ServiceProvider.GlobalProvider.GetService(typeof(SComponentModel));
if (componentModel != null)
{
IOutliningManagerService outliningManagerService = componentModel.GetService <IOutliningManagerService>();
_editorAdaptersFactoryService = componentModel.GetService <IVsEditorAdaptersFactoryService>();
if (outliningManagerService != null)
{
if (textViewAdapter != null && _editorAdaptersFactoryService != null)
{
var textView = _editorAdaptersFactoryService.GetWpfTextView(textViewAdapter);
var snapshot = textView.TextSnapshot;
var snapshotSpan = new Microsoft.VisualStudio.Text.SnapshotSpan(snapshot, new Microsoft.VisualStudio.Text.Span(0, snapshot.Length));
_outliningManager = outliningManagerService.GetOutliningManager(textView);
var regions = _outliningManager.GetAllRegions(snapshotSpan);
foreach (var reg in regions)
{
_outliningManager.TryCollapse(reg);
}
}
}
}
}
public void TextViewCreated(IWpfTextView textView)
{
var generalOptions = Setting.getGeneralOptions(_serviceProvider);
if (generalOptions == null || !generalOptions.OutliningEnabled)
{
return;
}
var textBuffer = textView.TextBuffer;
var outliningTagger = CreateTagger <IOutliningRegionTag>(textBuffer);
bool isFirstOutlining = true;
outliningTagger.TagsChanged += (sender, e) =>
{
if (isFirstOutlining)
{
var fullSpan = new SnapshotSpan(textView.TextSnapshot, 0, textView.TextSnapshot.Length);
// Ensure that first tags have been computed.
var tags = outliningTagger.GetTags(new NormalizedSnapshotSpanCollection(fullSpan));
var outliningManager = _outliningManagerService.GetOutliningManager(textView);
// Keep the outlining manager in the lifetime of the text view.
// This prevents the outlining manager being disposed while it should still be used.
textView.Properties.GetOrCreateSingletonProperty(() => outliningManager);
if (outliningManager != null)
{
outliningManager.CollapseAll(fullSpan, match: c => c.Tag.IsDefaultCollapsed);
}
isFirstOutlining = false;
}
};
}
public void TextViewCreated(IWpfTextView textView)
{
var generalOptions = Setting.getGeneralOptions(_serviceProvider);
if (generalOptions == null || !generalOptions.OutliningEnabled)
{
return;
}
var textBuffer = textView.TextBuffer;
var outliningTagger = CreateTagger <IOutliningRegionTag>(textBuffer);
bool isFirstOutlining = true;
outliningTagger.TagsChanged += (sender, e) =>
{
if (isFirstOutlining)
{
// Try to collapse tags once at view opening
isFirstOutlining = false;
var outliningManager = textView.Properties.GetOrCreateSingletonProperty(
() => _outliningManagerService.GetOutliningManager(textView));
if (outliningManager != null)
{
var fullSpan = new SnapshotSpan(textBuffer.CurrentSnapshot, 0, textBuffer.CurrentSnapshot.Length);
outliningManager.CollapseAll(fullSpan, match: c => c.Tag.IsDefaultCollapsed);
}
}
};
}
public static bool TryMoveCaretToAndEnsureVisible(this ITextView textView, VirtualSnapshotPoint point, IOutliningManagerService outliningManagerService = null, EnsureSpanVisibleOptions ensureSpanVisibleOptions = EnsureSpanVisibleOptions.None)
{
if (textView.IsClosed)
{
return(false);
}
var pointInView = textView.GetPositionInView(point.Position);
if (!pointInView.HasValue)
{
return(false);
}
// If we were given an outlining service, we need to expand any outlines first, or else
// the Caret.MoveTo won't land in the correct location if our target is inside a
// collapsed outline.
var outliningManager = outliningManagerService?.GetOutliningManager(textView);
outliningManager?.ExpandAll(new SnapshotSpan(pointInView.Value, length: 0), match: _ => true);
var newPosition = textView.Caret.MoveTo(new VirtualSnapshotPoint(pointInView.Value, point.VirtualSpaces));
// We use the caret's position in the view's current snapshot here in case something
// changed text in response to a caret move (e.g. line commit)
var spanInView = new SnapshotSpan(newPosition.BufferPosition, 0);
textView.ViewScroller.EnsureSpanVisible(spanInView, ensureSpanVisibleOptions);
return(true);
}
public FoldingManagerAdapter(
IWpfTextView textView,
IOutliningManagerService outliningManagerService)
{
_outliningManager = outliningManagerService.GetOutliningManager(textView);
_outliningManager.RegionsExpanded += OnExpanded;
_outliningManager.RegionsCollapsed += OnCollapsed;
}
public static IOutliningManager GetOutliningManager(IOutliningManagerService outliningManagerService, ITextView textView)
{
if (outliningManagerService == null)
{
return(null);
}
return(outliningManagerService.GetOutliningManager(textView));
}
private DiagnosticInfosViewModel CreateSut()
{
A.CallTo(() => _outliningManagerService.GetOutliningManager(_wpfTextView)).Returns(_outliningManager);
A.CallTo(() => _textView.TextView).Returns(_wpfTextView);
return(new DiagnosticInfosViewModel(
_textView,
_diagnosticsProvider,
_outliningManagerService,
_adornmentSpaceReservation));
}
public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText)
{
if (pguidCmdGroup == VSConstants.VSStd2K)
{
for (var i = 0; i < cCmds; i++)
{
switch ((VSConstants.VSStd2KCmdID)prgCmds[i].cmdID)
{
case VSConstants.VSStd2KCmdID.OUTLN_START_AUTOHIDING:
var outliningManager = _outliningManagerService.GetOutliningManager(_textView);
if (outliningManager != null && !outliningManager.Enabled)
{
prgCmds[i].cmdf = (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED);
}
return(VSConstants.S_OK);
}
}
}
return(_nextCommandTarget.QueryStatus(ref pguidCmdGroup, cCmds, prgCmds, pCmdText));
}
public CommandState GetCommandState(StartAutomaticOutliningCommandArgs args)
{
var outliningManager = _outliningManagerService.GetOutliningManager(args.TextView);
var enabled = false;
if (outliningManager != null)
{
enabled = outliningManager.Enabled;
}
return(new CommandState(isAvailable: !enabled));
}
void ExpandCollapsedRegions(ITextView textView, SnapshotSpan span)
{
var outlining = outliningService.GetOutliningManager(textView);
if (outlining != null)
{
foreach (var collapsed in outlining.GetCollapsedRegions(span))
{
outlining.Expand(collapsed);
}
}
}
private RegionTextViewHandler(IWpfTextView textView, IOutliningManagerService outliningManagerService)
{
_outliningManager = outliningManagerService.GetOutliningManager(textView);
if (_outliningManager == null)
{
return;
}
_textView = textView;
_outliningManager.RegionsCollapsed += OnRegionsCollapsed;
_textView.Closed += OnClosed;
}
public async Task R_OutlineToggleAll()
{
string text = _files.LoadDestinationFile("lsfit.r");
using (var script = await _editorHost.StartScript(_exportProvider, text, "filename", RContentTypeDefinition.ContentType, null)) {
script.DoIdle(500);
IOutliningManagerService svc = _exportProvider.GetExportedValue <IOutliningManagerService>();
IOutliningManager mgr = svc.GetOutliningManager(script.View);
var snapshot = script.TextBuffer.CurrentSnapshot;
var viewLines = script.View.TextViewLines;
viewLines.Count.Should().Be(22);
script.DoIdle(500);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_ALL);
script.DoIdle(1000);
IEnumerable <ICollapsed> collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(20);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_ALL);
script.DoIdle(500);
viewLines = script.View.TextViewLines;
viewLines.Count.Should().Be(22);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_STOP_HIDING_ALL);
script.DoIdle(200);
mgr.Enabled.Should().Be(false);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_START_AUTOHIDING);
script.DoIdle(200);
mgr.Enabled.Should().Be(true);
script.MoveDown(9);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_CURRENT);
script.DoIdle(500);
collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(1);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_CURRENT);
script.DoIdle(200);
collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(0);
}
}
public void R_OutlineToggleAll()
{
string text = _files.LoadDestinationFile("lsfit.r");
using (var script = new TestScript(text, RContentTypeDefinition.ContentType)) {
script.DoIdle(500);
IOutliningManagerService svc = EditorShell.Current.ExportProvider.GetExportedValue <IOutliningManagerService>();
IOutliningManager mgr = svc.GetOutliningManager(EditorWindow.CoreEditor.View);
var snapshot = EditorWindow.TextBuffer.CurrentSnapshot;
var viewLines = EditorWindow.CoreEditor.View.TextViewLines;
viewLines.Count.Should().Be(40);
script.DoIdle(500);
EditorWindow.ExecCommand(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_ALL);
script.DoIdle(1000);
IEnumerable <ICollapsed> collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(20);
EditorWindow.ExecCommand(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_ALL);
script.DoIdle(500);
viewLines = EditorWindow.CoreEditor.View.TextViewLines;
viewLines.Count.Should().Be(40);
EditorWindow.ExecCommand(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_STOP_HIDING_ALL);
script.DoIdle(200);
mgr.Enabled.Should().Be(false);
EditorWindow.ExecCommand(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_START_AUTOHIDING);
script.DoIdle(200);
mgr.Enabled.Should().Be(true);
script.MoveDown(9);
EditorWindow.ExecCommand(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_CURRENT);
script.DoIdle(500);
collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(1);
EditorWindow.ExecCommand(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_CURRENT);
script.DoIdle(200);
collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(0);
}
}
/// <inheritdoc />
public int GetComputedLineNumber(int absoluteLineNumber)
{
try
{
// a line could not get any further than 0 even by collapsing regions
if (absoluteLineNumber == 0)
{
return(0);
}
// if no snapshot line found return 0
var lineSnapshot = _textView.GetSnapshotForLineNumber(absoluteLineNumber);
if (lineSnapshot == null)
{
return(0);
}
// if no collapsed region than line number fits as normal
var outliningManager = _outliningManagerService.GetOutliningManager(_textView);
var snapshotSpan = lineSnapshot.Extent;
var region = outliningManager?.GetCollapsedRegions(snapshotSpan) ?? Enumerable.Empty <ICollapsible>();
if (!region.Any())
{
return(absoluteLineNumber);
}
// I assume that the longest collapsed region is the outermost
var regionSnapshot = region
.Select(x => x.Extent.GetSpan(_textView.TextSnapshot))
.ToDictionary(x => x.Length)
.OrderByDescending(x => x.Key)
.First()
.Value;
var collapsedLineNumber = _textView.TextSnapshot.GetLineNumberFromPosition(regionSnapshot.End.Position);
return(collapsedLineNumber);
}
catch (ObjectDisposedException ex)
{
if (ex.ObjectName == "OutliningMnger")
{
// TODO: when we have a logger service add logging
}
// I assume that this case seems to happen, if the TextView gets closed and we receive a
// DiagnosticChanged event right in the time frame before we dispose the whole container graph.
return(absoluteLineNumber);
}
}
/// <summary>
/// Attempts to get the outlining manager associated with the specified document.
/// </summary>
/// <param name="document">The document.</param>
/// <returns>The associated outlining manager, otherwise null.</returns>
private IOutliningManager GetOutliningManager(Document document)
{
try
{
_wpfTextView = GetWpfTextView(document);
if (_wpfTextView != null && _outliningManagerService != null)
{
return(_outliningManagerService.GetOutliningManager(_wpfTextView));
}
}
catch (Exception ex)
{
OutputWindowHelper.ExceptionWriteLine($"Unable to retrieve an outlining manager for '{document.FullName}'", ex);
}
return(null);
}
internal static IOutliningManager GetOutliningManager(this IServiceProvider serviceProvider, ITextView textView)
{
if (serviceProvider == null || textView == null)
{
return(null);
}
IComponentModel componentModel = serviceProvider.GetService <SComponentModel, IComponentModel>();
IOutliningManagerService outliningManagerService = componentModel?.GetService <IOutliningManagerService>();
if (outliningManagerService == null)
{
return(null);
}
return(outliningManagerService.GetOutliningManager(textView));
}
internal static async Task <IOutliningManager> GetOutliningManagerAsync(this Shell.IAsyncServiceProvider serviceProvider, ITextView textView)
{
if (serviceProvider == null || textView == null)
{
return(null);
}
IComponentModel componentModel = await serviceProvider.GetServiceAsync <SComponentModel, IComponentModel>();
IOutliningManagerService outliningManagerService = componentModel?.GetService <IOutliningManagerService>();
if (outliningManagerService == null)
{
return(null);
}
return(outliningManagerService.GetOutliningManager(textView));
}
/// <summary>
/// Initializes a new instance of the <see cref="DiagnosticInfosViewModel"/> class.
/// </summary>
/// <param name="textView">The <see cref="IQualityTextView"/>.</param>
/// <param name="diagnosticProvider">The <see cref="IDiagnosticProvider"/>.</param>
/// <param name="outliningManagerService">THe <see cref="IOutliningManagerService"/> for the <paramref name="textView"/>.</param>
/// <param name="adornmentSpaceReservation">The <see cref="IAdornmentSpaceReservation"/>.</param>
public DiagnosticInfosViewModel(
IQualityTextView textView,
IDiagnosticProvider diagnosticProvider,
IOutliningManagerService outliningManagerService,
IAdornmentSpaceReservation adornmentSpaceReservation)
{
_diagnosticProvider = diagnosticProvider ?? throw new ArgumentNullException(nameof(diagnosticProvider));
TextView = textView ?? throw new ArgumentNullException(nameof(textView));
AdornmentSpaceReservation = adornmentSpaceReservation ?? throw new ArgumentNullException(nameof(adornmentSpaceReservation));
OutliningManager = outliningManagerService.GetOutliningManager(TextView.TextView);
WeakEventManager <IDiagnosticProvider, DiagnosticsChangedEventArgs> .AddHandler(_diagnosticProvider, nameof(IDiagnosticProvider.DiagnosticsChanged), OnDiagnosticsChanged);
OutliningManager.RegionsExpanded += OnRegionsExpanded;
OutliningManager.RegionsCollapsed += OnRegionsCollapsed;
OnDiagnosticsChanged(this, new DiagnosticsChangedEventArgs(_diagnosticProvider.CurrentDiagnostics));
}
public ITagger <T> CreateTagger <T>(ITextView textView, ITextBuffer buffer) where T : ITag
{
//provide highlighting only on the top buffer
if (textView.TextBuffer != buffer)
{
return(null);
}
var wpfView = textView as IWpfTextView;
if (wpfView != null)
{
var outMgr = OutliningManagerService.GetOutliningManager(textView);
Func <Navigation.Navigator> createHandler = () => { return(new Navigation.Navigator(wpfView, outMgr)); };
wpfView.Properties.GetOrCreateSingletonProperty(createHandler);
}
return(new BraceHighlightTagger(textView, buffer) as ITagger <T>);
}
/// <summary>
/// Initializes a new instance of the <see cref="Selector"/> class.
/// </summary>
/// <param name="view"></param>
/// <param name="textSearchService"></param>
/// <param name="editorOperationsService"></param>
/// <param name="textStructureNavigator"></param>
/// <param name="outliningManagerService"></param>
public Selector(
IWpfTextView view,
ITextSearchService textSearchService,
IEditorOperationsFactoryService editorOperationsService,
ITextStructureNavigator textStructureNavigator,
IOutliningManagerService outliningManagerService)
{
this.view = view;
// Services
this.textSearchService = textSearchService;
this.EditorOperations = editorOperationsService.GetEditorOperations(this.view);
this.textStructureNavigator = textStructureNavigator;
this.outliningManager = outliningManagerService?.GetOutliningManager(this.view);
this.Dte = ServiceProvider.GlobalProvider.GetService(typeof(DTE)) as DTE2;
this.Selections = new List <Selection>();
this.historyManager = new HistoryManager();
}
private void SelectSpan(ITextView textView, SnapshotSpan snapshotSpan)
{
var source = textView.BufferGraph.MapUpToSnapshot(snapshotSpan, SpanTrackingMode.EdgeExclusive,
textView.TextSnapshot);
var span = source.First <SnapshotSpan>();
if (_outliningManagerService != null)
{
var outliningManager = _outliningManagerService.GetOutliningManager(textView);
if (outliningManager != null)
{
outliningManager.ExpandAll(span, (_) => true);
}
}
var virtualSnapshotSpan = new VirtualSnapshotSpan(span);
_editorOperationsFactory.GetEditorOperations(textView).SelectAndMoveCaret(
virtualSnapshotSpan.Start, virtualSnapshotSpan.End,
TextSelectionMode.Stream, EnsureSpanVisibleOptions.AlwaysCenter);
}
/// <summary>
/// Initializes a new instance of the <see cref="Selector"/> class.
/// </summary>
/// <param name="view"></param>
/// <param name="textSearchService"></param>
/// <param name="IEditorOperationsFactoryService"></param>
/// <param name="IEditorFormatMapService"></param>
/// <param name="ITextStructureNavigator"></param>
/// <param name="IOutliningManagerService"></param>
public Selector(
IWpfTextView view,
ITextSearchService textSearchService,
IEditorOperationsFactoryService editorOperationsService,
IEditorFormatMapService formatMapService = null,
ITextStructureNavigator textStructureNavigator = null,
IOutliningManagerService outliningManagerService = null
)
{
this.view = view;
// Services
this.textSearchService = textSearchService ?? throw new ArgumentNullException("textSearchService");
this.editorOperations = editorOperationsService.GetEditorOperations(this.view);
this.textStructureNavigator = textStructureNavigator;
this.outliningManager = outliningManagerService?.GetOutliningManager(this.view);
this.Dte = ServiceProvider.GlobalProvider.GetService(typeof(DTE)) as DTE2;
this.Selections = new List <Selection>();
}
/// <summary>
/// An event handler raised when a code item parent's expanded state has changed.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="eventArgs">The event arguments.</param>
private static void OnIsExpandedChanged(object sender, EventArgs eventArgs)
{
var item = sender as IMembers;
if (item != null)
{
var iCollapsible = FindCollapsibleFromCodeItem((CodeItem)item, _outliningManagerService, _textView);
if (iCollapsible != null)
{
var outliningManager = _outliningManagerService.GetOutliningManager(_textView);
if (item.IsExpanded && iCollapsible.IsCollapsed)
{
outliningManager.Expand(iCollapsible as ICollapsed);
}
else if (!item.IsExpanded && !iCollapsible.IsCollapsed)
{
outliningManager.TryCollapse(iCollapsible);
}
}
}
}
public void TextViewCreated(IWpfTextView textView)
{
var generalOptions = Setting.getGeneralOptions(_serviceProvider);
if (generalOptions == null || !generalOptions.OutliningEnabled) return;
var textBuffer = textView.TextBuffer;
var outliningTagger = CreateTagger<IOutliningRegionTag>(textBuffer);
bool isFirstOutlining = true;
outliningTagger.TagsChanged += (sender, e) =>
{
if (isFirstOutlining)
{
var fullSpan = new SnapshotSpan(textView.TextSnapshot, 0, textView.TextSnapshot.Length);
// Ensure that first tags have been computed.
var tags = outliningTagger.GetTags(new NormalizedSnapshotSpanCollection(fullSpan));
var outliningManager = _outliningManagerService.GetOutliningManager(textView);
if (outliningManager != null)
{
outliningManager.CollapseAll(fullSpan, match: c => c.Tag.IsDefaultCollapsed);
}
isFirstOutlining = false;
}
};
}
#pragma warning disable CS0649
public void TextViewCreated(IWpfTextView wpfTextView)
{
ThreadHelper.ThrowIfNotOnUIThread();
textView = wpfTextView;
settings = new Settings();
settings.LoadFromStore();
textView.Closed += OnClosed;
outliningManager = outliningManagerService.GetOutliningManager(textView);
if (settings.BehaviorMode != BehaviorMode.DoNothing)
{
outliningManager.RegionsChanged += OutliningManagerOnRegionsChanged;
}
if (settings.BehaviorMode == BehaviorMode.PreventCollapse)
{
outliningManager.RegionsCollapsed += OnRegionsCollapsed;
}
TinyMessageBroker.Instance.Subscribe(this);
}
public void TextViewCreated(IWpfTextView textView)
{
RegionExpander.Register(textView, _outliningManagerService.GetOutliningManager(textView));
}
/// <summary>
/// When a new text view is created, hook up the various "trackers" (<see cref="TextViewTracker"/>, <see cref="InheritanceTracker"/>, <see cref="QuickInfoTracker"/>).
/// </summary>
/// <param name="textView"></param>
public void TextViewCreated(IWpfTextView textView)
{
Contract.Assume(textView != null);
if (VSServiceProvider.Current == null || VSServiceProvider.Current.ExtensionHasFailed)
{
//If the VSServiceProvider is not initialize, we can't do anything.
return;
}
VSServiceProvider.Current.Logger.PublicEntry(() => {
#region Check if textView is valid
var fileName = textView.GetFileName();
if (fileName == null)
{
VSServiceProvider.Current.Logger.WriteToLog("Couldn't retrieve file name for current view.");
return;
}
if (!File.Exists(fileName))
{
VSServiceProvider.Current.Logger.WriteToLog("Couldn't find file for current view.");
return;
}
#endregion
VSServiceProvider.Current.Logger.WriteToLog("Text view found: " + fileName);
#region Check if textView is a CSharp file
var IsCSharpFile = Path.GetExtension(fileName) == ".cs";
#endregion
#region Get text view properties
var vsTextProperties = VSTextPropertiesProvider.GetVSTextProperties(textView);
#endregion
var vsProject = VSServiceProvider.Current.GetProjectForFile(fileName);//May be null!
ProjectTracker projectTracker = null;
if (vsProject != null)
{
projectTracker = ProjectTracker.GetOrCreateProjectTracker(vsProject);
if (projectTracker != null)
{
textView.Properties.AddProperty(typeof(ProjectTracker), projectTracker);
}
else
{
VSServiceProvider.Current.Logger.WriteToLog("Warning: Couldn't create a 'ProjectTracker', we won't be able to show inheritance contract information for this text view. Close and reopen the text view to try again!");
}
}
#region Check if textView is an editable code file
var IsEditableCodeFile = /*IsCSharpFile &&*/ textView.Roles.Contains("editable") && projectTracker != null; //TODO: We need a stronger check to see if it is a editable code file
#endregion
if (IsEditableCodeFile)
{
textView.GotAggregateFocus += NewFocus;
var textViewTracker = TextViewTracker.GetOrCreateTextViewTracker(textView, projectTracker, vsTextProperties);
//if (VSServiceProvider.Current.VSOptionsPage != null && (VSServiceProvider.Current.VSOptionsPage.InheritanceOnMethods || VSServiceProvider.Current.VSOptionsPage.InheritanceOnProperties)) {
// //var inheritanceAdornmentManager = AdornmentManager.GetOrCreateAdornmentManager(textView, "InheritanceAdornments", outliningManager, VSServiceProvider.Current.Logger);
// //var inheritanceTracker = InheritanceTracker.GetOrCreateAdornmentTracker(textViewTracker);
//}
//var quickInfoTracker = QuickInfoTracker.GetOrCreateQuickInfoTracker(textViewTracker); //Disabled for now, unfinished
}
#region Check if textView is a metadata file
var IsMetadataFile = !IsEditableCodeFile && fileName.Contains('$'); //TODO: We need a strong check to see if it is a metadata file
#endregion
if (IsMetadataFile)
{
if (lastFocus == null || !lastFocus.Properties.ContainsProperty(typeof(ProjectTracker)))
{
VSServiceProvider.Current.Logger.WriteToLog("Couldn't find project for metadata file.");
}
else
{
var outliningManager = OutliningManagerService.GetOutliningManager(textView);
if (outliningManager == null)
{
VSServiceProvider.Current.Logger.WriteToLog("Couldn't get outlining manager for current view.");
return;
}
projectTracker = lastFocus.Properties.GetProperty <ProjectTracker>(typeof(ProjectTracker));
textView.Properties.AddProperty(typeof(ProjectTracker), projectTracker);
textView.GotAggregateFocus += NewFocus;
if (VSServiceProvider.Current.VSOptionsPage != null && VSServiceProvider.Current.VSOptionsPage.Metadata)
{
var metadataAdornmentManager = AdornmentManager.GetOrCreateAdornmentManager(textView, "MetadataAdornments", outliningManager, VSServiceProvider.Current.Logger);
var metadataTracker = MetadataTracker.GetOrCreateMetadataTracker(textView, projectTracker, vsTextProperties);
}
}
}
}, "TextViewCreated");
}
private void ExpandSpan(ITextView textView, SnapshotSpan snapshotSpan)
{
var outliningManager = outliningManagerService.GetOutliningManager(textView);
outliningManager?.ExpandAll(snapshotSpan, _ => true);
}