public static Color Update(Panel panel, int value, int maxValue = 100) { if (panel == null) { return(Color.OrangeRed); } var hWnd = panel.GetAncestor()?.Handle ?? IntPtr.Zero; if (hWnd != IntPtr.Zero) { if (value == 0) { TaskBarProgress.SetState(hWnd, TaskBarProgressState.Indeterminate); } else { TaskBarProgress.SetValue(hWnd, value, maxValue); } } var color = ForeColor; if (ForeColor == default) { color = Color.FromArgb(byte.MaxValue - (byte)(value * (byte.MaxValue / (float)maxValue)), byte.MaxValue, value); } using (var g = panel.CreateGraphics()) { var width = value > 0 && value < maxValue ? (int)Math.Round(panel.Width / (double)maxValue * value, MidpointRounding.AwayFromZero) : panel.Width; using (Brush b = new SolidBrush(value > 0 ? color : panel.BackColor)) g.FillRectangle(b, 0, 0, width, panel.Height); } return(color); }
internal static void Restore(LocalAppData appData, bool quiet = false, Form owner = default) { if (appData == default) { return; } if (owner != default) { owner.TopMost = false; owner.Enabled = false; TaskBarProgress.SetState(owner.Handle, TaskBarProgressState.Indeterminate); Settings.WriteToFile(true); } var assocData = appData.Settings.FileTypeAssoc; assocData?.SystemRegistryAccess?.LoadRestorePoint(quiet); if (owner == default) { return; } TaskBarProgress.SetState(owner.Handle, TaskBarProgressState.NoProgress); if (WinApi.NativeHelper.GetForegroundWindow() != owner.Handle) { WinApi.NativeHelper.SetForegroundWindow(owner.Handle); } owner.Enabled = true; owner.TopMost = true; }
private void UpdatePingForm(PingData pingData) { notifyIcon.Icon = GetIcon(pingData.Status == IPStatus.Success ? pingData.Time : 0); if (pingData.Address != null) { string[] ipParts = pingData.Address.ToString().Split('.'); if (ipParts.Length == 4) { txtIP1.Text = int.Parse(ipParts[0]).ToString("000"); txtIP2.Text = int.Parse(ipParts[1]).ToString("000"); txtIP3.Text = int.Parse(ipParts[2]).ToString("000"); txtIP4.Text = int.Parse(ipParts[3]).ToString("000"); } txtTTL.Text = pingData.TTL.ToString(); } if (notifyIcon.Visible && pingData.Status != IPStatus.Success) { notifyIcon.BalloonTipIcon = ToolTipIcon.Warning; notifyIcon.BalloonTipTitle = Text; notifyIcon.BalloonTipText = "Ping error:" + Environment.NewLine + pingData.Message; notifyIcon.ShowBalloonTip(1000); } var lableText = pingData.Status == IPStatus.Success ? pingData.Time + " ms" : pingData.Status.ToString(); notifyIcon.Text = Text = string.Format(_titleTemplate, lableText); lblPing.Text = lableText; lblPing.BackColor = pingData.Color; Logger.Log(pingData.TimeStamp, pingData.ToString(), pingData.Color, pingData.Status != IPStatus.Success || pingData.Time >= nudLog.Value); TaskBarProgress.SetProgressState(Handle, GetProgressState(pingData.Status == IPStatus.Success ? pingData.Time : 0)); TaskBarProgress.SetProgressValue(Handle, 100, 100); }
private void StopPinging() { btnStart.Text = "Start"; txtHostName.ReadOnly = false; nudBuffer.Enabled = nudGood.Enabled = nudBad.Enabled = nudTimeOut.Enabled = nudLog.Enabled = true; notifyIcon.Text = Text = OriginalTitle; notifyIcon.Icon = GetIcon(-1); TaskBarProgress.SetProgressState(Handle, GetProgressState(-1)); Logger.Stop(); }
internal void ReportFMExtractProgress(int percent) { ProgressBar.SetValueInstant(percent.Clamp(0, 100)); ProgressMessageLabel.Text = LText.ProgressBox.InstallingFM; ProgressPercentLabel.Text = percent + @"%"; if (Owner?.IsHandleCreated == true) { TaskBarProgress.SetValue(Owner.Handle, percent, 100); } }
private void UpdateTaskBarProgress() { if (this.VisibleInTaskBar) { TaskBarProgress.SetValue(this.Value, this.Maximum); } else { TaskBarProgress.State = TaskBarProgress.TaskBarState.NoProgress; } }
internal void ShowProgressWindow(ProgressTasks progressTask, bool suppressShow = false) { ProgressTask = progressTask; this.CenterHV(Owner !, clientSize: true); ProgressMessageLabel.Text = progressTask switch { ProgressTasks.ScanAllFMs => LText.ProgressBox.Scanning, ProgressTasks.InstallFM => LText.ProgressBox.InstallingFM, ProgressTasks.UninstallFM => LText.ProgressBox.UninstallingFM, ProgressTasks.ConvertFiles => LText.ProgressBox.ConvertingFiles, ProgressTasks.ImportFromDarkLoader => LText.ProgressBox.ImportingFromDarkLoader, ProgressTasks.ImportFromNDL => LText.ProgressBox.ImportingFromNewDarkLoader, ProgressTasks.ImportFromFMSel => LText.ProgressBox.ImportingFromFMSel, ProgressTasks.CacheFM => LText.ProgressBox.CachingReadmeFiles, ProgressTasks.DeleteFMArchive => LText.ProgressBox.DeletingFMArchive, _ => "" }; CurrentThingLabel.Text = progressTask == ProgressTasks.ScanAllFMs ? LText.ProgressBox.CheckingInstalledFMs : ""; ProgressPercentLabel.Text = ""; if (progressTask == ProgressTasks.UninstallFM || progressTask == ProgressTasks.ConvertFiles || progressTask == ProgressTasks.ImportFromDarkLoader || progressTask == ProgressTasks.ImportFromNDL || progressTask == ProgressTasks.ImportFromFMSel || progressTask == ProgressTasks.DeleteFMArchive) { ProgressBar.Style = ProgressBarStyle.Marquee; if (Owner?.IsHandleCreated == true) { TaskBarProgress.SetState(Owner.Handle, TaskbarStates.Indeterminate); } ProgressCancelButton.Hide(); } else { ProgressBar.Style = ProgressBarStyle.Blocks; ProgressCancelButton.Visible = progressTask != ProgressTasks.CacheFM; ProgressBar.SetValueInstant(0); } if (!suppressShow) { ShowThis(); } }
private void RunFullWorkflow() { this.ShouldShowProgress = true; var filesSelected = this.FeatureFindingSettingsViewModel.Datasets.Where(ds => ds.IsSelected).ToList().Count != 0; var alignmentChosen = (this.AlignmentSettingsViewModel.ShouldAlignToBaseline && this.AlignmentSettingsViewModel.SelectedBaseline != null) || (this.AlignmentSettingsViewModel.ShouldAlignToAMT && this.Analysis.MassTagDatabase != null); if (filesSelected && alignmentChosen) { var taskBarProgress = TaskBarProgress.GetInstance(); taskBarProgress.TakeControl(this); taskBarProgress.ShowProgress(this, true); // Reporting to UI var progData = new ProgressData(new Progress <ProgressData>(pd => { var prog = pd.Percent; this.ProgressTracker = (int)prog; taskBarProgress.SetProgress(this, prog); })); // Internal progress, fed through progData, which will trigger the reports to the UI var totalProgress = new Progress <ProgressData>(pd => progData.Report(pd.Percent)); progData.StepRange(50); // Make copy of selected datasets at time of function call so all work is done on the same set of files // even if the user changes the selection while the workflow is running. var selectedDatasetsCopy = this.FeatureFindingSettingsViewModel.Datasets.Where(ds => ds.IsSelected).ToList(); this.FeatureFindingSettingsViewModel.LoadFeatures(selectedDatasetsCopy, totalProgress); progData.StepRange(80); this.AlignmentSettingsViewModel.AlignToBaseline(selectedDatasetsCopy, totalProgress); progData.StepRange(100); this.ClusterSettingsViewModel.ClusterFeatures(totalProgress); this.ShouldShowProgress = false; taskBarProgress.ShowProgress(this, false); taskBarProgress.ReleaseControl(this); } else if (!filesSelected) { MessageBox.Show("No datasets selected."); } else { MessageBox.Show("Alignment settings not set."); } }
internal void ReportScanProgress(int fmNumber, int fmsTotal, int percent, string fmName) { ProgressBar.SetValueInstant(percent.Clamp(0, 100)); string first = LText.ProgressBox.ReportScanningFirst; string between = LText.ProgressBox.ReportScanningBetweenNumAndTotal; string last = LText.ProgressBox.ReportScanningLast; ProgressMessageLabel.Text = first + fmNumber + between + fmsTotal + last; CurrentThingLabel.Text = fmName; ProgressPercentLabel.Text = percent + @"%"; if (Owner?.IsHandleCreated == true) { TaskBarProgress.SetValue(Owner.Handle, percent, 100); } }
internal void HideThis() { if (Owner?.IsHandleCreated == true) { TaskBarProgress.SetState(Owner.Handle, TaskbarStates.NoProgress); } Hide(); ProgressMessageLabel.Text = ""; CurrentThingLabel.Text = ""; ProgressPercentLabel.Text = ""; ProgressBar.SetValueInstant(0); ProgressBar.Style = ProgressBarStyle.Blocks; ProgressCancelButton.Show(); Enabled = false; Owner !.EnableEverything(true); }
internal void ReportCachingProgress(int percent) { ProgressBar.SetValueInstant(percent.Clamp(0, 100)); ProgressPercentLabel.Text = percent + @"%"; if (Visible) { if (Owner?.IsHandleCreated == true) { TaskBarProgress.SetValue(Owner.Handle, percent, 100); } } else { if (Owner?.IsHandleCreated == true) { TaskBarProgress.SetState(Owner.Handle, TaskbarStates.NoProgress); } } }
internal static void Associate(LocalAppData appData, bool quiet = false, Form owner = default) { if (appData?.Settings?.FileTypes?.Any() != true) { if (!quiet) { MessageBoxEx.Show(owner, Language.GetText(nameof(en_US.associateBtnMsg)), Resources.GlobalTitle, MessageBoxButtons.OK, MessageBoxIcon.Information); } return; } if (!Elevation.IsAdministrator) { if (owner != default) { owner.TopMost = false; owner.Enabled = false; TaskBarProgress.SetState(owner.Handle, TaskBarProgressState.Indeterminate); } _bw?.Dispose(); _bw = new BackgroundWorker(); _bw.DoWork += (sender, args) => { using (var process = ProcessEx.Start(PathEx.LocalPath, $"{ActionGuid.FileTypeAssociation} \"{appData.Key}\"", true, false)) if (!process?.HasExited == true) { process.WaitForExit(); } }; _bw.RunWorkerCompleted += (sender, args) => { if (owner == default) { return; } TaskBarProgress.SetState(owner.Handle, TaskBarProgressState.NoProgress); if (WinApi.NativeHelper.GetForegroundWindow() != owner.Handle) { WinApi.NativeHelper.SetForegroundWindow(owner.Handle); } owner.Enabled = true; owner.TopMost = true; }; _bw.RunWorkerAsync(); return; } var assocData = new FileTypeAssocData { AppKey = appData.Key, InstallId = Settings.SystemInstallId }; using (var dialog = new IconBrowserDialog(Settings.IconResourcePath, Settings.Window.Colors.BaseDark, Settings.Window.Colors.ControlText, Settings.Window.Colors.Button, Settings.Window.Colors.ButtonText, Settings.Window.Colors.ButtonHover)) { dialog.TopMost = true; dialog.Plus(); dialog.ShowDialog(); if (!string.IsNullOrEmpty(dialog.IconPath)) { assocData.IconPath = dialog.IconPath; assocData.IconId = dialog.IconId.ToString(CultureInfo.InvariantCulture); } } if (!FileEx.Exists(assocData.IconPath) || string.IsNullOrEmpty(assocData.IconId)) { goto Cancel; } MessageBoxEx.ButtonText.OverrideEnabled = true; MessageBoxEx.ButtonText.Yes = "App"; MessageBoxEx.ButtonText.No = "Launcher"; MessageBoxEx.ButtonText.Cancel = Language.GetText(nameof(en_US.Cancel)); var result = !quiet?MessageBoxEx.Show(Language.GetText(nameof(en_US.AssociateAppWayQuestion)), Resources.GlobalTitle, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question) : DialogResult.Yes; switch (result) { case DialogResult.Yes: assocData.StarterPath = EnvironmentEx.GetVariablePathFull(appData.FilePath, false, false); break; case DialogResult.No: assocData.StarterPath = EnvironmentEx.GetVariablePathFull(PathEx.LocalPath, false, false); break; default: goto Cancel; } if (FileEx.Exists(assocData.StarterPath)) { appData.Settings.FileTypeAssoc = assocData; } else { goto Cancel; } assocData = appData.Settings?.FileTypeAssoc; assocData?.SystemRegistryAccess?.AssociateFileTypes(false); return; Cancel: if (!quiet) { MessageBoxEx.Show(owner, Language.GetText(nameof(en_US.OperationCanceledMsg)), MessageBoxButtons.OK, MessageBoxIcon.Information); } }
internal void LoadFeatures(List <DatasetInformationViewModel> workFlowDatasets = null, IProgress <ProgressData> workflowProgress = null) { var featureCache = new FeatureLoader { Providers = this.analysis.DataProviders }; this.ShouldShowProgress = true; var selectedFiles = workFlowDatasets ?? this.Datasets.Where(file => !file.DoingWork).Where(ds => ds.IsSelected).ToList(); foreach (var file in selectedFiles) { file.DatasetState = DatasetInformationViewModel.DatasetStates.FindingFeatures; ThreadSafeDispatcher.Invoke(() => this.PlotMsFeaturesCommand.RaiseCanExecuteChanged()); ThreadSafeDispatcher.Invoke(() => this.FindMsFeaturesCommand.RaiseCanExecuteChanged()); } var taskBarProgress = TaskBarProgress.GetInstance(); taskBarProgress.ShowProgress(this, true); workflowProgress = workflowProgress ?? new Progress <ProgressData>(); IProgress <ProgressData> totalProgressRpt = new Progress <ProgressData>(pd => { this.TotalProgress = pd.Percent; taskBarProgress.SetProgress(this, pd.Percent); workflowProgress.Report(pd); }); var totalProgressData = new ProgressData(totalProgressRpt); DatabaseIndexer.IndexClustersDrop(NHibernateUtil.Path); DatabaseIndexer.IndexFeaturesDrop(NHibernateUtil.Path); var i = 1; foreach (var file in selectedFiles) { // Set range based on file totalProgressData.StepRange((i++ *100.0) / selectedFiles.Count); var fileInstance = file; var progData = new ProgressData(new Progress <ProgressData>(pd => { fileInstance.Progress = pd.Percent; // Report file progress totalProgressData.Report(fileInstance.Progress); })); var progressRpt = new Progress <ProgressData>(pd => progData.Report(pd.Percent)); progData.StepRange(30); IList <UMCLight> features; // Load features from the database. try { this.analysis.DataProviders.DatabaseLock.EnterReadLock(); features = featureCache.LoadDataset( file.Dataset, this.analysis.Options.MsFilteringOptions, this.analysis.Options.LcmsFindingOptions, this.analysis.Options.LcmsFilteringOptions, this.analysis.Options.DataLoadOptions, this.analysis.DataProviders.ScanSummaryProviderCache, this.analysis.DataProviders.IdentificationProviderCache, progressRpt); } finally { // Always close read lock, even during failure condition so we don't have a recursive lock error. this.analysis.DataProviders.DatabaseLock.ExitReadLock(); } if (!this.featuresByDataset.ContainsKey(file.Dataset)) { this.featuresByDataset.Add(file.Dataset, new List <UMCLight>()); } this.featuresByDataset[file.Dataset] = features; file.DatasetState = DatasetInformationViewModel.DatasetStates.PersistingFeatures; ThreadSafeDispatcher.Invoke(() => this.PlotMsFeaturesCommand.RaiseCanExecuteChanged()); // TODO: We were using this log file to track speed changes for writing the database. We probably don't need it anymore. using (var logger = new StreamWriter("nhibernate_stats.txt", true)) { logger.WriteLine(); var stopWatch = new Stopwatch(); stopWatch.Start(); var scanSumProvider = this.analysis.DataProviders.ScanSummaryProviderCache.GetScanSummaryProvider( file.Dataset.DatasetId); if (scanSumProvider.IsBackedByFile) { var ssDao = this.analysis.DataProviders.ScanSummaryDao; ssDao.DeleteByDatasetId(file.Dataset.DatasetId); // Add all of the Scan Summaries for this dataset to the database, but first properly set the dataset ID ssDao.AddAllStateless( scanSumProvider.GetScanSummaries().Select( summ => { summ.DatasetId = file.Dataset.DatasetId; return(summ); }).ToList()); } progData.StepRange(100); // Cache features to database. try { this.analysis.DataProviders.DatabaseLock.EnterWriteLock(); featureCache.CacheFeatures(features, progressRpt); } catch (NonUniqueObjectException ex) { MessageBox.Show("Could not completely persist features: " + ex.Message); } catch (Exception ex) // TODO: Figure out which exception should actually be caught here { MessageBox.Show("Could not persist features to database: " + ex.Message); file.DatasetState = DatasetInformationViewModel.DatasetStates.Loaded; continue; } finally { // Always close write lock, even during failure condition so we don't have a recursive lock error. this.analysis.DataProviders.DatabaseLock.ExitWriteLock(); } stopWatch.Stop(); logger.WriteLine("Writing: {0}s", stopWatch.Elapsed.TotalSeconds); } file.DatasetState = DatasetInformationViewModel.DatasetStates.FeaturesFound; ThreadSafeDispatcher.Invoke(() => this.FindMsFeaturesCommand.RaiseCanExecuteChanged()); file.Progress = 0; } DatabaseIndexer.IndexFeatures(NHibernateUtil.Path); taskBarProgress.ShowProgress(this, false); this.ShouldShowProgress = false; }
internal void ClusterFeatures(IProgress <ProgressData> workflowProgress = null) { var taskBarProgress = TaskBarProgress.GetInstance(); taskBarProgress.ShowProgress(this, true); workflowProgress = workflowProgress ?? new Progress <ProgressData>(); IProgress <ProgressData> internalProgress = new Progress <ProgressData>(pd => { this.progress.Report((int)pd.Percent); this.ProgressPercent = pd.Percent; taskBarProgress.SetProgress(this, pd.Percent); workflowProgress.Report(pd); }); this.algorithms = this.builder.GetAlgorithmProvider(this.options); var clusterer = this.algorithms.Clusterer; clusterer.Parameters = LcmsClusteringOptions.ConvertToOmics(this.options.LcmsClusteringOptions); this.featureCache = this.analysis.DataProviders.FeatureCache; if (clusterer is PromexClusterer) { var promexClusterer = clusterer as PromexClusterer; promexClusterer.Readers = this.analysis.DataProviders.ScanSummaryProviderCache; } foreach (var dataset in this.Datasets) { if (dataset.FeaturesFound) { dataset.DatasetState = DatasetInformationViewModel.DatasetStates.Clustering; } } ThreadSafeDispatcher.Invoke(this.ClusterFeaturesCommand.RaiseCanExecuteChanged); ThreadSafeDispatcher.Invoke(this.DisplayClustersCommand.RaiseCanExecuteChanged); this.ShouldShowProgress = true; var progData = new ProgressData(internalProgress); var clusterProgress = new Progress <ProgressData>(pd => progData.Report(pd.Percent)); this.analysis.DataProviders.DatabaseLock.EnterWriteLock(); DatabaseIndexer.IndexClustersDrop(NHibernateUtil.Path); this.analysis.DataProviders.ClusterCache.ClearAllClusters(); this.analysis.DataProviders.DatabaseLock.ExitWriteLock(); // The id for a cluster - keep track here to avoid duplicates when separating by charge. var clusterCount = 0; // Here we see if we need to separate the charge... // IMS is said to require charge separation if (!this.analysis.Options.LcmsClusteringOptions.ShouldSeparateCharge) { progData.StepRange(45); var features = new List <UMCLight>(); var i = 0; var datasets = this.Datasets.Where(ds => ds.FeaturesFound).ToList(); foreach (var dataset in datasets) { this.analysis.DataProviders.DatabaseLock.EnterReadLock(); features.AddRange(this.featureCache.FindByDatasetId(dataset.DatasetId)); this.analysis.DataProviders.DatabaseLock.ExitReadLock(); progData.Report(++i, datasets.Count); } progData.StepRange(100); ClusterGroupOfFeatures(clusterer, features, ref clusterCount, clusterProgress); } else { var maxChargeState = this.featureCache.FindMaxCharge(); // Here we cluster all charge states separately. Probably IMS Data. for (var chargeState = 1; chargeState <= maxChargeState; chargeState++) { var maxPercent = ((100.0 * chargeState) / maxChargeState); // TODO: Add restriction by selected dataset ids? var features = this.featureCache.FindByCharge(chargeState); if (features.Count < 1) { continue; } progData.StepRange(maxPercent); ClusterGroupOfFeatures(clusterer, features, ref clusterCount, clusterProgress); } this.analysis.Clusters = this.analysis.DataProviders.ClusterCache.FindAll(); } this.analysis.DataProviders.DatabaseLock.EnterWriteLock(); DatabaseIndexer.IndexClusters(NHibernateUtil.Path); this.analysis.DataProviders.DatabaseLock.ExitWriteLock(); foreach (var dataset in this.Datasets) { if (dataset.DatasetState == DatasetInformationViewModel.DatasetStates.PersistingClusters) { dataset.DatasetState = DatasetInformationViewModel.DatasetStates.Clustered; } } try { // Write to file this.WriteClusterData(string.Format("{0}_crosstab.tsv", this.analysis.AnalysisName), this.analysis.Clusters); } catch (Exception ex) { var errMsg = "Error writing results to text file: " + ex.Message; Logger.PrintMessage(errMsg); // Todo: Add this: if (!GlobalSettings.AutomatedAnalysisMode) MessageBox.Show(errMsg); } ThreadSafeDispatcher.Invoke(this.ClusterFeaturesCommand.RaiseCanExecuteChanged); ThreadSafeDispatcher.Invoke(this.DisplayClustersCommand.RaiseCanExecuteChanged); taskBarProgress.ShowProgress(this, false); this.ShouldShowProgress = false; }
/// <summary> /// Perform alignment. /// </summary> /// <param name="workFlowDatasets">Datasets to run on when being called externally form this view model.</param> /// <param name="workflowProgress">The progress reporter for when this method is called externally from this view model.</param> internal void AlignToBaseline(List <DatasetInformationViewModel> workFlowDatasets = null, IProgress <ProgressData> workflowProgress = null) { // Use Promiscuous points when aligning to an AMT tag database // Do not use Promiscuous points when aligning to a baseline dataset this.analysis.Options.AlignmentOptions.UsePromiscuousPoints = !this.ShouldAlignToBaseline; // Flag whether we are aligning to an AMT tag database this.analysis.Options.AlignmentOptions.LCMSWarpOptions.AlignToMassTagDatabase = !this.ShouldAlignToBaseline; // Show the progress bar this.ShowAlignmentProgress = true; var taskBarProgress = TaskBarProgress.GetInstance(); taskBarProgress.ShowProgress(this, true); // Update algorithms and providers var featureCache = new FeatureLoader { Providers = this.analysis.DataProviders }; this.algorithms = this.builder.GetAlgorithmProvider(this.analysis.Options); ////this.algorithms.DatabaseAligner.Progress += aligner_Progress; ////this.algorithms.DatasetAligner.Progress += aligner_Progress; this.aligner.m_algorithms = this.algorithms; var baselineFeatures = new List <UMCLight>(); if (this.ShouldAlignToBaseline) { baselineFeatures = featureCache.Providers.FeatureCache.FindByDatasetId(this.selectedBaseline.DatasetId); this.SelectedBaseline.DatasetState = DatasetInformationViewModel.DatasetStates.Baseline; var priorAlignment = (from x in this.alignmentInformation where x.DatasetID == this.selectedBaseline.DatasetId select x).ToList(); if (priorAlignment.Any()) { this.alignmentInformation.Remove(priorAlignment.Single()); } } var alignmentData = new AlignmentDAOHibernate(); alignmentData.ClearAll(); var selectedFiles = workFlowDatasets ?? this.Datasets.Where(file => file.IsSelected && !file.DoingWork && (this.ShouldAlignToAMT || !file.IsBaseline)).ToList(); foreach (var file in selectedFiles) { file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligning; } workflowProgress = workflowProgress ?? new Progress <ProgressData>(); IProgress <ProgressData> totalProgress = new Progress <ProgressData>(pd => { this.AlignmentProgress = pd.Percent; workflowProgress.Report(pd); taskBarProgress.SetProgress(this, pd.Percent); }); var totalProgressData = new ProgressData(totalProgress); DatabaseIndexer.IndexClustersDrop(NHibernateUtil.Path); DatabaseIndexer.IndexFeaturesDrop(NHibernateUtil.Path); var i = 1; foreach (var file in selectedFiles) { ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged()); ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged()); ThreadSafeDispatcher.Invoke(() => this.SaveAlignmentPlotsCommand.RaiseCanExecuteChanged()); if ((file.Dataset.IsBaseline || !file.FeaturesFound) && this.ShouldAlignToBaseline) { file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned; continue; } this.analysis.DataProviders.DatabaseLock.EnterReadLock(); IList <UMCLight> features = featureCache.Providers.FeatureCache.FindByDatasetId(file.DatasetId); this.analysis.DataProviders.DatabaseLock.ExitReadLock(); AlignmentData alignment; totalProgressData.StepRange((100.0 * i++) / selectedFiles.Count); var fileInstance = file; var datasetProgress = new Progress <ProgressData>( pd => { fileInstance.Progress = pd.Percent; totalProgressData.Report(pd.Percent); }); if (this.ShouldAlignToBaseline) { // Aligning to a baseline dataset alignment = this.aligner.AlignToDataset(ref features, file.Dataset, baselineFeatures, datasetProgress); alignment.BaselineIsAmtDB = false; } else { // Aligning to a database alignment = this.aligner.AlignToDatabase(ref features, file.Dataset, this.analysis.MassTagDatabase, datasetProgress); alignment.BaselineIsAmtDB = true; } // Check if there is information from a previous alignment for this dataset. If so, replace it. If not, just add the new one. var priorAlignment = this.alignmentInformation.Where(x => x.DatasetID == alignment.DatasetID).ToList(); if (priorAlignment.Any()) { this.alignmentInformation.Remove(priorAlignment.Single()); this.alignmentInformation.Add(alignment); } else { this.alignmentInformation.Add(alignment); } file.Dataset.AlignmentData = alignment; this.analysis.DataProviders.DatabaseLock.EnterWriteLock(); featureCache.CacheFeatures(features); this.analysis.DataProviders.DatabaseLock.ExitWriteLock(); file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned; ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged()); ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged()); ThreadSafeDispatcher.Invoke(() => this.SaveAlignmentPlotsCommand.RaiseCanExecuteChanged()); file.Progress = 0; } if (this.ShouldAlignToBaseline) { this.SelectedBaseline.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned; } DatabaseIndexer.IndexFeatures(NHibernateUtil.Path); taskBarProgress.ShowProgress(this, false); this.ShowAlignmentProgress = false; this.AlignmentProgress = 0; }