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;
}
