public void GetDriftTimesFromResults()
{
try
{
var driftTable = new MeasuredDriftTimeTable(gridMeasuredDriftTimes);
var tempDriftTimePredictor = new DriftTimePredictor("tmp", driftTable.GetTableMeasuredDriftTimes(cbOffsetHighEnergySpectra.Checked), null, null, 30); // Not L10N
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.EditDriftTimePredictorDlg_btnGenerateFromDocument_Click_Finding_drift_time_values_for_peaks,
Message = string.Empty,
ProgressValue = 0
})
{
longWaitDlg.PerformWork(this, 100, broker =>
{
tempDriftTimePredictor = tempDriftTimePredictor.ChangeMeasuredDriftTimesFromResults(Program.MainWindow.Document, Program.MainWindow.DocumentFilePath, broker);
});
if (!longWaitDlg.IsCanceled && tempDriftTimePredictor != null)
{
UpdateMeasuredDriftTimesControl(tempDriftTimePredictor);
}
}
}
catch (Exception ex)
{
MessageDlg.ShowException(this, ex);
}
}
private bool GetPython()
{
try
{
using (var waitDlg = new LongWaitDlg {
ProgressValue = 0
})
{
// Short wait, because this can't possible happen fast enough to avoid
// showing progress, except in testing
waitDlg.PerformWork(this, 50, DownloadPython);
}
using (var waitDlg = new LongWaitDlg(null, false)
{
Message = Resources.PythonInstaller_GetPython_Installing_Python
})
{
waitDlg.PerformWork(this, 50, InstallPython);
}
MessageDlg.Show(this, Resources.PythonInstaller_GetPython_Python_installation_completed_);
return(true);
}
catch (Exception ex)
{
MessageDlg.ShowWithException(this, (ex.InnerException ?? ex).Message, ex);
}
return(false);
}
protected override void DoTest()
{
var longWaitDlg = ShowDialog <LongWaitDlg>(() =>
{
using (var longWaitDlg2 = new LongWaitDlg())
{
longWaitDlg2.PerformWork(SkylineWindow, 1, (ILongWaitBroker longWaitBroker) =>
{
while (!longWaitDlg2.IsCanceled)
{
longWaitDlg2.CancellationToken.WaitHandle.WaitOne();
}
});
}
});
Size originalSize = default(Size);
RunUI(() => { originalSize = longWaitDlg.Size; });
PauseForScreenShot();
SetMessage(longWaitDlg, "TheQuickBrownFoxJumpsOverTheFirstLazyDog"
+ "ThenTheQuickBrownFoxJumpsOverTheSecondLazyDog"
+ "ThenTheQuickBrownFoxJumpsOverTheThirdLazyDog");
Size newSize = default(Size);
RunUI(() => newSize = longWaitDlg.Size);
PauseForScreenShot();
Assert.AreEqual(originalSize.Width, newSize.Width);
Assert.AreNotEqual(originalSize.Height, newSize.Height);
Assert.IsTrue(newSize.Height > originalSize.Height);
OkDialog(longWaitDlg, longWaitDlg.Close);
}
public bool Open(string skypPath, IEnumerable <Server> servers, FormEx parentWindow = null)
{
try
{
var skyp = SkypFile.Create(skypPath, servers);
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.SkypSupport_Open_Downloading_Skyline_Document_Archive,
})
{
longWaitDlg.PerformWork(parentWindow ?? _skyline, 1000, progressMonitor => Download(skyp, progressMonitor, parentWindow));
if (longWaitDlg.IsCanceled)
{
return(false);
}
}
return(_skyline.OpenSharedFile(skyp.DownloadPath));
}
catch (Exception e)
{
var message = TextUtil.LineSeparate(Resources.SkypSupport_Open_Failure_opening_skyp_file_, e.Message);
MessageDlg.ShowWithException(parentWindow ?? _skyline, message, e);
return(false);
}
}
public void GetDriftTimesFromResults()
{
try
{
var driftTable = new MeasuredDriftTimeTable(gridMeasuredDriftTimes, MeasuredDriftTimeSequence.TargetResolver);
bool useHighEnergyOffset = cbOffsetHighEnergySpectra.Checked;
var tempDriftTimePredictor = new IonMobilityPredictor(@"tmp", driftTable.GetTableMeasuredIonMobility(useHighEnergyOffset, Units), null, null, IonMobilityWindowWidthCalculator.IonMobilityPeakWidthType.resolving_power, 30, 0, 0);
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.EditDriftTimePredictorDlg_GetDriftTimesFromResults_Finding_ion_mobility_values_for_peaks,
Message = string.Empty,
ProgressValue = 0
})
{
longWaitDlg.PerformWork(this, 100, broker =>
{
tempDriftTimePredictor = tempDriftTimePredictor.ChangeMeasuredIonMobilityValuesFromResults(Program.MainWindow.Document, Program.MainWindow.DocumentFilePath, useHighEnergyOffset, broker);
});
if (!longWaitDlg.IsCanceled && tempDriftTimePredictor != null)
{
// Set display units based on what we found in the data
UpdateMeasuredDriftTimesControl(tempDriftTimePredictor);
}
}
}
catch (Exception ex)
{
MessageDlg.ShowException(this, ex);
}
}
protected override void DoTest()
{
// Test non-cancellable dialog.
RunUI(() => // Must start from same thread as Program.MainWindow
{
using (var longWaitDlg = new LongWaitDlg(null, false))
{
longWaitDlg.PerformWork(Program.MainWindow, 20, () =>
{
for (int i = 0; i < 100; i += 10)
{
Thread.Sleep(5);
longWaitDlg.ProgressValue = i;
}
});
}
});
// Show cancellable dialog if we're running this Form from SkylineTester.
if (Program.PauseForms != null && Program.PauseForms.Contains(typeof(LongWaitDlg).Name))
{
RunUI(() => // Must start from same thread as Program.MainWindow
{
using (var longWaitDlg = new LongWaitDlg())
{
longWaitDlg.PerformWork(Program.MainWindow, 0, () =>
{
WaitForOpenForm <LongWaitDlg>();
longWaitDlg.CancelButton.PerformClick();
});
Assert.IsTrue(longWaitDlg.IsCanceled);
}
});
}
}
public void CommitBatchModifyDocument(string description)
{
if (null == _batchChangesOriginalDocument)
{
throw new InvalidOperationException();
}
string message = Resources.DataGridViewPasteHandler_EndDeferSettingsChangesOnDocument_Updating_settings;
SkylineWindow.ModifyDocument(description, document =>
{
VerifyDocumentCurrent(_batchChangesOriginalDocument, document);
using (var longWaitDlg = new LongWaitDlg
{
Message = message
})
{
SrmDocument newDocument = null;
longWaitDlg.PerformWork(SkylineWindow, 1000, progressMonitor =>
{
var srmSettingsChangeMonitor = new SrmSettingsChangeMonitor(progressMonitor,
message);
newDocument = _document.EndDeferSettingsChanges(_batchChangesOriginalDocument.Settings, srmSettingsChangeMonitor);
});
return(newDocument);
}
});
_batchChangesOriginalDocument = null;
DocumentChangedEventHandler(_documentContainer, new DocumentChangedEventArgs(_document));
}
public void ShowRefineDlg()
{
using (var refineDlg = new RefineDlg(SkylineWindow))
{
if (refineDlg.ShowDialog(SkylineWindow) == DialogResult.OK)
{
ModifyDocument(Resources.SkylineWindow_ShowRefineDlg_Refine,
doc =>
{
using (var longWaitDlg = new LongWaitDlg(SkylineWindow))
{
longWaitDlg.Message = Resources.SkylineWindow_ShowRefineDlg_Refining_document;
longWaitDlg.PerformWork(refineDlg, 1000, progressMonitor =>
{
var srmSettingsChangeMonitor =
new SrmSettingsChangeMonitor(progressMonitor, Resources.SkylineWindow_ShowRefineDlg_Refining_document, SkylineWindow, doc);
doc = refineDlg.RefinementSettings.Refine(doc, srmSettingsChangeMonitor);
});
}
return(doc);
}, refineDlg.FormSettings.EntryCreator.Create);
}
}
}
/// <summary>
/// Uses an <see cref="IToolStoreClient"/> to download (zip files) for each of the tools selected in the form's checklistbox.
/// Returns a collection of tools to be updated.
/// </summary>
private ICollection <ToolUpdateInfo> GetToolsToUpdate()
{
labelOperation.Text = Resources.ToolUpdatesDlg_GetTools_Downloading_Updates;
var toolsToDownload = new Collection <ToolUpdateInfo>();
var toolList = _tools.Keys.ToList();
// get tools to update based on which ones are checked
foreach (int index in checkedListBoxTools.CheckedIndices)
{
toolsToDownload.Add(toolList[index]);
}
ICollection <ToolUpdateInfo> successfulDownloads = null;
ICollection <string> failedDownloads = null;
using (var dlg = new LongWaitDlg {
Message = Resources.ToolUpdatesDlg_GetToolsToUpdate_Downloading_Updates
})
{
dlg.PerformWork(this, 1000,
longWaitBroker =>
DownloadTools(longWaitBroker, toolsToDownload, out successfulDownloads,
out failedDownloads));
}
DisplayDownloadSummary(failedDownloads);
return(successfulDownloads);
}
private void RefreshDocument()
{
Document = Program.MainWindow.Document;
using (var longWaitDlg = new LongWaitDlg())
{
longWaitDlg.PerformWork(this, 200, pm =>
{
foreach (var peakBoundaries in _peakBoundaryList)
{
string comparisonName = peakBoundaries.Name;
BeginInvoke((Action)(() =>
{
longWaitDlg.Text = string.Format(Resources.ComparePeakPickingDlg_RefreshDocument_Refresh__0_, comparisonName);
longWaitDlg.ProgressValue = 0;
}));
if (pm.IsCanceled)
{
break;
}
peakBoundaries.GenerateComparison(Document, pm);
}
});
}
UpdateAll();
btnRefresh.Enabled = false;
}
private MsDataFilePath[] GetWiffSubPaths(string filePath)
{
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.ImportResultsDlg_GetWiffSubPaths_Sample_Names,
Message = string.Format(Resources.ImportResultsDlg_GetWiffSubPaths_Reading_sample_names_from__0__,
Path.GetFileName(filePath))
})
{
string[] dataIds = null;
try
{
longWaitDlg.PerformWork(this, 800, () => dataIds = MsDataFileImpl.ReadIds(filePath));
}
catch (Exception x)
{
string message = TextUtil.LineSeparate(
string.Format(Resources.ImportResultsDlg_GetWiffSubPaths_An_error_occurred_attempting_to_read_sample_information_from_the_file__0__, filePath),
Resources.ImportResultsDlg_GetWiffSubPaths_The_file_may_be_corrupted_missing_or_the_correct_libraries_may_not_be_installed,
x.Message);
MessageDlg.ShowWithException(this, message, x);
}
return(DataSourceUtil.GetWiffSubPaths(filePath, dataIds, ChooseSamples));
}
}
public void DownloadSelectedTool()
{
try
{
string identifier = _tools[listBoxTools.SelectedIndex].Identifier;
using (var dlg = new LongWaitDlg {
ProgressValue = 0, Message = string.Format(Resources.ToolStoreDlg_DownloadSelectedTool_Downloading__0_, _tools[listBoxTools.SelectedIndex].Name)
})
{
dlg.PerformWork(this, 500, progressMonitor => DownloadPath = _toolStoreClient.GetToolZipFile(progressMonitor, identifier, Path.GetTempPath()));
if (!dlg.IsCanceled)
{
DialogResult = DialogResult.OK;
}
}
}
catch (TargetInvocationException ex)
{
if (ex.InnerException is ToolExecutionException || ex.InnerException is WebException)
{
MessageDlg.ShowException(this, ex);
}
else
{
throw;
}
}
}
private bool LoadPeptideSearchLibrary(LibrarySpec docLibSpec)
{
if (docLibSpec == null)
{
return(false);
}
using (var longWait = new LongWaitDlg
{
Text = Resources.BuildPeptideSearchLibraryControl_LoadPeptideSearchLibrary_Loading_Library
})
{
try
{
var status = longWait.PerformWork(WizardForm, 800, monitor => ImportPeptideSearch.LoadPeptideSearchLibrary(LibraryManager, docLibSpec, monitor));
if (status.IsError)
{
MessageDlg.ShowException(WizardForm, status.ErrorException);
}
}
catch (Exception x)
{
MessageDlg.ShowWithException(WizardForm,
TextUtil.LineSeparate(string.Format(Resources.BuildPeptideSearchLibraryControl_LoadPeptideSearchLibrary_An_error_occurred_attempting_to_import_the__0__library_,
docLibSpec.Name), x.Message), x);
}
}
return(ImportPeptideSearch.HasDocLib);
}
private bool GetR()
{
try
{
using (var dlg = new LongWaitDlg {
Message = Resources.RInstaller_InstallR_Downloading_R, ProgressValue = 0
})
{
// Short wait, because this can't possible happen fast enough to avoid
// showing progress, except in testing
dlg.PerformWork(this, 50, DownloadR);
}
using (var dlg = new LongWaitDlg(null, false)
{
Message = Resources.RInstaller_GetR_Installing_R
})
{
dlg.PerformWork(this, 50, InstallR);
}
MessageDlg.Show(this, Resources.RInstaller_GetR_R_installation_complete_);
}
catch (TargetInvocationException ex)
{
if (ex.InnerException is ToolExecutionException)
{
MessageDlg.ShowException(this, ex);
return(false);
}
throw;
}
return(true);
}
private bool GetPackages()
{
try
{
using (var dlg = new LongWaitDlg(null, false)
{
Message = Resources.RInstaller_GetPAckages_Installing_Packages
})
{
dlg.PerformWork(this, 1000, InstallPackages);
}
}
catch (TargetInvocationException ex)
{
//Win32Exception is thrown when the user does not ok Administrative Privileges
if (ex.InnerException is ToolExecutionException || ex.InnerException is System.ComponentModel.Win32Exception)
{
MessageDlg.ShowException(this, ex);
return(false);
}
else
{
throw;
}
}
return(true);
}
private void ModifyDocument(string message, Action <SrmSettingsChangeMonitor> modifyAction)
{
using (var longWaitDlg = new LongWaitDlg(Program.MainWindow)
{
Text = Text, // Same as dialog box
Message = message,
ProgressValue = 0
})
{
try
{
longWaitDlg.PerformWork(this, 800, progressMonitor =>
{
using (var settingsChangeMonitor = new SrmSettingsChangeMonitor(progressMonitor, message, Program.MainWindow))
{
modifyAction(settingsChangeMonitor);
}
});
}
catch (OperationCanceledException)
{
// SrmSettingsChangeMonitor can throw OperationCancelledException without LongWaitDlg knowing about it.
}
}
}
public bool WriteChromatograms(string filePath)
{
var fileNames = (from object fileName in checkedListVars.CheckedItems select fileName.ToString()).ToList();
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.ExportChromatogramDlg_OkDialog_Exporting_Chromatograms,
})
{
try
{
longWaitDlg.PerformWork(this, 1000,
broker => WriteChromatograms(filePath,
broker,
fileNames,
LocalizationHelper.CurrentCulture,
_chromExtractors,
_chromSources));
if (longWaitDlg.IsCanceled)
{
return(false);
}
}
catch (Exception x)
{
var message = TextUtil.LineSeparate(string.Format(Resources.ExportChromatogramDlg_OkDialog_Failed_attempting_to_save_chromatograms_to__0__, filePath),
x.Message);
MessageDlg.ShowWithException(this, message, x);
}
}
return(true);
}
private bool GetPip()
{
try
{
using (var dlg = new LongWaitDlg {
ProgressValue = 0
})
{
// Short wait, because this can't possible happen fast enough to avoid
// showing progress, except in testing
dlg.PerformWork(this, 50, DownloadPip);
}
using (var dlg = new LongWaitDlg(null, false)
{
Message = Resources.PythonInstaller_GetPip_Installing_Pip
})
{
dlg.PerformWork(this, 50, InstallPip);
}
}
catch (TargetInvocationException ex)
{
if (ex.InnerException is ToolExecutionException)
{
MessageDlg.ShowException(this, ex);
return(false);
}
throw;
}
return(true);
}
public Tuple <Clusterer, ClusteredReportResults, ReportColorScheme> GetClusteredResults()
{
Tuple <Clusterer, ClusteredReportResults, ReportColorScheme> resultsTuple = null;
try
{
using (var longWaitDlg = new LongWaitDlg())
{
longWaitDlg.PerformWork(FormUtil.FindTopLevelOwner(this), 1000,
broker => { resultsTuple = GetClusteredResultsBackground(broker); });
if (longWaitDlg.IsCanceled)
{
return(null);
}
}
}
catch (Exception exception)
{
MessageDlg.ShowWithException(FormUtil.FindTopLevelOwner(this), Resources.DataboundGridControl_GetClusteredResults_An_error_occured_while_performing_clustering_, exception);
return(null);
}
if (resultsTuple == null)
{
MessageDlg.Show(FormUtil.FindTopLevelOwner(this),
Resources.DataboundGridControl_GetClusteredResults_Unable_to_choose_a_set_of_columns_to_use_for_hierarchical_clustering_);
return(null);
}
return(resultsTuple);
}
public bool ExportAnnotations(string filename)
{
var settings = GetExportAnnotationSettings();
bool success = false;
try
{
var documentAnnotations = new DocumentAnnotations(Document);
using (var longWaitDlg = new LongWaitDlg())
{
longWaitDlg.PerformWork(this, 1000, broker =>
{
using (var fileSaver = new FileSaver(filename))
{
documentAnnotations.WriteAnnotationsToFile(broker.CancellationToken, settings, fileSaver.SafeName);
fileSaver.Commit();
}
success = true;
});
}
}
catch (Exception e)
{
MessageDlg.ShowException(this, e);
return(false);
}
return(success);
}
public override bool RunLongJob(Control owner, Action <IProgressMonitor> job)
{
using (var longWaitDlg = new LongWaitDlg())
{
var status = longWaitDlg.PerformWork(FormUtil.FindTopLevelOwner(owner), 1000, job);
return(status.IsComplete);
}
}
private void RunOnBackgroundThread(Action <ILongWaitBroker> action)
{
using (var longWaitDlg = new LongWaitDlg())
{
InitLongWaitDlg(longWaitDlg);
longWaitDlg.PerformWork(ParentControl, DelayMillis, action);
}
}
private void RefreshStatus()
{
if (File.Exists(textPath.Text))
{
btnAddFastaFile.Enabled = true;
ProteomeDb proteomeDb = null;
int proteinCount = 0;
try
{
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.BuildBackgroundProteomeDlg_RefreshStatus_Loading_Proteome_File,
Message =
string.Format(
Resources.BuildBackgroundProteomeDlg_RefreshStatus_Loading_protein_information_from__0__,
textPath.Text)
})
{
longWaitDlg.PerformWork(this, 1000, () =>
{
proteomeDb = ProteomeDb.OpenProteomeDb(textPath.Text);
if (proteomeDb != null)
{
proteinCount = proteomeDb.GetProteinCount(); // This can be a lengthy operation on a large protdb, do it within the longwait
}
});
}
if (proteomeDb == null)
{
throw new Exception();
}
tbxStatus.Text =
string.Format(
Resources.BuildBackgroundProteomeDlg_RefreshStatus_The_proteome_file_contains__0__proteins,
proteinCount);
}
catch (Exception)
{
tbxStatus.Text = Resources.BuildBackgroundProteomeDlg_OkDialog_The_proteome_file_is_not_valid;
btnAddFastaFile.Enabled = false;
}
finally
{
if (null != proteomeDb)
{
proteomeDb.Dispose();
}
}
textPath.ForeColor = Color.Black;
}
else
{
btnAddFastaFile.Enabled = false;
tbxStatus.Text = Resources.BuildBackgroundProteomeDlg_RefreshStatus_Click_the_Open_button_to_choose_an_existing_proteome_file_or_click_the_Create_button_to_create_a_new_proteome_file;
textPath.ForeColor = string.IsNullOrEmpty(textPath.Text) ? Color.Black : Color.Red;
}
}
// find matches using the background proteome
public void UseBackgroundProteome()
{
if (_parent.Document.Settings.PeptideSettings.BackgroundProteome.Equals(BackgroundProteome.NONE))
{
MessageDlg.Show(this, Resources.AssociateProteinsDlg_UseBackgroundProteome_No_background_proteome_defined);
return;
}
_isFasta = false;
_fileName = _parent.Document.Settings.PeptideSettings.BackgroundProteome.DatabasePath;
checkBoxListMatches.Items.Clear();
BackgroundProteome proteome = _parent.Document.Settings.PeptideSettings.BackgroundProteome;
var proteinAssociations = new List <KeyValuePair <FastaSequence, List <PeptideDocNode> > >();
var peptidesForMatching = ListPeptidesForMatching();
IDictionary <String, List <Protein> > proteinsWithSequences = null;
using (var longWaitDlg = new LongWaitDlg())
{
longWaitDlg.PerformWork(this, 1000, longWaitBroker =>
{
using (var proteomeDb = proteome.OpenProteomeDb(longWaitBroker.CancellationToken))
{
proteinsWithSequences = proteomeDb.GetDigestion()
.GetProteinsWithSequences(peptidesForMatching.Select(pep => pep.Peptide.Target.Sequence));
}
});
}
if (proteinsWithSequences == null)
{
return;
}
HashSet <String> processedProteinSequence = new HashSet <string>();
foreach (var entry in proteinsWithSequences)
{
foreach (var protein in entry.Value)
{
if (!processedProteinSequence.Add(protein.Sequence))
{
continue;
}
var matches = peptidesForMatching.Where(pep => protein.Sequence.Contains(pep.Peptide.Target.Sequence)).ToList();
if (matches.Count == 0)
{
continue;
}
FastaSequence fastaSequence = proteome.MakeFastaSequence(protein);
if (fastaSequence != null)
{
proteinAssociations.Add(new KeyValuePair <FastaSequence, List <PeptideDocNode> >(fastaSequence, matches));
}
}
}
SetCheckBoxListItems(proteinAssociations,
Resources.AssociateProteinsDlg_UseBackgroundProteome_No_matches_were_found_using_the_background_proteome_);
}
private void RefreshStatus()
{
if (File.Exists(textPath.Text))
{
btnAddFastaFile.Enabled = true;
ProteomeDb proteomeDb = null;
try
{
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.BuildBackgroundProteomeDlg_RefreshStatus_Loading_Proteome_File,
Message =
string.Format(
Resources.BuildBackgroundProteomeDlg_RefreshStatus_Loading_protein_information_from__0__,
textPath.Text)
})
{
longWaitDlg.PerformWork(this, 1000, () => proteomeDb = ProteomeDb.OpenProteomeDb(textPath.Text));
}
if (proteomeDb == null)
{
throw new Exception();
}
int proteinCount = proteomeDb.GetProteinCount();
var digestions = proteomeDb.ListDigestions();
tbxStatus.Text =
string.Format(
Resources.BuildBackgroundProteomeDlg_RefreshStatus_The_proteome_file_contains__0__proteins,
proteinCount);
if (proteinCount != 0 && digestions.Count > 0)
{
tbxStatus.Text = TextUtil.LineSeparate(tbxStatus.Text,
Resources.BuildBackgroundProteomeDlg_RefreshStatus_The_proteome_has_already_been_digested);
}
}
catch (Exception)
{
tbxStatus.Text = Resources.BuildBackgroundProteomeDlg_OkDialog_The_proteome_file_is_not_valid;
btnAddFastaFile.Enabled = false;
}
finally
{
if (null != proteomeDb)
{
proteomeDb.Dispose();
}
}
}
else
{
btnAddFastaFile.Enabled = false;
tbxStatus.Text = Resources.BuildBackgroundProteomeDlg_RefreshStatus_Click_the_Open_button_to_choose_an_existing_proteome_file_or_click_the_Create_button_to_create_a_new_proteome_file;
}
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
var isotopeModification = _driverIsotopeModification.SelectedItem;
if (isotopeModification == null)
{
helper.ShowTextBoxError(comboIsotopeModification, Resources.MessageBoxHelper_ValidateNameTextBox__0__cannot_be_empty);
return;
}
lock (SkylineWindow.GetDocumentChangeLock())
{
var originalDocument = SkylineWindow.Document;
var deferSettingsChangeDoc = originalDocument.BeginDeferSettingsChanges();
var globalStaticMods = Settings.Default.StaticModList.ToList();
var globalIsotopeMods = Settings.Default.HeavyModList.ToList();
var newDocument = deferSettingsChangeDoc;
var simplePermutation = SimplePermutation;
using (var longWaitDlg = new LongWaitDlg()
{
Text = Resources.PermuteIsotopeModificationsDlg_OkDialog_Permuting_Isotope_Modifications
})
{
longWaitDlg.PerformWork(this, 1000, progressMonitor =>
{
var isotopePermuter = new IsotopeModificationPermuter(isotopeModification,
simplePermutation, IsotopeLabelType.heavy, globalStaticMods, globalIsotopeMods);
newDocument = isotopePermuter.PermuteIsotopeModifications(progressMonitor, newDocument);
if (!ReferenceEquals(newDocument, deferSettingsChangeDoc))
{
var settingsChangeMonitor = new SrmSettingsChangeMonitor(progressMonitor, Resources.PermuteIsotopeModificationsDlg_OkDialog_Updating_settings);
newDocument = newDocument.EndDeferSettingsChanges(originalDocument, settingsChangeMonitor);
}
});
if (longWaitDlg.IsCanceled)
{
return;
}
}
if (!ReferenceEquals(newDocument, deferSettingsChangeDoc))
{
SkylineWindow.ModifyDocument(Resources.PermuteIsotopeModificationsDlg_OkDialog_Permute_isotope_modifications, doc =>
{
// This will be true because we have acquired the lock on SkylineWindow.DocumentChangeLock()
Assume.IsTrue(ReferenceEquals(doc, originalDocument));
return(newDocument);
}, docPair => GetAuditLogEntry(docPair, isotopeModification, simplePermutation));
}
DialogResult = DialogResult.OK;
}
}
public void AddFastaFile(string fastaFilePath)
{
String databasePath = textPath.Text;
Settings.Default.FastaDirectory = Path.GetDirectoryName(fastaFilePath);
int duplicateSequenceCount = 0;
using (var longWaitDlg = new LongWaitDlg {
ProgressValue = 0
})
{
try
{
longWaitDlg.PerformWork(this, 0, progressMonitor =>
{
ProteomeDb proteomeDb = File.Exists(databasePath)
? ProteomeDb.OpenProteomeDb(databasePath)
: ProteomeDb.CreateProteomeDb(databasePath);
using (proteomeDb)
{
using (var reader = File.OpenText(fastaFilePath))
{
IProgressStatus status = new ProgressStatus(longWaitDlg.Message);
proteomeDb.AddFastaFile(reader, progressMonitor, ref status, false, out duplicateSequenceCount);
}
}
});
}
catch (Exception x)
{
var message = TextUtil.LineSeparate(string.Format(Resources.BuildBackgroundProteomeDlg_AddFastaFile_An_error_occurred_attempting_to_add_the_FASTA_file__0__,
fastaFilePath), x.Message);
MessageDlg.ShowWithException(this, message, x);
return;
}
}
string path = Path.GetFileName(fastaFilePath);
if (path != null)
{
listboxFasta.Items.Add(path);
}
RefreshStatus();
if (duplicateSequenceCount > 0)
{
MessageDlg.Show(this, string.Format(Resources.BuildBackgroundProteomeDlg_AddFastaFile_The_added_file_included__0__repeated_protein_sequences__Their_names_were_added_as_aliases_to_ensure_the_protein_list_contains_only_one_copy_of_each_sequence_, duplicateSequenceCount));
}
}
public void ShowExportSpectralLibraryDialog(Control owner)
{
if (Document.MoleculeTransitionGroupCount == 0)
{
MessageDlg.Show(owner, Resources.SkylineWindow_ShowExportSpectralLibraryDialog_The_document_must_contain_at_least_one_peptide_precursor_to_export_a_spectral_library_);
return;
}
else if (!Document.Settings.HasResults)
{
MessageDlg.Show(owner, Resources.SkylineWindow_ShowExportSpectralLibraryDialog_The_document_must_contain_results_to_export_a_spectral_library_);
return;
}
using (var dlg = new SaveFileDialog
{
Title = Resources.SkylineWindow_ShowExportSpectralLibraryDialog_Export_Spectral_Library,
OverwritePrompt = true,
DefaultExt = BiblioSpecLiteSpec.EXT,
Filter = TextUtil.FileDialogFiltersAll(BiblioSpecLiteSpec.FILTER_BLIB)
})
{
if (!string.IsNullOrEmpty(DocumentFilePath))
{
dlg.InitialDirectory = Path.GetDirectoryName(DocumentFilePath);
}
if (dlg.ShowDialog(owner) == DialogResult.Cancel)
{
return;
}
try
{
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.SkylineWindow_ShowExportSpectralLibraryDialog_Export_Spectral_Library,
Message = string.Format(Resources.SkylineWindow_ShowExportSpectralLibraryDialog_Exporting_spectral_library__0____, Path.GetFileName(dlg.FileName))
})
{
longWaitDlg.PerformWork(owner, 800, monitor => ExportSpectralLibrary(dlg.FileName, monitor));
}
}
catch (Exception x)
{
MessageDlg.ShowWithException(owner, TextUtil.LineSeparate(string.Format(Resources.SkylineWindow_ShowExportSpectralLibraryDialog_Failed_exporting_spectral_library_to__0__, dlg.FileName), x.Message), x);
}
}
}
public void OkDialog()
{
MessageBoxHelper helper = new MessageBoxHelper(this);
string serverName;
if (!helper.ValidateNameTextBox(textServerURL, out serverName))
{
return;
}
Uri uriServer = PanoramaUtil.ServerNameToUri(serverName);
if (uriServer == null)
{
helper.ShowTextBoxError(textServerURL, Resources.EditServerDlg_OkDialog_The_text__0__is_not_a_valid_server_name_, serverName);
return;
}
var panoramaClient = PanoramaClient ?? new WebPanoramaClient(uriServer);
using (var waitDlg = new LongWaitDlg {
Text = Resources.EditServerDlg_OkDialog_Verifying_server_information
})
{
try
{
waitDlg.PerformWork(this, 1000, () => PanoramaUtil.VerifyServerInformation(panoramaClient, Username, Password));
}
catch (Exception x)
{
helper.ShowTextBoxError(textServerURL, x.Message);
return;
}
}
Uri updatedUri = panoramaClient.ServerUri ?? uriServer;
if (_existing.Contains(server => !ReferenceEquals(_server, server) && Equals(updatedUri, server.URI)))
{
helper.ShowTextBoxError(textServerURL, Resources.EditServerDlg_OkDialog_The_server__0__already_exists_, uriServer.Host);
return;
}
_server = new Server(updatedUri, Username, Password);
DialogResult = DialogResult.OK;
}
public Database GetDatabase(Control owner)
{
if (_database == null)
{
var status = new ProgressStatus(Resources.ExportReportDlg_GetDatabase_Generating_Report_Data);
using (var longWait = new LongWaitDlg
{
Text = status.Message,
Message = Resources.ExportReportDlg_GetDatabase_Analyzing_document
})
{
longWait.PerformWork(owner, 1500, broker => EnsureDatabase(broker, 100, ref status));
}
}
return(_database);
}
public void LongWaitDlgAction(SkylineWindow skylineWindow)
{
skylineWindow.ResetDefaultSettings();
try
{
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.ActionTutorial_LongWaitDlgAction_Downloading_Tutorial_Zip_File,
Message =
String.Format(
Resources
.ActionTutorial_LongWaitDlgAction_Downloading_to___0__1_Tutorial_will_open_in_browser_when_download_is_complete_,
getTempPath(), Environment.NewLine),
ProgressValue = 0
})
{
longWaitDlg.PerformWork(skylineWindow, 1000, DownloadTutorials);
if (longWaitDlg.IsCanceled)
{
return;
}
}
using (var longWaitDlg = new LongWaitDlg
{
Text =
Resources.ActionTutorial_LongWaitDlgAction_Extracting_Tutorial_Zip_File_in_the_same_directory_,
ProgressValue = 0
})
{
longWaitDlg.PerformWork(skylineWindow, 1000, ExtractTutorial);
}
}
catch (Exception exception)
{
MessageDlg.ShowWithException(Program.MainWindow, string.Format(Resources.ActionTutorial_DownloadTutorials_Error__0_, exception.Message), exception);
}
}