public void NavigateTo(bool usePreviewPane = true)
{
if (LineMarker != null)
{
LineMarker?.NavigateTo(usePreviewPane);
}
else
{
// The user clicked an inline link with an integer target, which points to
// a Location object that does NOT have a region associated with it.
// Before anything else, see if this is an external link we should open in the browser.
if (Uri.TryCreate(this.FilePath, UriKind.Absolute, out Uri uri))
{
if (!uri.IsFile)
{
System.Diagnostics.Process.Start(uri.OriginalString);
return;
}
}
if (!File.Exists(this.FilePath))
{
CodeAnalysisResultManager.Instance.TryRebaselineAllSarifErrors(RunId, this.UriBaseId, this.FilePath);
}
if (File.Exists(this.FilePath))
{
SdkUIUtilities.OpenDocument(SarifViewerPackage.ServiceProvider, this.FilePath, usePreviewPane);
}
}
}
internal IVsWindowFrame NavigateTo(bool usePreviewPane)
{
// Fall back to the file and line number
if (!File.Exists(this.FullFilePath))
{
if (!CodeAnalysisResultManager.Instance.TryRebaselineAllSarifErrors(this.UriBaseId, this.FullFilePath))
{
return(null);
}
}
IVsWindowFrame windowFrame = SdkUIUtilities.OpenDocument(SarifViewerPackage.ServiceProvider, this.FullFilePath, usePreviewPane);
if (windowFrame != null)
{
IVsTextView textView = GetTextViewFromFrame(windowFrame);
if (textView == null)
{
return(null);
}
var sourceLocation = this.GetSourceLocation();
// Navigate the caret to the desired location. Text span uses 0-based indexes
TextSpan ts;
ts.iEndLine = ts.iStartLine = sourceLocation.StartLine - 1;
ts.iEndIndex = ts.iStartIndex = Math.Max(sourceLocation.StartColumn - 1, 0);
textView.EnsureSpanVisible(ts);
textView.SetSelection(ts.iStartLine, ts.iStartIndex, ts.iEndLine, ts.iEndIndex);
}
return(windowFrame);
}
// This method is called when you click an inline link, with an integer target, which
// points to a Location object that has a region associated with it.
internal IVsWindowFrame NavigateTo(bool usePreviewPane)
{
ThreadHelper.ThrowIfNotOnUIThread();
// Before anything else, see if this is an external link we should open in the browser.
Uri uri;
if (Uri.TryCreate(this.FullFilePath, UriKind.Absolute, out uri))
{
if (!uri.IsFile)
{
System.Diagnostics.Process.Start(uri.OriginalString);
return(null);
}
}
// Fall back to the file and line number
if (!File.Exists(this.FullFilePath))
{
if (!CodeAnalysisResultManager.Instance.TryRebaselineAllSarifErrors(_runId, this.UriBaseId, this.FullFilePath))
{
return(null);
}
}
if (File.Exists(this.FullFilePath) && Uri.TryCreate(this.FullFilePath, UriKind.Absolute, out uri))
{
// Fill out the region's properties
FileRegionsCache regionsCache = CodeAnalysisResultManager.Instance.RunDataCaches[_runId].FileRegionsCache;
Region = regionsCache.PopulateTextRegionProperties(Region, uri, true);
}
IVsWindowFrame windowFrame = SdkUIUtilities.OpenDocument(SarifViewerPackage.ServiceProvider, this.FullFilePath, usePreviewPane);
if (windowFrame != null)
{
IVsTextView textView = GetTextViewFromFrame(windowFrame);
if (textView == null)
{
return(null);
}
var sourceLocation = this.GetSourceLocation();
// Navigate the caret to the desired location. Text span uses 0-based indexes
TextSpan ts;
ts.iStartLine = sourceLocation.StartLine - 1;
ts.iEndLine = sourceLocation.EndLine - 1;
ts.iStartIndex = Math.Max(sourceLocation.StartColumn - 1, 0);
ts.iEndIndex = Math.Max(sourceLocation.EndColumn - 1, 0);
textView.EnsureSpanVisible(ts);
textView.SetSelection(ts.iStartLine, ts.iStartIndex, ts.iEndLine, ts.iEndIndex);
}
return(windowFrame);
}
/// <summary>
/// Attempts to navigate a VS editor to the text marker.
/// </summary>
/// <param name="usePreviewPane">Indicates whether to use VS's preview pane.</param>
/// <param name="moveFocusToCaretLocation">Indicates whether to move focus to the caret location.</param>
/// <returns>Returns true if a VS editor was opened.</returns>
/// <remarks>
/// The <paramref name="usePreviewPane"/> indicates whether Visual Studio opens the document as a preview (tab to the right)
/// rather than as an "open code editor" (tab attached to other open documents on the left).
/// </remarks>
public bool NavigateTo(bool usePreviewPane, bool moveFocusToCaretLocation)
{
ThreadHelper.ThrowIfNotOnUIThread();
bool documentWasOpened = false;
// Make sure to fully populate region.
if (!this.TryToFullyPopulateRegionAndFilePath())
{
return(false);
}
// If the tag doesn't have a persistent span, or its associated document isn't open,
// then this indicates that we need to attempt to open the document and cause it to
// be tagged.
if (!this.PersistentSpanValid())
{
// Now, we need to make sure the document gets tagged before the next section of code
// in this method attempts to navigate to it.
// So the flow looks like this. Get Visual Studio to open the document for us.
// That will cause Visual Studio to create a text view for it.
// Now, just because a text view is created does not mean that
// a request for "tags" has occurred. Tagging (and the display of those tags)
// is highly asynchronous. Taggers are created on demand and disposed when they are no longer
// needed. It is quite common to have multiple taggers active for the same text view and text buffers
// at the same time. (An easy example is a split-window scenario).
// This class relies on a persistent span (this.persistentSpan) being non-null and valid.
// This class "creates" the persistent span when it is asked for its tags in the GetTags
// method.
// To facilitate that, we will:
// 1) Open the document
// 2) Get the text view from the document.
// 2a) That alone may be enough to make the persistent span valid if it was already created.
// 3) If the persistent span still isn't valid (likely because we have crated the persistent span yet), ask ourselves for the tags which will
// cause the span to be created.
IVsWindowFrame vsWindowFrame = SdkUIUtilities.OpenDocument(ServiceProvider.GlobalProvider, this.resolvedFullFilePath, usePreviewPane);
if (vsWindowFrame == null)
{
return(false);
}
vsWindowFrame.Show();
documentWasOpened = true;
// At this point, the persistent span may have "become valid" due to the document open.
// If not, then ask ourselves for the tags which will create the persistent span.
if (!this.PersistentSpanValid())
{
if (!SdkUIUtilities.TryGetTextViewFromFrame(vsWindowFrame, out ITextView textView))
{
return(false);
}
var componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel));
if (componentModel == null)
{
return(false);
}
IPersistentSpanFactory persistentSpanFactory = componentModel.GetService <IPersistentSpanFactory>();
if (persistentSpanFactory == null)
{
return(false);
}
if (!this.TryCreatePersistentSpan(textView.TextBuffer, persistentSpanFactory))
{
return(false);
}
}
}
if (!this.PersistentSpanValid())
{
return(false);
}
// Now, if the span IS valid it doesn't mean that the editor is visible, so make sure we open the document
// for the user if needed.
// But before we try to call "open document" let's see if we can find an active view because calling
// "open document" is super slow (which causes keyboard navigation from items in the SARIF explorer to be slow
// IF "open document" is called every time.
if (!documentWasOpened ||
!SdkUIUtilities.TryGetActiveViewForTextBuffer(this.persistentSpan.Span.TextBuffer, out IWpfTextView wpfTextView))
{
IVsWindowFrame vsWindowFrame = SdkUIUtilities.OpenDocument(ServiceProvider.GlobalProvider, this.resolvedFullFilePath, usePreviewPane);
if (vsWindowFrame == null)
{
return(false);
}
vsWindowFrame.Show();
if (!SdkUIUtilities.TryGetActiveViewForTextBuffer(this.persistentSpan.Span.TextBuffer, out wpfTextView))
{
return(false);
}
}
ITextSnapshot currentSnapshot = this.persistentSpan.Span.TextBuffer.CurrentSnapshot;
// Note that "GetSpan" is not really a great name. What is actually happening
// is the "Span" that "GetSpan" is called on is "mapped" onto the passed in
// text snapshot. In essence what this means is take the "persistent span"
// that we have and "replay" any edits that have occurred and return a new
// span. So, if the span is no longer relevant (lets say the text has been deleted)
// then you'll get back an empty span.
SnapshotSpan trackingSpanSnapshot = this.persistentSpan.Span.GetSpan(currentSnapshot);
// If the caret is already in the text within the marker, don't re-select it
// otherwise users cannot move the caret in the region.
// If the caret isn't in the marker, move it there.
if (!trackingSpanSnapshot.Contains(wpfTextView.Caret.Position.BufferPosition) &&
!trackingSpanSnapshot.IsEmpty)
{
wpfTextView.Selection.Select(trackingSpanSnapshot, isReversed: false);
wpfTextView.Caret.MoveTo(trackingSpanSnapshot.End);
wpfTextView.Caret.EnsureVisible();
if (moveFocusToCaretLocation)
{
wpfTextView.VisualElement.Focus();
}
}
return(true);
}
