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 MeasuredIon ValidateCustomIon(string name)
{
var helper = new MessageBoxHelper(this);
string formula = _formulaBox.Formula.ToString(LocalizationHelper.CurrentCulture);
var charge = ValidateCharge();
if (!charge.HasValue)
{
return(null);
}
double monoMass;
double avgMass;
if (!string.IsNullOrEmpty(formula))
{
// Mass is specified by chemical formula
try
{
monoMass = SequenceMassCalc.ParseModMass(BioMassCalc.MONOISOTOPIC, formula);
avgMass = SequenceMassCalc.ParseModMass(BioMassCalc.AVERAGE, formula);
}
catch (ArgumentException x)
{
helper.ShowTextBoxError(_formulaBox, x.Message);
return(null);
}
}
else if (_formulaBox.MonoMass != null ||
_formulaBox.AverageMass != null)
{
// Mass is specified by combination of mz and charge
formula = null;
if (!_formulaBox.ValidateMonoText(helper))
{
return(null);
}
if (!_formulaBox.ValidateAverageText(helper))
{
return(null);
}
_formulaBox.Charge = charge; // This provokes calculation of mass from displayed mz values
monoMass = _formulaBox.MonoMass.Value;
avgMass = _formulaBox.AverageMass.Value;
}
else
{
// User hasn't fully specified either way
_formulaBox.ShowTextBoxErrorFormula(helper,
Resources.EditMeasuredIonDlg_OkDialog_Please_specify_a_formula_or_constant_masses);
return(null);
}
if (MeasuredIon.MIN_REPORTER_MASS > monoMass || MeasuredIon.MIN_REPORTER_MASS > avgMass)
{
_formulaBox.ShowTextBoxErrorMonoMass(helper, string.Format(Resources.EditMeasuredIonDlg_OkDialog_Reporter_ion_masses_must_be_less_than_or_equal_to__0__,
MeasuredIon.MAX_REPORTER_MASS));
return(null);
}
if (monoMass > MeasuredIon.MAX_REPORTER_MASS || avgMass > MeasuredIon.MAX_REPORTER_MASS)
{
_formulaBox.ShowTextBoxErrorAverageMass(helper, string.Format(Resources.EditMeasuredIonDlg_OkDialog_Reporter_ion_masses_must_be_less_than_or_equal_to__0__,
MeasuredIon.MAX_REPORTER_MASS));
return(null);
}
return(new MeasuredIon(name, formula, monoMass, avgMass, charge.Value));
}
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.FormulaMass(BioMassCalc.MONOISOTOPIC, formula, SequenceMassCalc.MassPrecision);
}
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;
}
private MeasuredIon ValidateCustomIon(string name)
{
var helper = new MessageBoxHelper(this);
string formula = (_formulaBox.NeutralFormula ?? string.Empty).ToString(LocalizationHelper.CurrentCulture);
var charge = ValidateCharge();
if (!charge.HasValue)
{
return(null);
}
double monoMass;
double avgMass;
if (!string.IsNullOrEmpty(formula))
{
// Mass is specified by chemical formula
try
{
monoMass = SequenceMassCalc.FormulaMass(BioMassCalc.MONOISOTOPIC, formula, SequenceMassCalc.MassPrecision);
avgMass = SequenceMassCalc.FormulaMass(BioMassCalc.AVERAGE, formula, SequenceMassCalc.MassPrecision);
}
catch (ArgumentException x)
{
helper.ShowTextBoxError(_formulaBox, x.Message);
return(null);
}
}
else if (_formulaBox.MonoMass != null ||
_formulaBox.AverageMass != null)
{
// Mass is specified by combination of mz and charge
formula = null;
if (!_formulaBox.ValidateMonoText(helper))
{
return(null);
}
if (!_formulaBox.ValidateAverageText(helper))
{
return(null);
}
// CONSIDER(bspratt): should we switch to using adducts instead of baking ions into formula?
_formulaBox.Adduct = Adduct.FromChargeNoMass(charge.Value); // This provokes calculation of mass from displayed mz values
monoMass = _formulaBox.MonoMass.Value;
avgMass = _formulaBox.AverageMass.Value;
}
else
{
// User hasn't fully specified either way
_formulaBox.ShowTextBoxErrorFormula(helper,
Resources.EditMeasuredIonDlg_OkDialog_Please_specify_a_formula_or_constant_masses);
return(null);
}
if (MeasuredIon.MIN_REPORTER_MASS > monoMass || MeasuredIon.MIN_REPORTER_MASS > avgMass)
{
_formulaBox.ShowTextBoxErrorMonoMass(helper, string.Format(Resources.EditMeasuredIonDlg_OkDialog_Reporter_ion_masses_must_be_less_than_or_equal_to__0__,
MeasuredIon.MAX_REPORTER_MASS));
return(null);
}
if (monoMass > MeasuredIon.MAX_REPORTER_MASS || avgMass > MeasuredIon.MAX_REPORTER_MASS)
{
_formulaBox.ShowTextBoxErrorAverageMass(helper, string.Format(Resources.EditMeasuredIonDlg_OkDialog_Reporter_ion_masses_must_be_less_than_or_equal_to__0__,
MeasuredIon.MAX_REPORTER_MASS));
return(null);
}
return(new MeasuredIon(name, formula, monoMass, avgMass, Adduct.FromChargeNoMass(charge.Value))); // Charge-only adduct: user is assumed to have placed ion elements in formula
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
var charge = 0;
if (textCharge.Visible &&
!helper.ValidateSignedNumberTextBox(textCharge, _minCharge, _maxCharge, out charge))
{
return;
}
var adduct = Adduct.NonProteomicProtonatedFromCharge(charge);
if (RetentionTimeWindow.HasValue && !RetentionTime.HasValue)
{
helper.ShowTextBoxError(textRetentionTimeWindow,
Resources
.Peptide_ExplicitRetentionTimeWindow_Explicit_retention_time_window_requires_an_explicit_retention_time_value_);
return;
}
if (Adduct.IsEmpty || Adduct.AdductCharge != adduct.AdductCharge)
{
Adduct =
adduct; // Note: order matters here, this settor indirectly updates _formulaBox.MonoMass when formula is empty
}
if (string.IsNullOrEmpty(_formulaBox.NeutralFormula))
{
// Can the text fields be understood as mz?
if (!_formulaBox.ValidateAverageText(helper))
{
return;
}
if (!_formulaBox.ValidateMonoText(helper))
{
return;
}
}
var monoMass = new TypedMass(_formulaBox.MonoMass ?? 0, MassType.Monoisotopic);
var averageMass = new TypedMass(_formulaBox.AverageMass ?? 0, MassType.Average);
if (monoMass < CustomMolecule.MIN_MASS || averageMass < CustomMolecule.MIN_MASS)
{
_formulaBox.ShowTextBoxErrorFormula(helper,
string.Format(
Resources
.EditCustomMoleculeDlg_OkDialog_Custom_molecules_must_have_a_mass_greater_than_or_equal_to__0__,
CustomMolecule.MIN_MASS));
return;
}
if (monoMass > CustomMolecule.MAX_MASS || averageMass > CustomMolecule.MAX_MASS)
{
_formulaBox.ShowTextBoxErrorFormula(helper,
string.Format(
Resources
.EditCustomMoleculeDlg_OkDialog_Custom_molecules_must_have_a_mass_less_than_or_equal_to__0__,
CustomMolecule.MAX_MASS));
return;
}
if ((_transitionSettings != null) &&
(!_transitionSettings.IsMeasurablePrecursor(
adduct.MzFromNeutralMass(monoMass, MassType.Monoisotopic)) ||
!_transitionSettings.IsMeasurablePrecursor(adduct.MzFromNeutralMass(averageMass, MassType.Average))))
{
_formulaBox.ShowTextBoxErrorFormula(helper,
Resources
.SkylineWindow_AddMolecule_The_precursor_m_z_for_this_molecule_is_out_of_range_for_your_instrument_settings_);
return;
}
if (_usageMode == UsageMode.precursor)
{
// Only the adduct should be changing
SetResult(_resultCustomMolecule, Adduct);
}
else if (!string.IsNullOrEmpty(_formulaBox.NeutralFormula))
{
try
{
var name = textName.Text;
if (string.IsNullOrEmpty(name))
{
name = _formulaBox.NeutralFormula; // Clip off any adduct description
}
SetResult(new CustomMolecule(_formulaBox.NeutralFormula, name), Adduct);
}
catch (InvalidDataException x)
{
_formulaBox.ShowTextBoxErrorFormula(helper, x.Message);
return;
}
}
else
{
SetResult(new CustomMolecule(monoMass, averageMass, textName.Text), Adduct);
}
// 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.PrecursorAdduct.AsFormula(),
Adduct
.AsFormula()) && // Compare AsFormula so proteomic and non-proteomic protonation are seen as same thing
!ReferenceEquals(t, _initialId));
}))
{
helper.ShowTextBoxError(textName,
Resources
.EditCustomMoleculeDlg_OkDialog_A_precursor_with_that_adduct_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 && (Equals(transition.Adduct.AsFormula(), Adduct.AsFormula()) &&
Equals(transition.CustomIon, ResultCustomMolecule)) &&
!ReferenceEquals(t, _initialId));
})))
{
helper.ShowTextBoxError(textName,
Resources.EditCustomMoleculeDlg_OkDialog_A_similar_transition_already_exists_, textName.Text);
return;
}
DialogResult = DialogResult.OK;
}
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.FormulaMass(BioMassCalc.MONOISOTOPIC, formulaLoss, SequenceMassCalc.MassPrecision);
double massAverage = SequenceMassCalc.FormulaMass(BioMassCalc.AVERAGE, formulaLoss, SequenceMassCalc.MassPrecision);
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()
{
var helper = new MessageBoxHelper(this);
var charge = 0;
if (textCharge.Visible &&
!helper.ValidateSignedNumberTextBox(textCharge, _minCharge, _maxCharge, out charge))
{
return;
}
var adduct = Adduct.NonProteomicProtonatedFromCharge(charge);
if (RetentionTimeWindow.HasValue && !RetentionTime.HasValue)
{
helper.ShowTextBoxError(textRetentionTimeWindow,
Resources
.Peptide_ExplicitRetentionTimeWindow_Explicit_retention_time_window_requires_an_explicit_retention_time_value_);
return;
}
if (Adduct.IsEmpty || Adduct.AdductCharge != adduct.AdductCharge)
{
Adduct =
adduct; // Note: order matters here, this settor indirectly updates _formulaBox.MonoMass when formula is empty
}
if (string.IsNullOrEmpty(_formulaBox.NeutralFormula))
{
// Can the text fields be understood as mz?
if (!_formulaBox.ValidateAverageText(helper))
{
return;
}
if (!_formulaBox.ValidateMonoText(helper))
{
return;
}
}
var monoMass = new TypedMass(_formulaBox.MonoMass ?? 0, MassType.Monoisotopic);
var averageMass = new TypedMass(_formulaBox.AverageMass ?? 0, MassType.Average);
if (monoMass < CustomMolecule.MIN_MASS || averageMass < CustomMolecule.MIN_MASS)
{
_formulaBox.ShowTextBoxErrorFormula(helper,
string.Format(
Resources
.EditCustomMoleculeDlg_OkDialog_Custom_molecules_must_have_a_mass_greater_than_or_equal_to__0__,
CustomMolecule.MIN_MASS));
return;
}
if (monoMass > CustomMolecule.MAX_MASS || averageMass > CustomMolecule.MAX_MASS)
{
_formulaBox.ShowTextBoxErrorFormula(helper,
string.Format(
Resources
.EditCustomMoleculeDlg_OkDialog_Custom_molecules_must_have_a_mass_less_than_or_equal_to__0__,
CustomMolecule.MAX_MASS));
return;
}
if ((_transitionSettings != null) &&
(!_transitionSettings.IsMeasurablePrecursor(
adduct.MzFromNeutralMass(monoMass, MassType.Monoisotopic)) ||
!_transitionSettings.IsMeasurablePrecursor(adduct.MzFromNeutralMass(averageMass, MassType.Average))))
{
_formulaBox.ShowTextBoxErrorFormula(helper,
Resources
.SkylineWindow_AddMolecule_The_precursor_m_z_for_this_molecule_is_out_of_range_for_your_instrument_settings_);
return;
}
// Ion mobility value must have ion mobility units
if (textIonMobility.Visible && IonMobility.HasValue)
{
if (IonMobilityUnits == eIonMobilityUnits.none)
{
helper.ShowTextBoxError(textIonMobility, Resources.EditCustomMoleculeDlg_OkDialog_Please_specify_the_ion_mobility_units_);
comboBoxIonMobilityUnits.Focus();
return;
}
if (IonMobility.Value == 0 ||
(IonMobility.Value < 0 && !IonMobilityFilter.AcceptNegativeMobilityValues(IonMobilityUnits)))
{
helper.ShowTextBoxError(textIonMobility,
string.Format(Resources.SmallMoleculeTransitionListReader_ReadPrecursorOrProductColumns_Invalid_ion_mobility_value__0_, IonMobility));
textIonMobility.Focus();
return;
}
}
if (_usageMode == UsageMode.precursor)
{
// Only the adduct should be changing
SetResult(_resultCustomMolecule, Adduct);
}
else if (!string.IsNullOrEmpty(_formulaBox.NeutralFormula))
{
try
{
var name = textName.Text;
if (string.IsNullOrEmpty(name))
{
name = _formulaBox.NeutralFormula; // Clip off any adduct description
}
SetResult(new CustomMolecule(_formulaBox.NeutralFormula, name), Adduct);
}
catch (InvalidDataException x)
{
_formulaBox.ShowTextBoxErrorFormula(helper, x.Message);
return;
}
}
else
{
SetResult(new CustomMolecule(monoMass, averageMass, textName.Text), Adduct);
}
// Did user change the list of heavy labels?
if (_driverLabelType != null)
{
// This is the only thing the user may have altered
var newHeavyMods = _driverLabelType.GetHeavyModifications().ToArray();
if (!ArrayUtil.EqualsDeep(newHeavyMods, _peptideSettings.Modifications.HeavyModifications))
{
var labelTypes = _peptideSettings.Modifications.InternalStandardTypes.Where(t =>
newHeavyMods.Any(m => Equals(m.LabelType, t))).ToArray();
if (labelTypes.Length == 0)
{
labelTypes = new[] { newHeavyMods.First().LabelType }
}
;
PeptideModifications modifications = new PeptideModifications(
_peptideSettings.Modifications.StaticModifications,
_peptideSettings.Modifications.MaxVariableMods,
_peptideSettings.Modifications.MaxNeutralLosses,
newHeavyMods,
labelTypes);
var settings = _peptideSettings.ChangeModifications(modifications);
SrmSettings newSettings = _parent.DocumentUI.Settings.ChangePeptideSettings(settings);
if (!_parent.ChangeSettings(newSettings, true))
{
// Not expected, since we checked for a change before calling
// Otherwise, this is very confusing. The form just refuses to go away
// We would prefer to get an unhandled exception and fix this
Assume.Fail();
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.PrecursorAdduct.AsFormula(),
Adduct
.AsFormula()) && // Compare AsFormula so proteomic and non-proteomic protonation are seen as same thing
!ReferenceEquals(t, _initialId));
}))
{
helper.ShowTextBoxError(textName,
Resources
.EditCustomMoleculeDlg_OkDialog_A_precursor_with_that_adduct_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 && (Equals(transition.Adduct.AsFormula(), Adduct.AsFormula()) &&
Equals(transition.CustomIon, ResultCustomMolecule)) &&
!ReferenceEquals(t, _initialId));
})))
{
helper.ShowTextBoxError(textName,
Resources.EditCustomMoleculeDlg_OkDialog_A_similar_transition_already_exists_, textName.Text);
return;
}
DialogResult = DialogResult.OK;
}