public async Task RunAsync(bool isDryRun) { try { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(_package.DisposalToken); var toolWindow = (BenchmarkTreeWindow)_package.FindToolWindow(typeof(BenchmarkTreeWindow), 0, false); BenchmarkTreeNode selectedNode = toolWindow.SelectedItem; var dte2 = (DTE2)Package.GetGlobalService(typeof(SDTE)); EnvDTE.Project project = GetProject(dte2, selectedNode.ProjectName); if (project == null) { return; } var propertyProvider = await CreateProjectPropertyProviderAsync(project.Name); try { if (!propertyProvider.IsOptimized) { await UIHelper.ShowErrorAsync(_package, "The current build configuration does not have the \"Optimize code\" flag set and is therefore not suitable for running Benchmarks.\r\n\r\nPlease enable the the \"Optimize code\" flag (under Project Properties -> Build) or switch to a non-debug configuration (e.g. 'Release') before running a Benchmark."); return; } } catch (Exception) { } string configurationName = project.ConfigurationManager.ActiveConfiguration.ConfigurationName; dte2.Solution.SolutionBuild.BuildProject(configurationName, project.UniqueName, true); if (dte2.Solution.SolutionBuild.LastBuildInfo != 0) { return; } var runParameters = new RunParameters { OutputPath = propertyProvider.OutputPath, ProjectPath = propertyProvider.ProjectPath, Runtime = propertyProvider.TargetRuntime, AssemblyPath = propertyProvider.GetOutputFilename(), IsDryRun = isDryRun, SelectedNode = selectedNode }; BenchmarkRunController runController = new BenchmarkRunController(runParameters, GetOptions()); await runController.RunAsync(); } catch (Exception ex) { await UIHelper.ShowErrorAsync(_package, ex.Message); } }
private async void Execute(object sender, EventArgs e) { CodeEvaluationDTO codeEvaluation; try { codeEvaluation = await _service.AnalyzeCodeAsync(_selectedFilePath); } catch (Exception exception) { Debug.WriteLine(exception); return; } ToolWindowPane window = _package.FindToolWindow(typeof(CodeAnalysisWindow), 0, true); if (window?.Frame == null) { throw new NotSupportedException("Cannot create tool window"); } var codeAnalysisWindow = window as CodeAnalysisWindow; codeAnalysisWindow?.UpdateVmContent(codeEvaluation); IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
private void Execute(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); var window = (FunctionListWindow)package.FindToolWindow(typeof(FunctionListWindow), 0, true); Execute(window); }
private void interfaceClassMapping(SchemaInfo schemaInfo, ClassInfo[] classInfos, Action <CodeClass[]> callbackOption) { ThreadHelper.ThrowIfNotOnUIThread("interfaceClassMapping"); logger.Info("interfaceClassMapping called"); ToolWindowPane toolWindowPane = package.FindToolWindow(typeof(InterfaceMapperWithClass), 0, create: true); if (toolWindowPane == null || toolWindowPane.Frame == null) { throw new NotSupportedException("Cannot create tool window"); } interfaceMapperWithClassControl = (toolWindowPane.Content as InterfaceMapperWithClassControl); windowFrame = (IVsWindowFrame)toolWindowPane.Frame; toolWindowPane.Caption = "Interface Class Mapper"; ErrorHandler.ThrowOnFailure(windowFrame.Show()); interfaceMapperWithClassControl.SetInterfaceMapperWithClassControlInput(new InterfaceMapperWithClassControlInput { ClassInfos = classInfos, ProjectNames = ClassFinder.FindProjects(dte.Solution), GetClasses = ((Project project) => ClassFinder.FindProjectClass(project)), GetRefClasses = ((Project project) => ClassFinder.FindProjectReferance(project)), CallbackOption = callbackOption, SchemaInfoCommon = schemaInfoCommon, Close = () => { ThreadHelper.ThrowIfNotOnUIThread("interfaceClassMapping"); ErrorHandler.ThrowOnFailure(windowFrame.Hide()); }, ClearCache = () => { ClassFinder.ClearCache(); }, LastRunFound = File.Exists(schemaInfo.FullMethodBasedUniqueName), CallbackLastRunOption = () => { var tempSchemaInfo = Json.Decode <SchemaInfo>(File.ReadAllText(schemaInfo.FullMethodBasedUniqueName)); fileCopyAndDebug(tempSchemaInfo); } }); }
private static void ShowToolWindow(AsyncPackage package) { ToolWindowPane window = package.FindToolWindow(typeof(RenameModalWindow), 0, true); if ((null == window) || (null == window.Frame)) { throw new NotSupportedException("Cannot create tool window"); } ThreadHelper.ThrowIfNotOnUIThread(); IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
private void Execute(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); var window = _package.FindToolWindow(typeof(SearchResultsToolWindow), 0, true); if ((null == window) || (null == window.Frame)) { throw new NotSupportedException("Cannot create tool window"); } var windowFrame = (IVsWindowFrame)window.Frame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
private static void ShowToolWindow <T>(object sender, EventArgs e, AsyncPackage package) { ExLogger.LogToFile(Logger, $"{Resource.Message_OpeningToolWindow}: {typeof(T)}", LogLevel.Info); var window = package.FindToolWindow(typeof(T), 0, true); if (window?.Frame == null) { throw new NotSupportedException(Resource.ErrorMessage_CannotCreateToolWindow); } var windowFrame = (IVsWindowFrame)window.Frame; ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
private void Execute(object sender, EventArgs e) { ThrowIfNotOnUIThread(); // Get the instance number 0 of this tool window. This window is // single instance so this instance is actually the only one. The // last flag is set to true so that if the tool window does not // exists it will be created. var window = package.FindToolWindow(typeof(MainWindow), 0, true); Assumes.NotNull(window); Assumes.NotNull(window.Frame); var windowFrame = (IVsWindowFrame)window.Frame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
private void Execute(object sender, EventArgs e) { ToolWindowPane window = _package.FindToolWindow(typeof(ClosedDocumentsHistory), 0, true); if ((null == window) || (null == window.Frame)) { LoggerContext.Current.Logger.Error($"Command failed: {nameof(ShowDocumentsHIstoryCommand)} Cannot create tool window"); throw new NotSupportedException("Cannot create tool window"); } IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show()); LoggerContext.Current.Logger.Info($"VS Command: {nameof(ShowDocumentsHIstoryCommand)} was executed"); }
// This is proper initialization since VS2017. // For details see comment to GetAsyncToolWindowFactory() method. //private static void Execute(AsyncPackage package) //{ // package.JoinableTaskFactory.RunAsync(async () => // { // ToolWindowPane window = await package.ShowToolWindowAsync( // MISSING METHOD IN Microsoft.VisualStudio.Shell.14 in AsyncPackage class. Available since .15 // typeof(PBMWindow), // 0, // create: true, // cancellationToken: package.DisposalToken); // }); //} /// <summary> /// Shows "Parallel Builds Monitor" tool window when "VS -> Menu -> View -> Other Windows -> Parallel Builds Monitor" is clicked. /// </summary> private static void Execute(AsyncPackage package) { // Get the instance number 0 of this tool window. This window is single instance so this instance // is actually the only one. // The last flag is set to true so that if the tool window does not exists it will be created. ToolWindowPane window = package.FindToolWindow(typeof(PBMWindow), 0, true); if ((null == window) || (null == window.Frame)) { throw new NotSupportedException("Cannot create tool window"); } IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
private static ToolWindowPane ShowToolWindow(AsyncPackage package) { // Get the instance number 0 of this tool window. This window is single instance so this instance // is actually the only one. // The last flag is set to true so that if the tool window does not exists it will be created. var window = package.FindToolWindow(typeof(BuildVisionPane), 0, true); if (window == null || window.Frame == null) { throw new InvalidOperationException(Resources.CanNotCreateWindow); } var windowFrame = (IVsWindowFrame)window.Frame; ErrorHandler.ThrowOnFailure(windowFrame.Show()); return(window); }
private void Execute(object sender, EventArgs e) { ToolWindowPane window = _package.FindToolWindow(typeof(ChallengeWindow), 0, true); if (window?.Frame == null) { throw new NotSupportedException("Cannot create tool window"); } var challengeWindow = window as ChallengeWindow; challengeWindow?.UpdateVmContent(_selectedFilePath, _serverUrl); IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
/// <summary> /// Shows the tool window when the menu item is clicked. /// </summary> /// <param name="sender">The event sender.</param> /// <param name="e">The event args.</param> private void ShowToolWindow(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); // Get the instance number 0 of this tool window. This window is single instance so this instance // is actually the only one. // The last flag is set to true so that if the tool window does not exists it will be created. ToolWindowPane window = _Package.FindToolWindow(typeof(SmartTestsWindow), 0, true); if ((null == window) || (null == window.Frame)) { throw new NotSupportedException("Cannot create tool window"); } IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private void Execute(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); // Get the instance number 0 of this tool window. This window is single instance so this instance // is actually the only one. // The last flag is set to true so that if the tool window does not exists it will be created. var window = _package.FindToolWindow(typeof(NullForgivingToolWindow), 0, true); if (window?.Frame == null) { throw new NotSupportedException("Cannot create tool window"); } var windowFrame = (IVsWindowFrame)window.Frame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
public object CreateToolWindowForView(Type viewType, string caption) { IView view = null; Type toolWindowType = null; try { var id = _largestId; _largestId += 1; // this might cause a problem after this instance of VsToolWindowService has constructed its 2,147,483,647th tool window if (viewType == typeof(OutputView) || viewType == typeof(IOutputView)) { toolWindowType = typeof(OutputToolWindow); } ToolWindowPane window = _package.FindToolWindow(toolWindowType, id, create: true); if (window == null || window.Frame == null) { throw new NotSupportedException("Cannot create tool window"); } view = window.Content as IView; window.Caption = caption; // give view a way to display its corresponding tool window view.DisplayView = () => { ThreadHelper.ThrowIfNotOnUIThread(); IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show()); }; return(view); } catch (Exception ex) { _logger.Error("VsToolWindowService tried to open a tool window of type {ViewType} but something went wrong: {ToolWindowDisplayException}", viewType, ex); return(view); } }
private async Task ExecuteAsync() { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var token = await GetTokenAtCaretPositionAsync(); ToolWindowPane window = _package.FindToolWindow(typeof(SearchResultsToolWindow), 0, true); if ((null == window) || (null == window.Frame)) { throw new NotSupportedException("Cannot create tool window"); } var searchResultsToolWindow = window as SearchResultsToolWindow; var searchResultsToolWindowFrame = window.Frame as IVsWindowFrame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(searchResultsToolWindowFrame.Show()); var searchResultsToolWindowControl = searchResultsToolWindow.Content as SearchResultsToolWindowControl; searchResultsToolWindowControl.Search(token.ValueText); }
public static void Prompt <TToolWindow>(AsyncPackage package, object dataContext = null, bool createIfNotExists = true) where TToolWindow : ToolWindowPane { ThreadHelper.ThrowIfNotOnUIThread(); // Get the instance number 0 of this tool window. This window is single instance so this instance // is actually the only one. // The last flag is set to true so that if the tool window does not exists it will be created. ToolWindowPane window = package.FindToolWindow(typeof(TToolWindow), 0, createIfNotExists); if ((window == null) || (window.Frame == null)) { throw new NotSupportedException("Cannot create tool window"); } if (window.Content is UserControl control) { control.DataContext = dataContext; } IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show()); }
private void OnOpenAxoCover(object sender, EventArgs e) { var window = _package.FindToolWindow(typeof(TestExplorerToolWindow), 0, true); (window.Frame as IVsWindowFrame).ShowNoActivate(); }