private ThreadedWaitDialogHelper.Session StartWaitDialog(string waitMessage, int delayToShowDialogMs) { var dialogFactory = _shell.GlobalServices.GetService <IVsThreadedWaitDialogFactory>(typeof(SVsThreadedWaitDialogFactory)); var initialProgress = new ThreadedWaitDialogProgressData(waitMessage, isCancelable: true); return(dialogFactory.StartWaitDialog(null, initialProgress, TimeSpan.FromMilliseconds(delayToShowDialogMs))); }
/// <summary> /// This event could be raised from multiple threads. Only perform thread-safe operations /// </summary> private void PackageRestoreManager_PackageRestored(object sender, PackageRestoredEventArgs args) { if (Token.IsCancellationRequested) { _canceled = true; return; } if (args.Restored) { var packageIdentity = args.Package; Interlocked.Increment(ref CurrentCount); ThreadHelper.JoinableTaskFactory.RunAsync(async delegate { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var progressData = new ThreadedWaitDialogProgressData(string.Format(CultureInfo.CurrentCulture, Resources.RestoredPackage, packageIdentity), string.Empty, string.Empty, isCancelable: true, currentStep: CurrentCount, totalSteps: TotalCount); ThreadedWaitDialogProgress.Report(progressData); }); } }
private void LogToVS(VerbosityLevel verbosityLevel, string message) { if (Token.IsCancellationRequested) { // If an operation is canceled, don't log anything, simply return // And, show a single message gets shown in the summary that package restore has been canceled // Do not report it as separate errors _canceled = true; return; } // If the verbosity level of message is worse than VerbosityLevel.Normal, that is, // VerbosityLevel.Detailed or VerbosityLevel.Diagnostic, AND, // _msBuildOutputVerbosity is lesser than verbosityLevel; do nothing if (verbosityLevel > VerbosityLevel.Normal && _msBuildOutputVerbosity < (int)verbosityLevel) { return; } ThreadHelper.JoinableTaskFactory.Run(async delegate { // Switch to main thread to update the progress dialog, output window or error list window await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); // Only show messages with VerbosityLevel.Normal. That is, info messages only. // Do not show errors, warnings, verbose or debug messages on the progress dialog // Avoid showing indented messages, these are typically not useful for the progress dialog since // they are missing the context of the parent text above it if (verbosityLevel == VerbosityLevel.Normal && message.Length == message.TrimStart().Length) { // When both currentStep and totalSteps are 0, we get a marquee on the dialog var progressData = new ThreadedWaitDialogProgressData(message, string.Empty, string.Empty, isCancelable: true, currentStep: 0, totalSteps: 0); // Update the progress dialog ThreadedWaitDialogProgress.Report(progressData); } // Write to the output window. Based on _msBuildOutputVerbosity, the message may or may not // get shown on the output window. Default is VerbosityLevel.Minimal WriteLine(verbosityLevel, message); // VerbosityLevel.Quiet corresponds to ILogger.LogError, and, // VerbosityLevel.Minimal corresponds to ILogger.LogWarning // In these 2 cases, we add an error or warning to the error list window if (verbosityLevel == VerbosityLevel.Quiet || verbosityLevel == VerbosityLevel.Minimal) { MessageHelper.ShowError(_errorListProvider, verbosityLevel == VerbosityLevel.Quiet ? TaskErrorCategory.Error : TaskErrorCategory.Warning, TaskPriority.High, message, hierarchyItem: null); } }); }
public async Task <IWaitDialog> CreateAsync(string title, ThreadedWaitDialogProgressData progress) { IVsThreadedWaitDialogFactory waitDialogFactory; await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); waitDialogFactory = (IVsThreadedWaitDialogFactory)await VS.Services.GetThreadedWaitDialogAsync(); return(new Dialog(waitDialogFactory.StartWaitDialog(title, progress))); }
public IModalProgressDialogSession StartModalProgressDialog(string caption, ProgressDialogData initialData, INuGetUI uiService) { var waitForDialogFactory = (IVsThreadedWaitDialogFactory)Package.GetGlobalService(typeof(SVsThreadedWaitDialogFactory)); var progressData = new ThreadedWaitDialogProgressData( initialData.WaitMessage, initialData.ProgressText, null, initialData.IsCancelable, initialData.CurrentStep, initialData.TotalSteps); var session = waitForDialogFactory.StartWaitDialog(caption, progressData); return(new VisualStudioProgressDialogSession(session)); }
public State(IWaitDialog waitDialog, ThreadedWaitDialogProgressData initialProgress, IVsSolution4 solution) { _waitDialog = waitDialog; _currentProgress = initialProgress; Solution = solution; _projectsToLoad = new HashSet <Guid>(); _loadedProjects = new HashSet <Guid>(); _projectsToUnload = new HashSet <Guid>(); _unloadedProjects = new HashSet <Guid>(); ProjectsVisitedWhileLoading = new HashSet <Guid>(); RequiresProjectDependencyCalculation = true; }
public async Task <IModalProgressDialogSession> StartModalProgressDialogAsync(string caption, ProgressDialogData initialData, INuGetUI uiService) { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var waitForDialogFactory = (IVsThreadedWaitDialogFactory)Package.GetGlobalService(typeof(SVsThreadedWaitDialogFactory)); var progressData = new ThreadedWaitDialogProgressData( initialData.WaitMessage, initialData.ProgressText, null, initialData.IsCancelable, initialData.CurrentStep, initialData.TotalSteps); var session = waitForDialogFactory.StartWaitDialog(caption, progressData); return(new VisualStudioProgressDialogSession(session)); }
public override void ReportProgress( string progressMessage, uint currentStep, uint totalSteps) { ThreadHelper.ThrowIfNotOnUIThread(); // When both currentStep and totalSteps are 0, we get a marquee on the dialog var progressData = new ThreadedWaitDialogProgressData( progressMessage, progressText: string.Empty, statusBarText: string.Empty, isCancelable: true, currentStep: (int)currentStep, totalSteps: (int)totalSteps); _session.Progress.Report(progressData); }
public override async Task ReportProgressAsync( string progressMessage, uint currentStep, uint totalSteps) { await _taskFactory.SwitchToMainThreadAsync(); // When both currentStep and totalSteps are 0, we get a marquee on the dialog var progressData = new ThreadedWaitDialogProgressData( progressMessage, progressText: string.Empty, statusBarText: string.Empty, isCancelable: true, currentStep: (int)currentStep, totalSteps: (int)totalSteps); _session.Progress.Report(progressData); }
public void Update(ThreadedWaitDialogProgressData data) { Session.Progress.Report(data); }
public void ReportProgress(ThreadedWaitDialogProgressData progress) { _session.Progress.Report(progress); }
private static ThreadedWaitDialogHelper.Session StartWaitDialog(double delayToShowDialog) { var initialProgress = new ThreadedWaitDialogProgressData(Resources.DebuggerInProgress, isCancelable: true); return(_twdf.Value.StartWaitDialog(null, initialProgress, TimeSpan.FromSeconds(delayToShowDialog))); }
private void Report(ThreadedWaitDialogProgressData progress) { _waitDialog.ReportProgress(progress); _currentProgress = progress; }
static protected void Report(Session s, string progressText, string statusText = null) { var value = new ThreadedWaitDialogProgressData(null, progressText, statusText); s.Progress.Report(value); }
static protected Session StartWaitDialog(string waitMessage, string progressText = null, string statusText = null) { var waitDialogSvc = (IVsThreadedWaitDialogFactory)Package.GetGlobalService(typeof(SVsThreadedWaitDialogFactory)); var initialProgress = new ThreadedWaitDialogProgressData(waitMessage, progressText, statusText); return waitDialogSvc.StartWaitDialog("CodeWeaver", initialProgress); }
public async Task ApplyAsync(FilterOptions options) { ThreadedWaitDialogProgressData progress; IWaitDialogFactory waitDialogFactory; if (options is null) { throw new ArgumentNullException(nameof(options)); } await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); if ((options.ProjectsToLoad.Count == 0) && (options.ProjectsToUnload.Count == 0)) { return; } waitDialogFactory = await VS.GetRequiredServiceAsync <IWaitDialogFactory, IWaitDialogFactory>(); progress = new ThreadedWaitDialogProgressData("Filtering projects...", "Getting ready...", "", true); using (var dialog = await waitDialogFactory.CreateAsync(Vsix.Name, progress)) { IEnumerable <Guid> projectsToUnload; IEnumerable <Guid> projectsToLoad; State state; ISolutionExplorer solutionExplorer; state = new State( dialog, progress, (IVsSolution4)await VS.Services.GetSolutionAsync() ); projectsToUnload = options.ProjectsToUnload.ToList(); projectsToLoad = options.ProjectsToLoad.ToList(); // Work out which projects actually need to be unloaded // so that we can calculate an accurate progress. If a // project is already unloaded, then we can skip it. state.AddProjectsToUnload(projectsToUnload.Where((x) => IsLoaded(state.Solution, x))); // Do the same for the projects that we need to load. We may add // to this list as we load projects and find their dependencies, // but we need to start with a known list so that we can give a // reasonable initial estimation for the progress. Start with the // projects that we were asked to load that are not already loaded. state.AddProjectsToLoad(projectsToLoad.Where((x) => !IsLoaded(state.Solution, x))); // If we're loading dependencies, then we can add the unloaded // dependencies of the loaded projects that were requested to be loaded. if (options.LoadProjectDependencies) { foreach (var identifier in projectsToLoad.Where((x) => IsLoaded(state.Solution, x))) { foreach (var dependency in await GetProjectDependenciesAsync(identifier, state)) { if (!IsLoaded(state.Solution, dependency)) { state.AddProjectToLoad(dependency); } } } } // Now we can start loading and unloading projects. We're // filtering projects because the user wants to keep the number // of projects loaded to a minimum, so start by unloading the // requested projects before we start loading any new projects. foreach (var identifier in projectsToUnload) { if (state.IsCancellationRequested) { break; } await UnloadProjectAsync(identifier, state); } foreach (var identifier in projectsToLoad) { if (state.IsCancellationRequested) { break; } await LoadProjectAsync(identifier, options.LoadProjectDependencies, state); } // Even if we've been cancelled, we'll still hide the unloaded // projects and show the loaded projects. This prevents us from // getting into a state where we've loaded some projects but they // remain hidden because the user cancelled half way through. solutionExplorer = await VS.GetRequiredServiceAsync <ISolutionExplorer, ISolutionExplorer>(); await solutionExplorer.HideUnloadedProjectsAsync(); // If a project has been loaded, then the user probably // wants to see it, so expand any parent folders. await solutionExplorer.ExpandAsync(state.GetLoadedProjects()); } }