private IVsThreadedWaitDialog3 CreateDialog(IVsThreadedWaitDialogFactory dialogFactory) { Marshal.ThrowExceptionForHR(dialogFactory.CreateInstance(out IVsThreadedWaitDialog2 dialog2)); if (dialog2 == null) { throw new ArgumentNullException(nameof(dialog2)); } var dialog3 = (IVsThreadedWaitDialog3)dialog2; var callback = new Callback(this); dialog3.StartWaitDialogWithCallback( szWaitCaption: _title, szWaitMessage: _message, szProgressText: null, varStatusBmpAnim: null, szStatusBarText: null, fIsCancelable: _allowCancel, iDelayToShowDialog: DelayToShowDialogSecs, fShowProgress: false, iTotalSteps: 0, iCurrentStep: 0, pCallback: callback); return(dialog3); }
/// <inheritdoc/> public override async TPL.Task Execute(Project project) { if (await this.HasUserAcceptedWarningMessage(Resources.Resources.NugetUpdate_Title, Resources.Resources.NugetUpdate_Text)) { // Creates dialog informing the user to wait for the installation to finish IVsThreadedWaitDialogFactory twdFactory = await this.Package.GetServiceAsync(typeof(SVsThreadedWaitDialogFactory)) as IVsThreadedWaitDialogFactory; IVsThreadedWaitDialog2 dialog = null; twdFactory?.CreateInstance(out dialog); string title = Resources.Resources.NugetUpdate_WaitTitle; string text = Resources.Resources.NugetUpdate_WaitText; dialog?.StartWaitDialog(title, text, null, null, null, 0, false, true); try { await this.Successor.Execute(project); } finally { // Closes the wait dialog. If the dialog failed, does nothing dialog?.EndWaitDialog(out int canceled); } } }
internal PackageRestoreManager( DTE dte, ISolutionManager solutionManager, IFileSystemProvider fileSystemProvider, IPackageRepositoryFactory packageRepositoryFactory, IPackageSourceProvider packageSourceProvider, IVsPackageManagerFactory packageManagerFactory, IVsPackageInstallerEvents packageInstallerEvents, IPackageRepository localCacheRepository, IVsThreadedWaitDialogFactory waitDialogFactory, ISettings settings) { Debug.Assert(solutionManager != null); _dte = dte; _fileSystemProvider = fileSystemProvider; _solutionManager = solutionManager; _packageRepositoryFactory = packageRepositoryFactory; _packageSourceProvider = packageSourceProvider; _waitDialogFactory = waitDialogFactory; _packageManagerFactory = packageManagerFactory; _localCacheRepository = localCacheRepository; _settings = settings; _solutionManager.ProjectAdded += OnProjectAdded; _solutionManager.SolutionOpened += OnSolutionOpenedOrClosed; _solutionManager.SolutionClosed += OnSolutionOpenedOrClosed; packageInstallerEvents.PackageReferenceAdded += OnPackageReferenceAdded; }
internal PackageRestoreManager( DTE dte, ISolutionManager solutionManager, IFileSystemProvider fileSystemProvider, IPackageRepositoryFactory packageRepositoryFactory, IVsPackageSourceProvider packageSourceProvider, IVsPackageManagerFactory packageManagerFactory, IVsPackageInstallerEvents packageInstallerEvents, IPackageRepository localCacheRepository, IVsThreadedWaitDialogFactory waitDialogFactory, ISettings settings) { Debug.Assert(solutionManager != null); _dte = dte; _fileSystemProvider = fileSystemProvider; _solutionManager = solutionManager; _packageRepositoryFactory = packageRepositoryFactory; _packageSourceProvider = packageSourceProvider; _waitDialogFactory = waitDialogFactory; _packageManagerFactory = packageManagerFactory; _localCacheRepository = localCacheRepository; _settings = settings; _solutionManager.ProjectAdded += OnProjectAdded; _solutionManager.SolutionOpened += OnSolutionOpenedOrClosed; _solutionManager.SolutionClosed += OnSolutionOpenedOrClosed; packageInstallerEvents.PackageReferenceAdded += OnPackageReferenceAdded; }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param> /// <param name="progress">A provider for progress updates.</param> /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns> protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { // When initialized asynchronously, the current thread may be a background thread at this point. // Do any initialization that requires the UI thread after switching to the UI thread. await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); // Query service asynchronously from the UI thread //var dte = await GetServiceAsync(typeof(EnvDTE.DTE)) as EnvDTE.DTE; ITextTemplating textTemplating = null; EnvDTE80.DTE2 dte2 = null; IVsThreadedWaitDialogFactory dialogFactory = null; dte2 = await GetServiceAsync(typeof(SDTE)) as EnvDTE80.DTE2; textTemplating = await GetServiceAsync(typeof(STextTemplating)) as ITextTemplating; dialogFactory = await GetServiceAsync(typeof(SVsThreadedWaitDialogFactory)) as IVsThreadedWaitDialogFactory; await CS2REACTJS.Commands.CrtDbContextCommand.InitializeAsync(this, dte2, textTemplating, dialogFactory); await CS2REACTJS.Commands.CrtViewModelCommand.InitializeAsync(this, dte2, textTemplating, dialogFactory); await CS2REACTJS.Commands.CrtWebApiServiceCommand.InitializeAsync(this, dte2, textTemplating, dialogFactory); await CS2REACTJS.Commands.CrtJavaScriptsCommand.InitializeAsync(this, dte2, textTemplating, dialogFactory); await CS2REACTJS.Commands.CrtFeatureScriptsCommand.InitializeAsync(this, dte2, textTemplating, dialogFactory); }
static WaitDialog Create() { if (factory == null) { factory = (IVsThreadedWaitDialogFactory)Package .GetGlobalService(typeof(SVsThreadedWaitDialogFactory)); if (factory == null) { return(null); } } IVsThreadedWaitDialog2 vsWaitDialog = null; factory.CreateInstance(out vsWaitDialog); if (vsWaitDialog == null) { return(null); } return(new WaitDialog { VsWaitDialog = vsWaitDialog, Running = true, }); }
IVsThreadedWaitDialog3 CreateDialog(IVsThreadedWaitDialogFactory dialogFactory) { ThreadHelper.ThrowIfNotOnUIThread(); Marshal.ThrowExceptionForHR(dialogFactory.CreateInstance(out var dialog2)); var dialog3 = (IVsThreadedWaitDialog3)dialog2; var callback = new Callback(this); dialog3.StartWaitDialogWithCallback( szWaitCaption: _title, szWaitMessage: _message, szProgressText: null, varStatusBmpAnim: null, szStatusBarText: null, fIsCancelable: _allowCancel, iDelayToShowDialog: DelayToShowDialogSecs, fShowProgress: false, iTotalSteps: 0, iCurrentStep: 0, pCallback: callback); return(dialog3); }
private IVsThreadedWaitDialog3 CreateDialog( IVsThreadedWaitDialogFactory dialogFactory, bool showProgress) { Marshal.ThrowExceptionForHR(dialogFactory.CreateInstance(out var dialog2)); Contract.ThrowIfNull(dialog2); var dialog3 = (IVsThreadedWaitDialog3)dialog2; var callback = new Callback(this); dialog3.StartWaitDialogWithCallback( szWaitCaption: _title, szWaitMessage: _message, szProgressText: null, varStatusBmpAnim: null, szStatusBarText: null, fIsCancelable: _allowCancel, iDelayToShowDialog: DelayToShowDialogSecs, fShowProgress: showProgress, iTotalSteps: this.ProgressTracker.TotalItems, iCurrentStep: this.ProgressTracker.CompletedItems, pCallback: callback); return dialog3; }
private async Task <bool> DownloadIWYUWithProgressBar(string executablePath, IVsThreadedWaitDialogFactory dialogFactory) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); IVsThreadedWaitDialog2 progressDialog; dialogFactory.CreateInstance(out progressDialog); if (progressDialog == null) { Output.Instance.WriteLine("Failed to get create wait dialog."); return(false); } progressDialog.StartWaitDialogWithPercentageProgress( szWaitCaption: "Include Toolbox - Downloading include-what-you-use", szWaitMessage: "", // comes in later. szProgressText: null, varStatusBmpAnim: null, szStatusBarText: "Downloading include-what-you-use", fIsCancelable: true, iDelayToShowDialog: 0, iTotalSteps: 100, iCurrentStep: 0); var cancellationToken = new System.Threading.CancellationTokenSource(); try { await IWYUDownload.DownloadIWYU(executablePath, delegate(string section, string status, float percentage) { ThreadHelper.ThrowIfNotOnUIThread(); bool canceled; progressDialog.UpdateProgress( szUpdatedWaitMessage: section, szProgressText: status, szStatusBarText: $"Downloading include-what-you-use - {section} - {status}", iCurrentStep: (int)(percentage * 100), iTotalSteps: 100, fDisableCancel: true, pfCanceled: out canceled); if (canceled) { cancellationToken.Cancel(); } }, cancellationToken.Token); } catch (Exception e) { await Output.Instance.ErrorMsg("Failed to download include-what-you-use: {0}", e); return(false); } finally { progressDialog.EndWaitDialog(); } return(true); }
public static WaitDialog Start( string caption, string message, string progressText = null, string statusBarText = null, int delay = 0, bool isCancelable = false, bool showMarqueeProgress = true, IVsThreadedWaitDialogFactory dialogFactory = null) { ThreadHelper.ThrowIfNotOnUIThread(); var dialog = Create(dialogFactory); if (dialog == null) { return(null); } var res = dialog.VsWaitDialog.StartWaitDialog(caption, message, progressText, null, statusBarText, delay, isCancelable, showMarqueeProgress); if (res != VSConstants.S_OK) { return(null); } return(dialog); }
public bool InstallDebugPackage(IVsOutputWindowPane outputPane, IVsThreadedWaitDialogFactory dlgFactory /*uint debugTargetTypeId,*/) { bool isInstalled; string source; string destination; string ondemandPath = ToolsPathInfo.OndemandFolderPath; this.outputPane = outputPane; if (this.outputPane != null) { this.outputPane.Activate(); } // Check the lldb package was installed in previous or not. GetPkgInstalledStatus(out isInstalled); if (!isInstalled) { source = ondemandPath + @"\" + GetLldbPkgName(); destination = GetLldbDestPath(); if (!PushDebuggerPackage(source, destination)) { ErrorMessage = "Failed : Debugger Push from " + source + " to " + destination + ".\n"; } // Install Debug package if (!DeployDebuggerPackage(destination)) { ErrorMessage = "Failed : Debugger Installation on " + destination + " .\n"; } } ErrorMessage = string.Empty; return(true); }
static WaitDialog Create(IVsThreadedWaitDialogFactory dialogFactory) { ThreadHelper.ThrowIfNotOnUIThread(); if (factory == null) { factory = dialogFactory ?? VsServiceProvider .GetService <SVsThreadedWaitDialogFactory, IVsThreadedWaitDialogFactory>(); if (factory == null) { return(null); } } factory.CreateInstance(out IVsThreadedWaitDialog2 vsWaitDialog); if (vsWaitDialog == null) { return(null); } return(new WaitDialog { VsWaitDialog = vsWaitDialog, Running = true, }); }
public static WaitDialog StartWithProgress( string caption, string message, int totalSteps, int currentStep = 0, string progressText = null, string statusBarText = null, int delay = 0, bool isCancelable = false, IVsThreadedWaitDialogFactory dialogFactory = null) { ThreadHelper.ThrowIfNotOnUIThread(); var dialog = Create(dialogFactory); if (dialog == null) { return(null); } var res = dialog.VsWaitDialog.StartWaitDialogWithPercentageProgress( caption, message, progressText, null, statusBarText, isCancelable, delay, totalSteps, currentStep); if (res != VSConstants.S_OK) { return(null); } return(dialog); }
private IVsThreadedWaitDialog3 CreateDialog( IVsThreadedWaitDialogFactory dialogFactory, bool showProgress ) { Marshal.ThrowExceptionForHR(dialogFactory.CreateInstance(out var dialog2)); Contract.ThrowIfNull(dialog2); var dialog3 = (IVsThreadedWaitDialog3)dialog2; var callback = new Callback(this); dialog3.StartWaitDialogWithCallback( szWaitCaption: _title, szWaitMessage: this.ProgressTracker.Description ?? _message, szProgressText: null, varStatusBmpAnim: null, szStatusBarText: null, fIsCancelable: _allowCancel, iDelayToShowDialog: DelayToShowDialogSecs, fShowProgress: showProgress, iTotalSteps: this.ProgressTracker.TotalItems, iCurrentStep: this.ProgressTracker.CompletedItems, pCallback: callback ); return(dialog3); }
public ThreadedWaitDialogProgressScope(string waitCaption) { IVsThreadedWaitDialogFactory factory = (IVsThreadedWaitDialogFactory)Package.GetGlobalService(typeof(SVsThreadedWaitDialogFactory)); Session = factory.StartWaitDialog(waitCaption); }
static WaitDialog Create() { if (factory == null) { factory = VsServiceProvider .GetService <SVsThreadedWaitDialogFactory, IVsThreadedWaitDialogFactory>(); if (factory == null) { return(null); } } IVsThreadedWaitDialog2 vsWaitDialog = null; factory.CreateInstance(out vsWaitDialog); if (vsWaitDialog == null) { return(null); } return(new WaitDialog { VsWaitDialog = vsWaitDialog, Running = true, }); }
// Test constructor internal DefaultWaitDialogFactory( JoinableTaskContext joinableTaskContext, IVsThreadedWaitDialogFactory waitDialogFactory) { _waitDialogFactory = waitDialogFactory; _joinableTaskFactory = joinableTaskContext.Factory; }
public VisualStudioGitService(IServiceProvider serviceProvider) { _dialogFactory = serviceProvider.GetService(typeof(SVsThreadedWaitDialogFactory)) as IVsThreadedWaitDialogFactory; _gitCommandExecuter = new GitCommandExecuter(serviceProvider); _teamExplorer = serviceProvider.GetService(typeof(ITeamExplorer)) as ITeamExplorer; _dte = serviceProvider.GetService(typeof(DTE)) as DTE; _vsDiffService = serviceProvider.GetService(typeof(SVsDifferenceService)) as IVsDifferenceService; }
public BatchProcessingViewModel(DTE2 dte, ITextTemplating textTemplating, IVsThreadedWaitDialogFactory dialogFactory, string t4RootFolder, string batchRootFolder) { this.Dte = dte; this.TextTemplating = textTemplating; this.T4RootFolder = t4RootFolder; this.BatchRootFolder = batchRootFolder; this.DialogFactory = dialogFactory; }
public static void Initialize(string AppTitle, DTE2 dte, IVsThreadedWaitDialogFactory dialogFactory, IVsOutputWindow outputWindow, Func <ChartControl> getpanewindow) { QCPluginUtilities.AppTitle = AppTitle; QCPluginUtilities.dialogFactory = dialogFactory; QCPluginUtilities.dte = dte; QCPluginUtilities.outputWindow = outputWindow; QCPluginUtilities.InstallPath = RetrieveAssemblyDirectory(); QCPluginUtilities.GetPaneWindow = getpanewindow; }
public VisualStudioWaitContext(IVsThreadedWaitDialogFactory dialogFactory, string title, string message, bool allowCancel) { _title = title; _message = message; _allowCancel = allowCancel; _cancellationTokenSource = new CancellationTokenSource(); _dialog = CreateDialog(dialogFactory); }
public WaitDialogRestorer(IPackageRestorer restorer, IVsThreadedWaitDialogFactory waitDialogFactory) { if (restorer == null) throw new ArgumentNullException("restorer"); if (waitDialogFactory == null) throw new ArgumentNullException("waitDialogFactory"); this.restorer = restorer; this.waitDialogFactory = waitDialogFactory; }
public MainWindowVm2WebApi(DTE2 dte, ITextTemplating textTemplating, IVsThreadedWaitDialogFactory dialogFactory) : base(dte, textTemplating, dialogFactory) { InvitationViewModel InvitationVM = new InvitationViewModel(); InvitationVM.WizardName = "#3 WebApi Wizard"; InvitationVM.IsReady.IsReadyEvent += InvitationViewModel_IsReady; this.InvitationUC = new UserControlInvitation(InvitationVM); this.CurrentUserControl = this.InvitationUC; InvitationVM.DoAnalise(dte); }
public MainWindowEf2Vm(DTE2 dte, ITextTemplating textTemplating, IVsThreadedWaitDialogFactory dialogFactory) : base(dte, textTemplating, dialogFactory) { Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); InvitationViewModel InvitationVM = new InvitationViewModel(); InvitationVM.WizardName = "#2 View Wizard"; InvitationVM.IsReady.IsReadyEvent += InvitationViewModel_IsReady; this.InvitationUC = new UserControlInvitation(InvitationVM); this.CurrentUserControl = this.InvitationUC; InvitationVM.DoAnalise(dte); }
public SelectFolderViewModel(DTE2 dte, ITextTemplating textTemplating, IVsThreadedWaitDialogFactory dialogFactory, SolutionCodeElement selectedDbContext, string rootFolder, string JavaScriptsTmplst, string BatchJavaScriptsTmplst) : base() { this.T4Folders = new ObservableCollection <string>(); this.Dte = dte; this.SelectedDbContext = selectedDbContext; this.DialogFactory = dialogFactory; this.TextTemplating = textTemplating; this.T4RootFolder = Path.Combine(rootFolder, JavaScriptsTmplst); this.BatchRootFolder = Path.Combine(rootFolder, BatchJavaScriptsTmplst); this.OnContextChanged = new ContextChangedService(); }
public VisualStudioWaitContext(IVsThreadedWaitDialogFactory waitDialogFactory, string title, string message, bool allowCancel, int totalSteps = 0) { _title = title; _message = message; _totalSteps = totalSteps; if (allowCancel) { _cancellationTokenSource = new CancellationTokenSource(); } _dialog = CreateDialog(waitDialogFactory); }
public VisualStudioWaitContext(IVsThreadedWaitDialogFactory dialogFactory, string title, string message, bool allowCancel) { ThreadHelper.ThrowIfNotOnUIThread(); _title = title; _message = message; _allowCancel = allowCancel; _cancellationTokenSource = new CancellationTokenSource(); _dialog = CreateDialog(dialogFactory); }
private void UpdateSlowCheetah(Project project) { // This is done on the UI thread because changes are made to the project file, // causing it to be reloaded. To avoid conflicts with NuGet installation, // the update is done sequentially if (this.HasUserAcceptedWarningMessage(Resources.Resources.NugetUpdate_Title, Resources.Resources.NugetUpdate_Text)) { // Creates dialog informing the user to wait for the installation to finish IVsThreadedWaitDialogFactory twdFactory = this.package.GetService(typeof(SVsThreadedWaitDialogFactory)) as IVsThreadedWaitDialogFactory; IVsThreadedWaitDialog2 dialog = null; twdFactory?.CreateInstance(out dialog); string title = Resources.Resources.NugetUpdate_WaitTitle; string text = Resources.Resources.NugetUpdate_WaitText; dialog?.StartWaitDialog(title, text, null, null, null, 0, false, true); try { // Installs the latest version of the SlowCheetah NuGet package var componentModel = (IComponentModel)this.package.GetService(typeof(SComponentModel)); if (this.IsSlowCheetahInstalled(project)) { IVsPackageUninstaller packageUninstaller = componentModel.GetService <IVsPackageUninstaller>(); packageUninstaller.UninstallPackage(project, PackageName, true); } IVsPackageInstaller2 packageInstaller = componentModel.GetService <IVsPackageInstaller2>(); packageInstaller.InstallLatestPackage(null, project, PackageName, false, false); project.Save(); ProjectRootElement projectRoot = ProjectRootElement.Open(project.FullName); foreach (ProjectPropertyGroupElement propertyGroup in projectRoot.PropertyGroups.Where(pg => pg.Label.Equals("SlowCheetah"))) { projectRoot.RemoveChild(propertyGroup); } foreach (ProjectImportElement import in projectRoot.Imports.Where(i => i.Label == "SlowCheetah" || i.Project == "$(SlowCheetahTargets)")) { projectRoot.RemoveChild(import); } projectRoot.Save(); } finally { // Closes the wait dialog. If the dialog failed, does nothing int canceled; dialog?.EndWaitDialog(out canceled); } } }
public WaitDialogRestorer(IPackageRestorer restorer, IVsThreadedWaitDialogFactory waitDialogFactory) { if (restorer == null) { throw new ArgumentNullException("restorer"); } if (waitDialogFactory == null) { throw new ArgumentNullException("waitDialogFactory"); } this.restorer = restorer; this.waitDialogFactory = waitDialogFactory; }
public VisualStudioWaitContext( IGlobalOperationNotificationService notificationService, IVsThreadedWaitDialogFactory dialogFactory, string title, string message, bool allowCancel) { _title = title; _message = message; _allowCancel = allowCancel; _cancellationTokenSource = new CancellationTokenSource(); _dialog = CreateDialog(dialogFactory); _registration = notificationService.Start(title); }
public VisualStudioWaitContext( IGlobalOperationNotificationService notificationService, IVsThreadedWaitDialogFactory dialogFactory, string title, string message, bool allowCancel) { _title = title; _message = message; _allowCancel = allowCancel; _cancellationTokenSource = new CancellationTokenSource(); _dialog = CreateDialog(dialogFactory); _registration = notificationService.Start(title); }
public CLIExecutor(Process executable, WaitDialogDescription dialogDesc, ProcessDataReceiverDelegate OnProcessUpdated, ProcessTerminatorDelegate OnProcessCanceled, ProcessTerminatorDelegate OnProcessExited) { this.executable = executable; this.dialogDesc = dialogDesc; this.OnProcessExited = OnProcessExited; this.OnProcessUpdated = OnProcessUpdated; this.OnProcessCanceled = OnProcessCanceled; IVsThreadedWaitDialogFactory dlgFactory = Package.GetGlobalService(typeof(SVsThreadedWaitDialogFactory)) as IVsThreadedWaitDialogFactory; if (dlgFactory != null) { dlgFactory.CreateInstance(out waitDialog); } }
public DefaultWaitDialogFactory(JoinableTaskContext joinableTaskContext) { if (joinableTaskContext is null) { throw new ArgumentNullException(nameof(joinableTaskContext)); } _waitDialogFactory = (IVsThreadedWaitDialogFactory)Shell.Package.GetGlobalService(typeof(SVsThreadedWaitDialogFactory)); if (_waitDialogFactory == null) { throw new ArgumentNullException(nameof(_waitDialogFactory)); } _joinableTaskFactory = joinableTaskContext.Factory; }
public MainWindowBase(DTE2 dte, ITextTemplating textTemplating, IVsThreadedWaitDialogFactory dialogFactory) { CancelClicked = new ButtonClickedNotificationService(); this.Dte = dte; this.TextTemplating = textTemplating; this.DialogFactory = dialogFactory; try { DefineDestinationProject(); } catch { ; } }
public IDisposable ShowProgressDialog(string caption, string message, int startDelay) { IVsThreadedWaitDialog2 vsThreadedWaitDialog2; IVsThreadedWaitDialogFactory service = this._serviceProvider.GetService(typeof(SVsThreadedWaitDialogFactory)) as IVsThreadedWaitDialogFactory; Marshal.ThrowExceptionForHR(service.CreateInstance(out vsThreadedWaitDialog2)); string str = null; int num = vsThreadedWaitDialog2.StartWaitDialog(caption, message, null, null, str, startDelay, false, true); Marshal.ThrowExceptionForHR(num); Cursor overrideCursor = Mouse.OverrideCursor; Mouse.OverrideCursor = Cursors.Wait; return(new VsShellDialogService.ProgressDialog(vsThreadedWaitDialog2, overrideCursor)); }
internal PackageRestoreManager( DTE dte, ISolutionManager solutionManager, IFileSystemProvider fileSystemProvider, IPackageRepositoryFactory packageRepositoryFactory, IVsPackageManagerFactory packageManagerFactory, IVsThreadedWaitDialogFactory waitDialogFactory) { Debug.Assert(solutionManager != null); _dte = dte; _fileSystemProvider = fileSystemProvider; _solutionManager = solutionManager; _packageRepositoryFactory = packageRepositoryFactory; _waitDialogFactory = waitDialogFactory; _packageManagerFactory = packageManagerFactory; _solutionManager.ProjectAdded += OnProjectAdded; _solutionManager.SolutionOpened += OnSolutionOpenedOrClosed; _solutionManager.SolutionClosed += OnSolutionOpenedOrClosed; }
public VisualStudioWaitContext( IGlobalOperationNotificationService notificationService, IVsThreadedWaitDialogFactory dialogFactory, string title, string message, bool allowCancel, bool showProgress) { _title = title; _message = message; _allowCancel = allowCancel; _cancellationTokenSource = new CancellationTokenSource(); this.ProgressTracker = showProgress ? new ProgressTracker((_1, _2) => UpdateDialog()) : new ProgressTracker(); _dialog = CreateDialog(dialogFactory, showProgress); _registration = notificationService.Start(title); }
IVsThreadedWaitDialog3 CreateDialog(IVsThreadedWaitDialogFactory dialogFactory) { IVsThreadedWaitDialog2 dialog2; Marshal.ThrowExceptionForHR(dialogFactory.CreateInstance(out dialog2)); var dialog3 = (IVsThreadedWaitDialog3) dialog2; var callback = new Callback(this); dialog3.StartWaitDialogWithCallback( szWaitCaption : _title, szWaitMessage : _message, szProgressText : null, varStatusBmpAnim : null, szStatusBarText : null, fIsCancelable : _allowCancel, iDelayToShowDialog: DelayToShowDialogSecs, fShowProgress : false, iTotalSteps : 0, iCurrentStep : 0, pCallback : callback); return dialog3; }
private PackageRestoreManager CreateInstance( DTE dte = null, ISolutionManager solutionManager = null, IFileSystemProvider fileSystemProvider = null, IPackageRepositoryFactory packageRepositoryFactory = null, IVsThreadedWaitDialogFactory waitDialogFactory = null, IVsPackageManagerFactory packageManagerFactory = null, IPackageRepository localCache = null, IPackageSourceProvider packageSourceProvider = null, ISettings settings = null) { if (dte == null) { dte = new Mock<DTE>().Object; } if (solutionManager == null) { solutionManager = new Mock<ISolutionManager>().Object; } if (fileSystemProvider == null) { fileSystemProvider = new Mock<IFileSystemProvider>().Object; } if (packageRepositoryFactory == null) { packageRepositoryFactory = new Mock<IPackageRepositoryFactory>().Object; } if (waitDialogFactory == null) { var mockWaitDialogFactory = new Mock<IVsThreadedWaitDialogFactory>(); var mockWaitDialog = new Mock<IVsThreadedWaitDialog2>(); mockWaitDialog.Setup(p => p.StartWaitDialog( It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<object>(), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<bool>(), It.IsAny<bool>())); int canceled; mockWaitDialog.Setup(p => p.EndWaitDialog(out canceled)).Returns(0); var waitDialog = mockWaitDialog.Object; mockWaitDialogFactory.Setup(p => p.CreateInstance(out waitDialog)).Returns(0); waitDialogFactory = mockWaitDialogFactory.Object; } if (packageManagerFactory == null) { packageManagerFactory = new Mock<IVsPackageManagerFactory>().Object; } if (localCache == null) { localCache = new MockPackageRepository(); } if (packageSourceProvider == null) { packageSourceProvider = new Mock<IPackageSourceProvider>().Object; } if (settings == null) { settings = Mock.Of<ISettings>(); } return new PackageRestoreManager( dte, solutionManager, fileSystemProvider, packageRepositoryFactory, packageSourceProvider, packageManagerFactory, new VsPackageInstallerEvents(), localCache, waitDialogFactory, settings); }