public void OkDialog()
{
var helper = new MessageBoxHelper(this);
double maxArea = 0;
if (!string.IsNullOrEmpty(textMaxArea.Text))
{
if (!helper.ValidateDecimalTextBox(textMaxArea, 5, double.MaxValue, out maxArea))
return;
}
bool decimalCv = cbDecimalCvs.Checked;
double maxCv = 0;
if (!string.IsNullOrEmpty(textMaxCv.Text))
{
double maxAllowed = 500;
if (decimalCv)
maxAllowed /= 100;
if (!helper.ValidateDecimalTextBox(textMaxCv, 0, maxAllowed, out maxCv))
return;
}
Settings.Default.PeakAreaMaxArea = maxArea;
Settings.Default.PeakAreaMaxCv = maxCv;
Settings.Default.PeakDecimalCv = decimalCv;
Settings.Default.AreaFontSize = GraphFontSize.GetFontSize(textSizeComboBox).PointSize;
DialogResult = DialogResult.OK;
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
string name;
if (!helper.ValidateNameTextBox(textName, out name))
return;
foreach (SrmSettings settings in Settings.Default.SrmSettingsList)
{
if (name == settings.Name)
{
var message = TextUtil.LineSeparate(String.Format(Resources.SaveSettingsDlg_OnClosing_The_name__0__already_exists, name),
Resources.SaveSettingsDlg_OnClosing_Do_you_want_to_overwrite_the_existing_settings);
var result = MessageBox.Show(this, message, Program.Name, MessageBoxButtons.OKCancel, MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2);
if (result == DialogResult.OK)
break;
textName.Focus();
return;
}
}
SaveName = name;
DialogResult = DialogResult.OK;
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
double[] timeWindows;
if (!helper.ValidateDecimalListTextBox(textTimeWindows,
PeptidePrediction.MIN_MEASURED_RT_WINDOW,
PeptidePrediction.MAX_MEASURED_RT_WINDOW,
out timeWindows))
return;
int primaryTransitionCount = 0;
if (!string.IsNullOrEmpty(textPrimaryTransitionCount.Text))
{
if (!helper.ValidateNumberTextBox(textPrimaryTransitionCount,
AbstractMassListExporter.PRIMARY_COUNT_MIN,
AbstractMassListExporter.PRIMARY_COUNT_MAX,
out primaryTransitionCount))
return;
}
Array.Sort(timeWindows);
RTScheduleGraphPane.ScheduleWindows = timeWindows;
RTScheduleGraphPane.PrimaryTransitionCount = primaryTransitionCount;
DialogResult = DialogResult.OK;
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
if (!helper.ValidateDecimalTextBox(textThreshold, 0, double.MaxValue, out _threshold))
return;
DialogResult = DialogResult.OK;
Close();
}
public BuildBackgroundProteomeDlg(IEnumerable<BackgroundProteomeSpec> existing)
{
InitializeComponent();
Icon = Resources.Skyline;
_existing = existing;
_messageBoxHelper = new MessageBoxHelper(this);
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
int standardCount;
if (!helper.ValidateNumberTextBox(textPeptideCount, CalibrateIrtDlg.MIN_STANDARD_PEPTIDES, _peptideCount, out standardCount))
return;
DialogResult = DialogResult.OK;
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
if (!helper.ValidateDecimalTextBox(textThreshold, 0, 1.0, out _threshold))
return;
// Round to precision used in calculating optimal regressions
_threshold = Math.Round(_threshold, RetentionTimeRegression.ThresholdPrecision);
DialogResult = DialogResult.OK;
Close();
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
int lineWidth;
if (!helper.ValidateNumberTextBox(textLineWidth, 1, 5, out lineWidth))
return;
Settings.Default.SpectrumLineWidth = lineWidth;
Settings.Default.SpectrumFontSize = GraphFontSize.GetFontSize(textSizeComboBox).PointSize;
DialogResult = DialogResult.OK;
}
public TransitionSettings GetTransitionSettings(Form parent)
{
var helper = new MessageBoxHelper(parent);
TransitionSettings settings = SkylineWindow.DocumentUI.Settings.TransitionSettings;
// Validate and store filter settings
int[] precursorCharges;
if (!helper.ValidateNumberListTextBox(txtPrecursorCharges, TransitionGroup.MIN_PRECURSOR_CHARGE, TransitionGroup.MAX_PRECURSOR_CHARGE, out precursorCharges))
return null;
precursorCharges = precursorCharges.Distinct().ToArray();
int[] productCharges;
if (!helper.ValidateNumberListTextBox(txtIonCharges, Transition.MIN_PRODUCT_CHARGE, Transition.MAX_PRODUCT_CHARGE, out productCharges))
return null;
productCharges = productCharges.Distinct().ToArray();
IonType[] types = IonTypes;
if (types.Length == 0)
{
helper.ShowTextBoxError(txtIonTypes, Resources.TransitionSettingsUI_OkDialog_Ion_types_must_contain_a_comma_separated_list_of_ion_types_a_b_c_x_y_z_and_p_for_precursor);
return null;
}
types = types.Distinct().ToArray();
bool exclusionUseDIAWindow = cbExclusionUseDIAWindow.Visible && cbExclusionUseDIAWindow.Checked;
var filter = new TransitionFilter(precursorCharges, productCharges, types, settings.Filter.FragmentRangeFirstName, settings.Filter.FragmentRangeLastName,
settings.Filter.MeasuredIons, settings.Filter.PrecursorMzWindow, exclusionUseDIAWindow, settings.Filter.AutoSelect);
Helpers.AssignIfEquals(ref filter, settings.Filter);
// Validate and store library settings
double ionMatchTolerance;
if (!helper.ValidateDecimalTextBox(txtTolerance, TransitionLibraries.MIN_MATCH_TOLERANCE, TransitionLibraries.MAX_MATCH_TOLERANCE, out ionMatchTolerance))
return null;
int ionCount = settings.Libraries.IonCount;
if (!helper.ValidateNumberTextBox(txtIonCount, TransitionLibraries.MIN_ION_COUNT, TransitionLibraries.MAX_ION_COUNT, out ionCount))
return null;
TransitionLibraryPick pick = (settings.Libraries.Pick != TransitionLibraryPick.none) ? settings.Libraries.Pick : TransitionLibraryPick.all;
var libraries = new TransitionLibraries(ionMatchTolerance, ionCount, pick);
Helpers.AssignIfEquals(ref libraries, settings.Libraries);
return new TransitionSettings(settings.Prediction, filter, libraries, settings.Integration, settings.Instrument, settings.FullScan);
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
int lineWidth;
if (!helper.ValidateNumberTextBox(textLineWidth, 1, 5, out lineWidth))
return;
double timeRange = 0;
if (!string.IsNullOrEmpty(textTimeRange.Text))
{
if (!helper.ValidateDecimalTextBox(textTimeRange, 0.05, 15.0, out timeRange))
return;
}
bool relative = cbRelative.Checked;
double minIntensity = 0;
if (!string.IsNullOrEmpty(textMinIntensity.Text))
{
if (!helper.ValidateDecimalTextBox(textMinIntensity, 0, double.MaxValue, out minIntensity))
return;
}
double maxIntensity = 0;
if (!string.IsNullOrEmpty(textMaxIntensity.Text))
{
if (!helper.ValidateDecimalTextBox(textMaxIntensity, 5, double.MaxValue, out maxIntensity))
return;
}
Settings.Default.ChromatogramLineWidth = lineWidth;
Settings.Default.ChromatogramFontSize = GraphFontSize.GetFontSize(textSizeComboBox).PointSize;
Settings.Default.ChromatogramTimeRange = timeRange;
Settings.Default.ChromatogramTimeRangeRelative = relative;
Settings.Default.ChromatogramMinIntensity = minIntensity;
Settings.Default.ChromatogramMaxIntensity = maxIntensity;
if (maxIntensity != 0)
Settings.Default.LockYChrom = true;
Settings.Default.AllowLabelOverlap = cbShowOverlappingLabels.Checked;
Settings.Default.AllowMultiplePeptideSelection = cbShowMultiplePeptides.Checked;
DialogResult = DialogResult.OK;
}
public void OkDialog(string outputPath)
{
var helper = new MessageBoxHelper(this, true);
_instrumentType = comboInstrument.SelectedItem.ToString();
// Use variable for document to export, since code below may modify the document.
SrmDocument documentExport = _document;
string templateName = null;
if (_fileType == ExportFileType.Method)
{
// Check for instruments that cannot do DIA.
if (IsDia)
{
if (Equals(InstrumentType, ExportInstrumentType.AGILENT_TOF) ||
Equals(InstrumentType, ExportInstrumentType.ABI_TOF) ||
Equals(InstrumentType, ExportInstrumentType.THERMO_LTQ))
{
helper.ShowTextBoxError(textTemplateFile, Resources.ExportMethodDlg_OkDialog_Export_of_DIA_method_is_not_supported_for__0__, InstrumentType);
return;
}
}
templateName = textTemplateFile.Text;
if (string.IsNullOrEmpty(templateName))
{
helper.ShowTextBoxError(textTemplateFile, Resources.ExportMethodDlg_OkDialog_A_template_file_is_required_to_export_a_method);
return;
}
if ((Equals(InstrumentType, ExportInstrumentType.AGILENT6400) ||
Equals(InstrumentType, ExportInstrumentType.BRUKER_TOF)) ?
!Directory.Exists(templateName) : !File.Exists(templateName))
{
helper.ShowTextBoxError(textTemplateFile, Resources.ExportMethodDlg_OkDialog_The_template_file__0__does_not_exist, templateName);
return;
}
if (Equals(InstrumentType, ExportInstrumentType.AGILENT6400) &&
!AgilentMethodExporter.IsAgilentMethodPath(templateName))
{
helper.ShowTextBoxError(textTemplateFile,
Resources.ExportMethodDlg_OkDialog_The_folder__0__does_not_appear_to_contain_an_Agilent_QQQ_method_template_The_folder_is_expected_to_have_a_m_extension_and_contain_the_file_qqqacqmethod_xsd,
templateName);
return;
}
if (Equals(InstrumentType, ExportInstrumentType.BRUKER_TOF) &&
!BrukerMethodExporter.IsBrukerMethodPath(templateName))
{
helper.ShowTextBoxError(textTemplateFile,
Resources.ExportMethodDlg_OkDialog_The_folder__0__does_not_appear_to_contain_a_Bruker_TOF_method_template___The_folder_is_expected_to_have_a__m_extension__and_contain_the_file_submethods_xml_,
templateName);
return;
}
}
if (Equals(InstrumentType, ExportInstrumentType.AGILENT_TOF) ||
Equals(InstrumentType, ExportInstrumentType.ABI_TOF))
{
// Check that mass analyzer settings are set to TOF.
if (documentExport.Settings.TransitionSettings.FullScan.IsEnabledMs &&
documentExport.Settings.TransitionSettings.FullScan.PrecursorMassAnalyzer != FullScanMassAnalyzerType.tof)
{
MessageDlg.Show(this, string.Format(Resources.ExportMethodDlg_OkDialog_The_precursor_mass_analyzer_type_is_not_set_to__0__in_Transition_Settings_under_the_Full_Scan_tab, Resources.ExportMethodDlg_OkDialog_TOF));
return;
}
if (documentExport.Settings.TransitionSettings.FullScan.IsEnabledMsMs &&
documentExport.Settings.TransitionSettings.FullScan.ProductMassAnalyzer != FullScanMassAnalyzerType.tof)
{
MessageDlg.Show(this, string.Format(Resources.ExportMethodDlg_OkDialog_The_product_mass_analyzer_type_is_not_set_to__0__in_Transition_Settings_under_the_Full_Scan_tab, Resources.ExportMethodDlg_OkDialog_TOF));
return;
}
}
if (Equals(InstrumentType, ExportInstrumentType.THERMO_Q_EXACTIVE))
{
// Check that mass analyzer settings are set to Orbitrap.
if (documentExport.Settings.TransitionSettings.FullScan.IsEnabledMs &&
documentExport.Settings.TransitionSettings.FullScan.PrecursorMassAnalyzer != FullScanMassAnalyzerType.orbitrap)
{
MessageDlg.Show(this, string.Format(Resources.ExportMethodDlg_OkDialog_The_precursor_mass_analyzer_type_is_not_set_to__0__in_Transition_Settings_under_the_Full_Scan_tab, Resources.ExportMethodDlg_OkDialog_Orbitrap));
return;
}
if (documentExport.Settings.TransitionSettings.FullScan.IsEnabledMsMs &&
documentExport.Settings.TransitionSettings.FullScan.ProductMassAnalyzer != FullScanMassAnalyzerType.orbitrap)
{
MessageDlg.Show(this, string.Format(Resources.ExportMethodDlg_OkDialog_The_product_mass_analyzer_type_is_not_set_to__0__in_Transition_Settings_under_the_Full_Scan_tab, Resources.ExportMethodDlg_OkDialog_Orbitrap));
return;
}
}
if (IsDia && _document.Settings.TransitionSettings.FullScan.IsolationScheme.FromResults)
{
MessageDlg.Show(this, Resources.ExportMethodDlg_OkDialog_The_DIA_isolation_list_must_have_prespecified_windows_);
return;
}
if (!documentExport.HasAllRetentionTimeStandards() &&
DialogResult.Cancel == MultiButtonMsgDlg.Show(
this,
TextUtil.LineSeparate(
Resources.ExportMethodDlg_OkDialog_The_document_does_not_contain_all_of_the_retention_time_standard_peptides,
Resources.ExportMethodDlg_OkDialog_You_will_not_be_able_to_use_retention_time_prediction_with_acquired_results,
Resources.ExportMethodDlg_OkDialog_Are_you_sure_you_want_to_continue),
Resources.ExportMethodDlg_OkDialog_OK))
{
return;
}
//This will populate _exportProperties
if (!ValidateSettings(helper))
{
return;
}
// Full-scan method building ignores CE and DP regression values
if (!IsFullScanInstrument)
{
// Check to make sure CE and DP match chosen instrument, and offer to use
// the correct version for the instrument, if not.
var predict = documentExport.Settings.TransitionSettings.Prediction;
var ce = predict.CollisionEnergy;
string ceName = (ce != null ? ce.Name : null);
string ceNameDefault = _instrumentType;
if (ceNameDefault.IndexOf(' ') != -1)
ceNameDefault = ceNameDefault.Substring(0, ceNameDefault.IndexOf(' '));
bool ceInSynch = ceName != null && ceName.StartsWith(ceNameDefault);
var dp = predict.DeclusteringPotential;
string dpName = (dp != null ? dp.Name : null);
string dpNameDefault = _instrumentType;
if (dpNameDefault.IndexOf(' ') != -1)
dpNameDefault = dpNameDefault.Substring(0, dpNameDefault.IndexOf(' '));
bool dpInSynch = true;
if (_instrumentType == ExportInstrumentType.ABI)
dpInSynch = dpName != null && dpName.StartsWith(dpNameDefault);
else
dpNameDefault = null; // Ignored for all other types
if ((!ceInSynch && Settings.Default.CollisionEnergyList.Keys.Any(name => name.StartsWith(ceNameDefault))) ||
(!dpInSynch && Settings.Default.DeclusterPotentialList.Keys.Any(name => name.StartsWith(dpNameDefault))))
{
var sb = new StringBuilder(string.Format(Resources.ExportMethodDlg_OkDialog_The_settings_for_this_document_do_not_match_the_instrument_type__0__,
_instrumentType));
sb.AppendLine().AppendLine();
if (!ceInSynch)
sb.Append(Resources.ExportMethodDlg_OkDialog_Collision_Energy).Append(TextUtil.SEPARATOR_SPACE).AppendLine(ceName);
if (!dpInSynch)
{
sb.Append(Resources.ExportMethodDlg_OkDialog_Declustering_Potential).Append(TextUtil.SEPARATOR_SPACE)
.AppendLine(dpName ?? Resources.ExportMethodDlg_OkDialog_None);
}
sb.AppendLine().Append(Resources.ExportMethodDlg_OkDialog_Would_you_like_to_use_the_defaults_instead);
var result = MultiButtonMsgDlg.Show(this, sb.ToString(), MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, true);
if (result == DialogResult.Yes)
{
documentExport = ChangeInstrumentTypeSettings(documentExport, ceNameDefault, dpNameDefault);
}
else if (result == DialogResult.Cancel)
{
comboInstrument.Focus();
return;
}
}
}
if (documentExport.Settings.TransitionSettings.Prediction.CompensationVoltage != null &&
!Equals(comboOptimizing.SelectedItem.ToString(), ExportOptimize.COV))
{
// Show warning if we don't have results for the highest tune level
var highestCoV = documentExport.HighestCompensationVoltageTuning();
string message = null;
switch (highestCoV)
{
case CompensationVoltageParameters.Tuning.fine:
{
var missing = documentExport.GetMissingCompensationVoltages(highestCoV).ToArray();
if (missing.Any())
{
message = TextUtil.LineSeparate(
Resources.ExportMethodDlg_OkDialog_You_are_missing_fine_tune_optimized_compensation_voltages_for_the_following_,
TextUtil.LineSeparate(missing));
}
break;
}
case CompensationVoltageParameters.Tuning.medium:
{
message = Resources.ExportMethodDlg_OkDialog_You_are_missing_fine_tune_optimized_compensation_voltages_;
var missing = documentExport.GetMissingCompensationVoltages(highestCoV).ToArray();
if (missing.Any())
{
message = TextUtil.LineSeparate(message,
Resources.ExportMethodDlg_OkDialog_You_are_missing_medium_tune_optimized_compensation_voltages_for_the_following_,
TextUtil.LineSeparate(missing));
}
break;
}
case CompensationVoltageParameters.Tuning.rough:
{
message = Resources.ExportMethodDlg_OkDialog_You_have_only_rough_tune_optimized_compensation_voltages_;
var missing = documentExport.GetMissingCompensationVoltages(highestCoV).ToArray();
if (missing.Any())
{
message = TextUtil.LineSeparate(message,
Resources.ExportMethodDlg_OkDialog_You_are_missing_any_optimized_compensation_voltages_for_the_following_,
TextUtil.LineSeparate(missing));
}
break;
}
case CompensationVoltageParameters.Tuning.none:
{
message = Resources.ExportMethodDlg_OkDialog_Your_document_does_not_contain_compensation_voltage_results__but_compensation_voltage_is_set_under_transition_settings_;
break;
}
}
if (message != null)
{
message = TextUtil.LineSeparate(message, Resources.ExportMethodDlg_OkDialog_Are_you_sure_you_want_to_continue_);
if (DialogResult.Cancel == MultiButtonMsgDlg.Show(this, message, Resources.ExportMethodDlg_OkDialog_OK))
{
return;
}
}
}
if (outputPath == null)
{
string title = Text;
string ext = TextUtil.EXT_CSV;
string filter = Resources.ExportMethodDlg_OkDialog_Method_File;
switch (_fileType)
{
case ExportFileType.List:
filter = Resources.ExportMethodDlg_OkDialog_Transition_List;
ext = ExportInstrumentType.TransitionListExtension(_instrumentType);
break;
case ExportFileType.IsolationList:
filter = Resources.ExportMethodDlg_OkDialog_Isolation_List;
ext = ExportInstrumentType.IsolationListExtension(_instrumentType);
break;
case ExportFileType.Method:
title = string.Format(Resources.ExportMethodDlg_OkDialog_Export__0__Method, _instrumentType);
ext = ExportInstrumentType.MethodExtension(_instrumentType);
break;
}
using (var dlg = new SaveFileDialog
{
Title = title,
InitialDirectory = Settings.Default.ExportDirectory,
OverwritePrompt = true,
DefaultExt = ext,
Filter = TextUtil.FileDialogFilterAll(filter, ext)
})
{
if (dlg.ShowDialog(this) == DialogResult.Cancel)
{
return;
}
outputPath = dlg.FileName;
}
}
Settings.Default.ExportDirectory = Path.GetDirectoryName(outputPath);
// Set ShowMessages property on ExportDlgProperties to true
// so that we see the progress dialog during the export process
var wasShowMessageValue = _exportProperties.ShowMessages;
_exportProperties.ShowMessages = true;
try
{
_exportProperties.ExportFile(_instrumentType, _fileType, outputPath, documentExport, templateName);
}
catch(UnauthorizedAccessException x)
{
MessageDlg.ShowException(this, x);
_exportProperties.ShowMessages = wasShowMessageValue;
return;
}
catch (IOException x)
{
MessageDlg.ShowException(this, x);
_exportProperties.ShowMessages = wasShowMessageValue;
return;
}
// Successfully completed dialog. Store the values in settings.
Settings.Default.ExportInstrumentType = _instrumentType;
Settings.Default.ExportMethodStrategy = ExportStrategy.ToString();
Settings.Default.ExportIgnoreProteins = IgnoreProteins;
if (IsFullScanInstrument)
{
Settings.Default.ExportMethodMaxPrec = (MaxTransitions.HasValue ?
MaxTransitions.Value.ToString(CultureInfo.InvariantCulture) : null);
}
else
{
Settings.Default.ExportMethodMaxTran = (MaxTransitions.HasValue ?
MaxTransitions.Value.ToString(CultureInfo.InvariantCulture) : null);
}
Settings.Default.ExportMethodType = _exportProperties.MethodType.ToString();
if (textPrimaryCount.Visible)
Settings.Default.PrimaryTransitionCount = PrimaryCount;
if (textDwellTime.Visible)
Settings.Default.ExportMethodDwellTime = DwellTime;
if (textRunLength.Visible)
Settings.Default.ExportMethodRunLength = RunLength;
if (panelThermoColumns.Visible)
{
Settings.Default.ExportThermoEnergyRamp = AddEnergyRamp;
Settings.Default.ExportThermoTriggerRef = AddTriggerReference;
}
if (_fileType == ExportFileType.Method)
Settings.Default.ExportMethodTemplateList.SetValue(new MethodTemplateFile(_instrumentType, templateName));
if (cbExportMultiQuant.Visible)
Settings.Default.ExportMultiQuant = ExportMultiQuant;
if (cbExportEdcMass.Visible)
Settings.Default.ExportEdcMass = ExportEdcMass;
DialogResult = DialogResult.OK;
Close();
}
/// <summary>
/// This function will validate all the settings required for exporting a method,
/// placing the values on the ExportDlgProperties _exportProperties. It returns
/// boolean whether or not it succeeded. It can show MessageBoxes or not based
/// on a parameter.
/// </summary>
public bool ValidateSettings(MessageBoxHelper helper)
{
// ReSharper disable ConvertIfStatementToConditionalTernaryExpression
if (radioSingle.Checked)
_exportProperties.ExportStrategy = ExportStrategy.Single;
else if (radioProtein.Checked)
_exportProperties.ExportStrategy = ExportStrategy.Protein;
else
_exportProperties.ExportStrategy = ExportStrategy.Buckets;
// ReSharper restore ConvertIfStatementToConditionalTernaryExpression
_exportProperties.IgnoreProteins = cbIgnoreProteins.Checked;
_exportProperties.FullScans = _document.Settings.TransitionSettings.FullScan.IsEnabledMsMs;
_exportProperties.AddEnergyRamp = panelThermoColumns.Visible && cbEnergyRamp.Checked;
_exportProperties.UseSlens = cbSlens.Checked;
_exportProperties.AddTriggerReference = panelThermoColumns.Visible && cbTriggerRefColumns.Checked;
_exportProperties.ExportMultiQuant = panelAbSciexTOF.Visible && cbExportMultiQuant.Checked;
_exportProperties.RetentionStartAndEnd = panelThermoRt.Visible && cbUseStartAndEndRts.Checked;
_exportProperties.ExportEdcMass = panelWaters.Visible && cbExportEdcMass.Checked;
_exportProperties.Ms1Scan = _document.Settings.TransitionSettings.FullScan.IsEnabledMs &&
_document.Settings.TransitionSettings.FullScan.IsEnabledMsMs;
_exportProperties.InclusionList = IsInclusionListMethod;
_exportProperties.MsAnalyzer =
TransitionFullScan.MassAnalyzerToString(
_document.Settings.TransitionSettings.FullScan.PrecursorMassAnalyzer);
_exportProperties.MsMsAnalyzer =
TransitionFullScan.MassAnalyzerToString(
_document.Settings.TransitionSettings.FullScan.ProductMassAnalyzer);
_exportProperties.OptimizeType = comboOptimizing.SelectedItem == null ? ExportOptimize.NONE : comboOptimizing.SelectedItem.ToString();
var prediction = _document.Settings.TransitionSettings.Prediction;
if (Equals(_exportProperties.OptimizeType, ExportOptimize.CE))
{
var regression = prediction.CollisionEnergy;
_exportProperties.OptimizeStepSize = regression.StepSize;
_exportProperties.OptimizeStepCount = regression.StepCount;
}
else if (Equals(_exportProperties.OptimizeType, ExportOptimize.DP))
{
var regression = prediction.DeclusteringPotential;
_exportProperties.OptimizeStepSize = regression.StepSize;
_exportProperties.OptimizeStepCount = regression.StepCount;
}
else if (Equals(_exportProperties.OptimizeType, ExportOptimize.COV))
{
string tuning = comboTuning.SelectedItem.ToString();
_exportProperties.OptimizeType = tuning;
var compensationVoltage = prediction.CompensationVoltage;
var tuneLevel = CompensationVoltageParameters.GetTuneLevel(tuning);
if (helper.ShowMessages)
{
if (tuneLevel.Equals(CompensationVoltageParameters.Tuning.medium))
{
var missing = _document.GetMissingCompensationVoltages(CompensationVoltageParameters.Tuning.rough).ToList();
if (missing.Any())
{
missing.Insert(0, Resources.ExportMethodDlg_ValidateSettings_Cannot_export_medium_tune_transition_list__The_following_precursors_are_missing_rough_tune_results_);
helper.ShowTextBoxError(comboTuning, TextUtil.LineSeparate(missing));
return false;
}
}
else if (tuneLevel.Equals(CompensationVoltageParameters.Tuning.fine))
{
var missing = _document.GetMissingCompensationVoltages(CompensationVoltageParameters.Tuning.medium).ToList();
if (missing.Any())
{
missing.Insert(0, Resources.ExportMethodDlg_ValidateSettings_Cannot_export_fine_tune_transition_list__The_following_precursors_are_missing_medium_tune_results_);
helper.ShowTextBoxError(comboTuning, TextUtil.LineSeparate(missing));
return false;
}
}
}
_exportProperties.OptimizeStepSize = compensationVoltage.GetStepSize(tuneLevel);
_exportProperties.OptimizeStepCount = compensationVoltage.GetStepCount(tuneLevel);
_exportProperties.PrimaryTransitionCount = 1;
}
else
{
_exportProperties.OptimizeType = null;
_exportProperties.OptimizeStepSize = _exportProperties.OptimizeStepCount = _exportProperties.PrimaryTransitionCount = 0;
}
string maxTran = textMaxTransitions.Text;
if (string.IsNullOrEmpty(maxTran))
{
if (_exportProperties.ExportStrategy == ExportStrategy.Buckets)
{
helper.ShowTextBoxError(textMaxTransitions, Resources.ExportMethodDlg_ValidateSettings__0__must_contain_a_value);
return false;
}
_exportProperties.MaxTransitions = null;
}
int maxVal;
// CONSIDER: Better error message when instrument limitation encountered?
int maxInstrumentTrans = _document.Settings.TransitionSettings.Instrument.MaxTransitions ??
TransitionInstrument.MAX_TRANSITION_MAX;
int minTrans = IsFullScanInstrument
? AbstractMassListExporter.MAX_TRANS_PER_INJ_MIN
: MethodExporter.MAX_TRANS_PER_INJ_MIN_TLTQ;
if (_exportProperties.ExportStrategy != ExportStrategy.Buckets)
maxVal = maxInstrumentTrans;
else if (!helper.ValidateNumberTextBox(textMaxTransitions, minTrans, maxInstrumentTrans, out maxVal))
return false;
// Make sure all the transitions of all precursors can fit into a single document,
// but not if this is a full-scan instrument, because then the maximum is refering
// to precursors and not transitions.
if (!IsFullScanInstrument && !ValidatePrecursorFit(_document, maxVal, helper.ShowMessages))
return false;
_exportProperties.MaxTransitions = maxVal;
_exportProperties.MethodType = ExportMethodTypeExtension.GetEnum(comboTargetType.SelectedItem.ToString());
if (textPrimaryCount.Visible)
{
int primaryCount;
if (!helper.ValidateNumberTextBox(textPrimaryCount, AbstractMassListExporter.PRIMARY_COUNT_MIN, AbstractMassListExporter.PRIMARY_COUNT_MAX, out primaryCount))
return false;
_exportProperties.PrimaryTransitionCount = primaryCount;
}
if (textDwellTime.Visible)
{
int dwellTime;
if (!helper.ValidateNumberTextBox(textDwellTime, AbstractMassListExporter.DWELL_TIME_MIN, AbstractMassListExporter.DWELL_TIME_MAX, out dwellTime))
return false;
_exportProperties.DwellTime = dwellTime;
}
if (textRunLength.Visible)
{
double runLength;
if (!helper.ValidateDecimalTextBox(textRunLength, AbstractMassListExporter.RUN_LENGTH_MIN, AbstractMassListExporter.RUN_LENGTH_MAX, out runLength))
return false;
_exportProperties.RunLength = runLength;
}
// If export method type is scheduled, and allows multiple scheduling options
// ask the user which to use.
if (_exportProperties.MethodType != ExportMethodType.Standard && HasMultipleSchedulingOptions(_document))
{
if (!helper.ShowMessages)
{
// CONSIDER: Kind of a hack, but pick some reasonable defaults. The user
// may decide otherwise later, but this is the best we can do
// without asking.
if (!_document.Settings.HasResults || Settings.Default.ScheduleAvergeRT)
SchedulingAlgorithm = ExportSchedulingAlgorithm.Average;
else
{
SchedulingAlgorithm = ExportSchedulingAlgorithm.Single;
SchedulingReplicateNum = _document.Settings.MeasuredResults.Chromatograms.Count - 1;
}
}
else
{
using (var schedulingOptionsDlg = new SchedulingOptionsDlg(_document, i =>
_exportProperties.MethodType != ExportMethodType.Triggered || CanTriggerReplicate(i)))
{
if (schedulingOptionsDlg.ShowDialog(this) != DialogResult.OK)
return false;
SchedulingAlgorithm = schedulingOptionsDlg.Algorithm;
SchedulingReplicateNum = schedulingOptionsDlg.ReplicateNum;
}
}
}
if (ExportOptimize.CompensationVoltageTuneTypes.Contains(_exportProperties.OptimizeType))
{
var precursorsMissingRanks = _document.GetPrecursorsWithoutTopRank(0, _exportProperties.SchedulingReplicateNum).ToArray();
if (precursorsMissingRanks.Any())
{
if (helper.ShowMessages)
{
if (DialogResult.Cancel == MultiButtonMsgDlg.Show(this, TextUtil.LineSeparate(
Resources.ExportMethodDlg_OkDialog_Compensation_voltage_optimization_should_be_run_on_one_transition_per_peptide__and_the_best_transition_cannot_be_determined_for_the_following_precursors_,
TextUtil.LineSeparate(precursorsMissingRanks),
Resources.ExportMethodDlg_OkDialog_Provide_transition_ranking_information_through_imported_results__a_spectral_library__or_choose_only_one_target_transition_per_precursor_),
Resources.ExportMethodDlg_OkDialog_OK))
{
return false;
}
}
_exportProperties.PrimaryTransitionCount = 0;
}
}
return true;
}
private void CalcMethodCount()
{
if (InstrumentType == null)
return;
if (IsDia)
{
labelMethodNum.Text = 1.ToString(LocalizationHelper.CurrentCulture);
return;
}
if (_recalcMethodCountStatus != RecalcMethodCountStatus.waiting || !IsHandleCreated)
{
_recalcMethodCountStatus = RecalcMethodCountStatus.pending;
return;
}
var helper = new MessageBoxHelper(this, false);
if (!ValidateSettings(helper) || comboInstrument.SelectedItem == null)
{
labelMethodNum.Text = string.Empty;
return;
}
// ReSharper disable LocalizableElement
labelMethodNum.Text = "..."; // Not L10N
// ReSharper restore LocalizableElement
_recalcMethodCountStatus = RecalcMethodCountStatus.running;
var recalcMethodCount = new RecalcMethodCountCaller(RecalcMethodCount);
string instrument = comboInstrument.SelectedItem.ToString();
recalcMethodCount.BeginInvoke(_exportProperties, instrument, _fileType, _document, null, null);
}
public bool ValidateMonoText(MessageBoxHelper helper)
{
double val;
return helper.ValidateDecimalTextBox(textMono, out val);
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
string name;
if (!helper.ValidateNameTextBox(_editing ? (Control) textName : comboMod, out name))
return;
// Allow updating the original modification
if (!_editing || !Equals(name, Modification.Name))
{
if(!ModNameAvailable(name))
{
helper.ShowTextBoxError(_editing ? (Control)textName : comboMod,
Resources.EditStaticModDlg_OkDialog_The_modification__0__already_exists, name);
return;
}
}
string aas = comboAA.Text;
if (string.IsNullOrEmpty(aas))
aas = null;
else
{
// Use the cleanest possible format.
var sb = new StringBuilder();
foreach (string aaPart in aas.Split(SEPARATOR_AA))
{
string aa = aaPart.Trim();
if (aa.Length == 0)
continue;
if (sb.Length > 0)
sb.Append(", "); // Not L10N
sb.Append(aa);
}
}
string termString = comboTerm.SelectedItem.ToString();
ModTerminus? term = null;
if (!string.IsNullOrEmpty(termString))
term = (ModTerminus) Enum.Parse(typeof (ModTerminus), termString);
if (cbVariableMod.Checked && aas == null && term == null)
{
MessageDlg.Show(this, Resources.EditStaticModDlg_OkDialog_Variable_modifications_must_specify_amino_acid_or_terminus);
comboAA.Focus();
return;
}
string formula = null;
double? monoMass = null;
double? avgMass = null;
LabelAtoms labelAtoms = LabelAtoms.None;
if (cbChemicalFormula.Checked)
formula = Formula;
else
labelAtoms = LabelAtoms;
// Get the losses to know whether any exist below
IList<FragmentLoss> losses = null;
if (listNeutralLosses.Items.Count > 0)
{
losses = Losses.ToArray();
}
if (!string.IsNullOrEmpty(formula))
{
try
{
SequenceMassCalc.ParseModMass(BioMassCalc.MONOISOTOPIC, formula);
}
catch (ArgumentException x)
{
_formulaBox.ShowTextBoxErrorFormula(helper, x.Message);
return;
}
}
else if (labelAtoms == LabelAtoms.None)
{
formula = null;
// Allow formula and both masses to be empty, if losses are present
if ( NotZero(_formulaBox.MonoMass) || NotZero(_formulaBox.AverageMass)|| losses == null)
{
// TODO: Maximum and minimum masses should be formalized and applied everywhere
double mass;
if (!_formulaBox.ValidateMonoText(helper, -1500, 5000, out mass))
return;
monoMass = mass;
if (!_formulaBox.ValidateAverageText(helper, -1500, 5000, out mass))
return;
avgMass = mass;
}
// Loss-only modifications may not be variable
else if (cbVariableMod.Checked)
{
MessageDlg.Show(this, Resources.EditStaticModDlg_OkDialog_The_variable_checkbox_only_applies_to_precursor_modification_Product_ion_losses_are_inherently_variable);
cbVariableMod.Focus();
return;
}
}
else if (aas == null && term.HasValue)
{
MessageDlg.Show(this, Resources.EditStaticModDlg_OkDialog_Labeled_atoms_on_terminal_modification_are_not_valid);
return;
}
RelativeRT relativeRT = RelativeRT.Matching;
if (comboRelativeRT.Visible && comboRelativeRT.SelectedItem != null)
{
relativeRT = RelativeRTExtension.GetEnum(comboRelativeRT.SelectedItem.ToString());
}
// Store state of the chemical formula checkbox for next use.
if (cbChemicalFormula.Visible)
Settings.Default.ShowHeavyFormula = _formulaBox.FormulaVisible;
var newMod = new StaticMod(name,
aas,
term,
cbVariableMod.Checked,
formula,
labelAtoms,
relativeRT,
monoMass,
avgMass,
losses);
foreach (StaticMod mod in _existing)
{
if (newMod.Equivalent(mod) && !(_editing && mod.Equals(_originalModification)))
{
if (DialogResult.OK == MultiButtonMsgDlg.Show(
this,
TextUtil.LineSeparate(Resources.EditStaticModDlg_OkDialog_There_is_an_existing_modification_with_the_same_settings,
string.Format("'{0}'.", mod.Name), // Not L10N
string.Empty,
Resources.EditStaticModDlg_OkDialog_Continue),
MultiButtonMsgDlg.BUTTON_OK))
{
Modification = newMod;
DialogResult = DialogResult.OK;
}
return;
}
}
var uniMod = UniMod.GetModification(name, IsStructural);
// If the modification name is not found in Unimod, check if there exists a modification in Unimod that matches
// the dialog modification, and prompt the user to to use the Unimod modification instead.
if (uniMod == null)
{
var matchingMod = UniMod.FindMatchingStaticMod(newMod, IsStructural);
if (matchingMod != null &&
(ModNameAvailable(matchingMod.Name) ||
(_editing && Equals(matchingMod.Name, Modification.Name))))
{
var result = MultiButtonMsgDlg.Show(
this,
TextUtil.LineSeparate(Resources.EditStaticModDlg_OkDialog_There_is_a_Unimod_modification_with_the_same_settings,
string.Empty,
string.Format(Resources.EditStaticModDlg_OkDialog_Click__Unimod__to_use_the_name___0___, matchingMod.Name),
string.Format(Resources.EditStaticModDlg_OkDialog_Click__Custom__to_use_the_name___0___, name)),
Resources.EditStaticModDlg_OkDialog_Unimod,
Resources.EditStaticModDlg_OkDialog_Custom,
true);
if (result == DialogResult.Yes)
newMod = matchingMod.MatchVariableAndLossInclusion(newMod); // Unimod
if (result == DialogResult.Cancel)
return;
}
}
else
{
// If the dialog modification matches the modification of the same name in Unimod,
// use the UnimodId.
if (newMod.Equivalent(uniMod))
newMod = uniMod.MatchVariableAndLossInclusion(newMod);
else
{
// Finally, if the modification name is found in Unimod, but the modification in Unimod does not
// match the dialog modification, prompt the user to use the Unimod modification definition instead.
if (DialogResult.OK != MultiButtonMsgDlg.Show(
this,
TextUtil.LineSeparate(string.Format(Resources.EditStaticModDlg_OkDialog_This_modification_does_not_match_the_Unimod_specifications_for___0___, name),
string.Empty,
Resources.EditStaticModDlg_OkDialog_Use_non_standard_settings_for_this_name),
MultiButtonMsgDlg.BUTTON_OK))
{
return;
}
}
}
_modification = newMod;
DialogResult = DialogResult.OK;
}
public bool ValidateAverageText(MessageBoxHelper helper)
{
double val;
return helper.ValidateDecimalTextBox(textAverage, out val);
}
public bool ValidateMonoText(MessageBoxHelper helper, double min, double max, out double val)
{
return helper.ValidateDecimalTextBox(textMono, min, max, out val);
}
public void ShowTextBoxErrorFormula(MessageBoxHelper helper, string message)
{
helper.ShowTextBoxError(textFormula, message);
}
public void ShowTextBoxErrorMonoMass(MessageBoxHelper helper, string message)
{
helper.ShowTextBoxError(textMono, message);
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
string formulaLoss = _formulaBox.Formula;
double? monoLoss = null;
double? avgLoss = null;
if (!string.IsNullOrEmpty(formulaLoss))
{
try
{
double massMono = SequenceMassCalc.ParseModMass(BioMassCalc.MONOISOTOPIC, formulaLoss);
double massAverage = SequenceMassCalc.ParseModMass(BioMassCalc.AVERAGE, formulaLoss);
if (FragmentLoss.MIN_LOSS_MASS > massMono || FragmentLoss.MIN_LOSS_MASS > massAverage)
{
_formulaBox.ShowTextBoxErrorFormula(helper, string.Format(Resources.EditFragmentLossDlg_OkDialog_Neutral_loss_masses_must_be_greater_than_or_equal_to__0__,
FragmentLoss.MIN_LOSS_MASS));
return;
}
if (massMono > FragmentLoss.MAX_LOSS_MASS || massAverage > FragmentLoss.MAX_LOSS_MASS)
{
_formulaBox.ShowTextBoxErrorFormula(helper, string.Format(Resources.EditFragmentLossDlg_OkDialog_Neutral_loss_masses_must_be_less_than_or_equal_to__0__,
FragmentLoss.MAX_LOSS_MASS));
return;
}
}
catch (ArgumentException x)
{
_formulaBox.ShowTextBoxErrorFormula(helper, x.Message);
return;
}
}
else if (_formulaBox.MonoMass != null ||
_formulaBox.AverageMass != null)
{
formulaLoss = null;
double mass;
if (!_formulaBox.ValidateMonoText(helper, FragmentLoss.MIN_LOSS_MASS, FragmentLoss.MAX_LOSS_MASS, out mass))
return;
monoLoss = mass;
if (!_formulaBox.ValidateAverageText(helper, FragmentLoss.MIN_LOSS_MASS, FragmentLoss.MAX_LOSS_MASS, out mass))
return;
avgLoss = mass;
}
else
{
_formulaBox.ShowTextBoxErrorFormula(helper,Resources.EditFragmentLossDlg_OkDialog_Please_specify_a_formula_or_constant_masses);
return;
}
// Make sure the new loss does not already exist.
var loss = new FragmentLoss(formulaLoss, monoLoss, avgLoss, Inclusion);
if (_existing.Contains(loss))
{
MessageDlg.Show(this, string.Format(Resources.EditFragmentLossDlg_OkDialog_The_loss__0__already_exists, loss));
return;
}
Loss = loss;
DialogResult = DialogResult.OK;
}
public void OkDialog()
{
double minIrt;
double maxIrt;
var helper = new MessageBoxHelper(this);
if (!helper.ValidateDecimalTextBox(textMinIrt, null, null, out minIrt))
return;
if (!helper.ValidateDecimalTextBox(textMaxIrt, minIrt, null, out maxIrt))
return;
var peptide1 = (DbIrtPeptide) comboFixedPoint1.SelectedItem;
var peptide2 = (DbIrtPeptide) comboFixedPoint2.SelectedItem;
double minCurrent = Math.Min(peptide1.Irt, peptide2.Irt);
double maxCurrent = Math.Max(peptide1.Irt, peptide2.Irt);
var statX = new Statistics(minCurrent, maxCurrent);
var statY = new Statistics(minIrt, maxIrt);
LinearEquation = new RegressionLine(statY.Slope(statX), statY.Intercept(statX));
// Convert all of the peptides to the new scale.
foreach (var peptide in _irtPeptides)
{
peptide.Irt = LinearEquation.GetY(peptide.Irt);
}
DialogResult = DialogResult.OK;
}
public void OkDialog()
{
var messageBoxHelper = new MessageBoxHelper(this);
string name;
if (!messageBoxHelper.ValidateNameTextBox(tbxName, out name))
{
return;
}
if (_annotationDef == null || name != _annotationDef.Name)
{
foreach (var annotationDef in _existing)
{
if (annotationDef.Name == name)
{
messageBoxHelper.ShowTextBoxError(tbxName, Resources.DefineAnnotationDlg_OkDialog_There_is_already_an_annotation_defined_named__0__, name);
return;
}
}
}
if (checkedListBoxAppliesTo.CheckedItems.Count == 0)
{
MessageBox.Show(this, Resources.DefineAnnotationDlg_OkDialog_Choose_at_least_one_type_for_this_annotation_to_apply_to, Program.Name);
checkedListBoxAppliesTo.Focus();
return;
}
DialogResult = DialogResult.OK;
Close();
}
public bool BuildPeptideSearchLibrary(CancelEventArgs e)
{
// Nothing to build, if now search files were specified
if (!SearchFilenames.Any())
{
var libraries = SkylineWindow.Document.Settings.PeptideSettings.Libraries;
if (!libraries.HasLibraries)
return false;
var libSpec = libraries.LibrarySpecs.FirstOrDefault(s => s.IsDocumentLibrary);
return libSpec != null && LoadPeptideSearchLibrary(libSpec);
}
double cutOffScore;
MessageBoxHelper helper = new MessageBoxHelper(WizardForm);
if (!helper.ValidateDecimalTextBox(textCutoff, 0, 1.0, out cutOffScore))
{
e.Cancel = true;
return false;
}
ImportPeptideSearch.CutoffScore = cutOffScore;
BiblioSpecLiteBuilder builder;
try
{
builder = ImportPeptideSearch.GetLibBuilder(SkylineWindow.Document, SkylineWindow.DocumentFilePath, cbIncludeAmbiguousMatches.Checked);
}
catch (FileEx.DeleteException de)
{
MessageDlg.ShowException(this, de);
return false;
}
using (var longWaitDlg = new LongWaitDlg
{
Text = Resources.BuildPeptideSearchLibraryControl_BuildPeptideSearchLibrary_Building_Peptide_Search_Library,
Message = Resources.BuildPeptideSearchLibraryControl_BuildPeptideSearchLibrary_Building_document_library_for_peptide_search_,
})
{
// Disable the wizard, because the LongWaitDlg does not
try
{
ImportPeptideSearch.ClosePeptideSearchLibraryStreams(SkylineWindow.DocumentUI);
var status = longWaitDlg.PerformWork(WizardForm, 800,
monitor => LibraryManager.BuildLibraryBackground(SkylineWindow, builder, monitor, new LibraryManager.BuildState(null, null)));
if (status.IsError)
{
MessageDlg.ShowException(WizardForm, status.ErrorException);
return false;
}
}
catch (Exception x)
{
MessageDlg.ShowWithException(WizardForm, TextUtil.LineSeparate(string.Format(Resources.BuildPeptideSearchLibraryControl_BuildPeptideSearchLibrary_Failed_to_build_the_library__0__,
Path.GetFileName(BiblioSpecLiteSpec.GetLibraryFileName(SkylineWindow.DocumentFilePath))), x.Message), x);
return false;
}
}
var docLibSpec = builder.LibrarySpec.ChangeDocumentLibrary(true);
Settings.Default.SpectralLibraryList.Insert(0, docLibSpec);
// Go ahead and load the library - we'll need it for
// the modifications and chromatograms page.
if (!LoadPeptideSearchLibrary(docLibSpec))
return false;
var docNew = ImportPeptideSearch.AddDocumentSpectralLibrary(SkylineWindow.Document, docLibSpec);
if (docNew == null)
return false;
SkylineWindow.ModifyDocument(Resources.BuildPeptideSearchLibraryControl_BuildPeptideSearchLibrary_Add_document_spectral_library, doc => docNew);
if (!string.IsNullOrEmpty(builder.AmbiguousMatchesMessage))
{
MessageDlg.Show(WizardForm, builder.AmbiguousMatchesMessage);
}
return true;
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
var charge = 0;
if (textCharge.Visible && !helper.ValidateSignedNumberTextBox(textCharge, _minCharge, _maxCharge, out charge))
return;
if (RetentionTimeWindow.HasValue && !RetentionTime.HasValue)
{
helper.ShowTextBoxError(textRetentionTimeWindow,
Resources.Peptide_ExplicitRetentionTimeWindow_Explicit_retention_time_window_requires_an_explicit_retention_time_value_);
return;
}
Charge = charge; // Note: order matters here, this settor indirectly updates _formulaBox.MonoMass when formula is empty
if (string.IsNullOrEmpty(_formulaBox.Formula))
{
// Can the text fields be understood as mz?
if (!_formulaBox.ValidateAverageText(helper))
return;
if (!_formulaBox.ValidateMonoText(helper))
return;
}
var formula = _formulaBox.Formula;
var monoMass = _formulaBox.MonoMass ?? 0;
var averageMass = _formulaBox.AverageMass ?? 0;
if (monoMass < CustomIon.MIN_MASS || averageMass < CustomIon.MIN_MASS)
{
_formulaBox.ShowTextBoxErrorFormula(helper,
string.Format(Resources.EditCustomMoleculeDlg_OkDialog_Custom_molecules_must_have_a_mass_greater_than_or_equal_to__0__,
CustomIon.MIN_MASS));
return;
}
if (monoMass > CustomIon.MAX_MASS || averageMass > CustomIon.MAX_MASS)
{
_formulaBox.ShowTextBoxErrorFormula(helper,
string.Format(Resources.EditCustomMoleculeDlg_OkDialog_Custom_molecules_must_have_a_mass_less_than_or_equal_to__0__, CustomIon.MAX_MASS));
return;
}
if ((_transitionSettings != null) &&
(!_transitionSettings.IsMeasurablePrecursor(BioMassCalc.CalculateIonMz(monoMass, charge)) ||
!_transitionSettings.IsMeasurablePrecursor(BioMassCalc.CalculateIonMz(averageMass, charge))))
{
_formulaBox.ShowTextBoxErrorFormula(helper, Resources.SkylineWindow_AddMolecule_The_precursor_m_z_for_this_molecule_is_out_of_range_for_your_instrument_settings_);
return;
}
if (!string.IsNullOrEmpty(_formulaBox.Formula))
{
try
{
ResultCustomIon = new DocNodeCustomIon(formula, textName.Text);
}
catch (InvalidDataException x)
{
_formulaBox.ShowTextBoxErrorFormula(helper, x.Message);
return;
}
}
else
{
ResultCustomIon = new DocNodeCustomIon(monoMass, averageMass, textName.Text);
}
// Did user change the list of heavy labels?
if (_driverLabelType != null)
{
PeptideModifications modifications = new PeptideModifications(
_peptideSettings.Modifications.StaticModifications,
_peptideSettings.Modifications.MaxVariableMods,
_peptideSettings.Modifications.MaxNeutralLosses,
_driverLabelType.GetHeavyModifications(), // This is the only thing the user may have altered
_peptideSettings.Modifications.InternalStandardTypes);
var settings = _peptideSettings.ChangeModifications(modifications);
// Only update if anything changed
if (!Equals(settings, _peptideSettings))
{
SrmSettings newSettings = _parent.DocumentUI.Settings.ChangePeptideSettings(settings);
if (!_parent.ChangeSettings(newSettings, true))
{
return;
}
_peptideSettings = newSettings.PeptideSettings;
}
}
// See if this combination of charge and label would conflict with any existing transition groups
if (_existingIds != null && _existingIds.Any(t =>
{
var transitionGroup = t as TransitionGroup;
return transitionGroup != null && Equals(transitionGroup.LabelType, IsotopeLabelType) &&
Equals(transitionGroup.PrecursorCharge, Charge) && !ReferenceEquals(t, _initialId);
}))
{
helper.ShowTextBoxError(textName,
Resources.EditCustomMoleculeDlg_OkDialog_A_precursor_with_that_charge_and_label_type_already_exists_, textName.Text);
return;
}
// See if this would conflict with any existing transitions
if (_existingIds != null && (_existingIds.Any(t =>
{
var transition = t as Transition;
return transition != null && ((transition.Charge == Charge) && Equals(transition.CustomIon, ResultCustomIon)) && !ReferenceEquals(t, _initialId);
})))
{
helper.ShowTextBoxError(textName,
Resources.EditCustomMoleculeDlg_OkDialog_A_similar_transition_already_exists_, textName.Text);
return;
}
DialogResult = DialogResult.OK;
}
private void textCharge_TextChanged(object sender, EventArgs e)
{
var helper = new MessageBoxHelper(this, false);
int charge;
if (!helper.ValidateSignedNumberTextBox(textCharge, _minCharge, _maxCharge, out charge))
return;
Charge = charge;
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
double lockmassPositive;
if (string.IsNullOrEmpty(textLockmassPositive.Text))
lockmassPositive = 0;
else if (!helper.ValidateDecimalTextBox(textLockmassPositive, 0, null, out lockmassPositive))
return;
double lockmassNegative;
if (string.IsNullOrEmpty(textLockmassNegative.Text))
lockmassNegative = 0;
else if (!helper.ValidateDecimalTextBox(textLockmassNegative, 0, null, out lockmassNegative))
return;
double lockmassTolerance;
if (string.IsNullOrEmpty(textLockmassTolerance.Text))
lockmassTolerance = 0;
else if (!helper.ValidateDecimalTextBox(textLockmassTolerance, LockMassParameters.LOCKMASS_TOLERANCE_MIN, LockMassParameters.LOCKMASS_TOLERANCE_MAX, out lockmassTolerance))
return;
Settings.Default.LockmassParameters = LockMassParameters = new LockMassParameters(lockmassPositive, lockmassNegative, lockmassTolerance);
DialogResult = DialogResult.OK;
}
public void ShowTextBoxErrorAverageMass(MessageBoxHelper helper, string message)
{
helper.ShowTextBoxError(textAverage,message);
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
// Validate start and end.
double start;
double end;
if (!helper.ValidateDecimalTextBox(textStart, TransitionFullScan.MIN_RES_MZ, TransitionFullScan.MAX_RES_MZ, out start) ||
!helper.ValidateDecimalTextBox(textEnd, TransitionFullScan.MIN_RES_MZ, TransitionFullScan.MAX_RES_MZ, out end))
{
return;
}
if (start >= end)
{
MessageDlg.Show(this, Resources.CalculateIsolationSchemeDlg_OkDialog_Start_value_must_be_less_than_End_value);
return;
}
// Validate window width.
double windowWidth;
if (!helper.ValidateDecimalTextBox(textWidth, 0.1, TransitionFullScan.MAX_RES_MZ - TransitionFullScan.MIN_RES_MZ, out windowWidth))
{
return;
}
if (windowWidth > end - start)
{
MessageDlg.Show(this, Resources.CalculateIsolationSchemeDlg_OkDialog_Window_width_must_be_less_than_or_equal_to_the_isolation_range);
return;
}
// Validate margins.
double? margin = null;
if (!helper.IsZeroOrEmpty(textMargin))
{
double marginValue;
if (!helper.ValidateDecimalTextBox(textMargin, TransitionInstrument.MIN_MZ_MATCH_TOLERANCE,
TransitionFullScan.MAX_RES_MZ - TransitionFullScan.MIN_RES_MZ, out marginValue))
{
return;
}
margin = marginValue;
}
// Validate CE range.
double? ceRange = null;
if (!helper.IsZeroOrEmpty(textCERange))
{
double ceRangeValue;
if (!helper.ValidateDecimalTextBox(textCERange, 0.0, double.MaxValue, out ceRangeValue))
{
return;
}
ceRange = ceRangeValue;
}
// Validate multiplexing.
if (Multiplexed)
{
int windowsPerScan;
if (!helper.ValidateNumberTextBox(textWindowsPerScan, 2, 20, out windowsPerScan))
{
return;
}
// Make sure multiplexed window count is a multiple of windows per scan.
if (Multiplexed && IsolationWindows.Count % windowsPerScan != 0)
{
MessageDlg.Show(this, Resources.CalculateIsolationSchemeDlg_OkDialog_The_number_of_generated_windows_could_not_be_adjusted_to_be_a_multiple_of_the_windows_per_scan_Try_changing_the_windows_per_scan_or_the_End_value);
return;
}
}
try
{
// ReSharper disable ObjectCreationAsStatement
new IsolationWindow(start, end, null, margin, margin, ceRange);
// ReSharper restore ObjectCreationAsStatement
}
catch (InvalidDataException x)
{
MessageDlg.ShowException(this, x);
return;
}
DialogResult = DialogResult.OK;
}
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;
}
private bool UpdateFullScanSettings()
{
var helper = new MessageBoxHelper(this);
// Validate and store MS1 full-scan settings
// If high resolution MS1 filtering is enabled, make sure precursor m/z type
// is monoisotopic and isotope enrichments are set
var precursorIsotopes = FullScanSettingsControl.PrecursorIsotopesCurrent;
var precursorAnalyzerType = FullScanSettingsControl.PrecursorMassAnalyzer;
var precursorMassType = TransitionSettings.Prediction.PrecursorMassType;
if (precursorIsotopes != FullScanPrecursorIsotopes.None &&
precursorAnalyzerType != FullScanMassAnalyzerType.qit)
{
precursorMassType = MassType.Monoisotopic;
if (FullScanSettingsControl.Enrichments == null)
{
MessageDlg.Show(GetParentForm(this), Resources.TransitionSettingsUI_OkDialog_Isotope_enrichment_settings_are_required_for_MS1_filtering_on_high_resolution_mass_spectrometers);
return false;
}
}
if (FullScanSettingsControl.IsolationScheme == null && FullScanSettingsControl.AcquisitionMethod == FullScanAcquisitionMethod.DIA)
{
MessageDlg.Show(this, Resources.TransitionSettingsUI_OkDialog_An_isolation_scheme_is_required_to_match_multiple_precursors);
return false;
}
TransitionFilter filter = TransitionSettings.Filter;
if (FullScanSettingsControl.PrecursorChargesTextBox.Visible)
{
int[] precursorCharges;
if (!helper.ValidateNumberListTextBox(FullScanSettingsControl.PrecursorChargesTextBox, TransitionGroup.MIN_PRECURSOR_CHARGE, TransitionGroup.MAX_PRECURSOR_CHARGE, out precursorCharges))
return false;
precursorCharges = precursorCharges.Distinct().ToArray();
filter = TransitionSettings.Filter.ChangePrecursorCharges(precursorCharges);
}
if (WorkflowType == Workflow.dda && !filter.IonTypes.Contains(IonType.precursor))
filter = filter.ChangeIonTypes(new[] {IonType.precursor});
if (!filter.AutoSelect)
filter = filter.ChangeAutoSelect(true);
Helpers.AssignIfEquals(ref filter, TransitionSettings.Filter);
if (FullScanSettingsControl.IsDIA() && filter.ExclusionUseDIAWindow)
{
if (FullScanSettingsControl.IsolationScheme.IsAllIons)
{
MessageDlg.Show(this, Resources.TransitionSettingsUI_OkDialog_Cannot_use_DIA_window_for_precusor_exclusion_when__All_Ions__is_selected_as_the_isolation_scheme___To_use_the_DIA_window_for_precusor_exclusion__change_the_isolation_scheme_in_the_Full_Scan_settings_);
return false;
}
if (FullScanSettingsControl.IsolationScheme.FromResults)
{
MessageDlg.Show(this, Resources.TransitionSettingsUI_OkDialog_Cannot_use_DIA_window_for_precursor_exclusion_when_isolation_scheme_does_not_contain_prespecified_windows___Please_select_an_isolation_scheme_with_prespecified_windows_);
return false;
}
}
TransitionFullScan fullScan;
if (!FullScanSettingsControl.ValidateFullScanSettings(helper, out fullScan))
return false;
Helpers.AssignIfEquals(ref fullScan, TransitionSettings.FullScan);
var prediction = TransitionSettings.Prediction.ChangePrecursorMassType(precursorMassType);
Helpers.AssignIfEquals(ref prediction, TransitionSettings.Prediction);
TransitionSettings settings;
try
{
settings = new TransitionSettings(prediction, filter,
TransitionSettings.Libraries, TransitionSettings.Integration, TransitionSettings.Instrument, fullScan);
}
catch (Exception x)
{
MessageDlg.Show(this, x.Message);
return false;
}
// Only update, if anything changed
if (!Equals(settings, TransitionSettings))
{
SrmSettings newSettings = SkylineWindow.DocumentUI.Settings.ChangeTransitionSettings(settings);
if (!SkylineWindow.ChangeSettings(newSettings, true))
{
return false;
}
}
// MS1 filtering must be enabled
if (!FullScan.IsEnabledMs)
{
MessageDlg.Show(this, Resources.ImportPeptideSearchDlg_UpdateFullScanSettings_Full_scan_MS1_filtering_must_be_enabled_in_order_to_import_a_peptide_search_);
return false;
}
return true;
}