public void Cancel() { if (!Unsaved) { DialogResult = DialogResult.Cancel; } else { DialogResult result = MultiButtonMsgDlg.Show( this, Resources.ConfigureToolsDlg_Cancel_Do_you_wish_to_Save_changes_, MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, true); switch (result) { case DialogResult.Yes: if (SaveTools()) { DialogResult = DialogResult.OK; } break; case DialogResult.No: DialogResult = DialogResult.Cancel; break; } } }
public void OkDialog() { var chosenLists = new HashSet <string>(_listsListBoxDriver.Chosen.Select(data => data.ListName)); var removedListsWithData = DocumentContainer.Document.Settings.DataSettings.Lists .Where(list => !chosenLists.Contains(list.ListName) && list.RowCount > 0).ToArray(); if (removedListsWithData.Any()) { string message; if (removedListsWithData.Length == 1) { var list = removedListsWithData[0]; message = string.Format( Resources.DocumentSettingsDlg_OkDialog_The_list___0___has__1__items_in_it__If_you_remove_that_list_from_your_document__those_items_will_be_deleted__Are_you_sure_you_want_to_delete_those_items_from_that_list_, list.ListName, list.RowCount); } else { message = TextUtil.LineSeparate(new[] { Resources.DocumentSettingsDlg_OkDialog_The_following_lists_have_items_in_them_which_will_be_deleted_when_you_remove_the_lists_from_your_document_ } .Concat(removedListsWithData.Select(list => string.Format(Resources.DocumentSettingsDlg_OkDialog_List___0___with__1__items, list.ListName, list.RowCount))) .Concat(new[] { Resources.DocumentSettingsDlg_OkDialog_Are_you_sure_you_want_to_delete_those_items_from_those_lists_ })); } if (MultiButtonMsgDlg.Show(this, message, MultiButtonMsgDlg.BUTTON_OK) == DialogResult.Cancel) { return; } } Settings.Default.ListDefList.Clear(); Settings.Default.ListDefList.AddRange(_listsListBoxDriver.List.Select(list => list.DeleteAllRows())); DialogResult = DialogResult.OK; }
/// <summary> /// Shows a dialog prompting user to decide whether to use embedded spectra when external spectra are preferred but cannot be found. /// Returns 'normal' if the user wants Embedded spectra, 'option1' to retry finding the external spectra, or to 'cancel' to abort the library build. /// </summary> public static UpdateProgressResponse ShowLibraryMissingExternalSpectraError(Control parentWindow, Exception errorException) { // E.g. could not find external raw data for MaxQuant msms.txt; ask user if they want to retry with "prefer embedded spectra" option if (!BiblioSpecLiteBuilder.IsLibraryMissingExternalSpectraError(errorException, out string spectrumFilename, out string resultsFilepath)) { throw new InvalidOperationException(@"IsLibraryMissingExternalSpectraError returned false"); } // TODO: parse supported file extensions from BiblioSpec or ProteoWizard var dialogResult = MultiButtonMsgDlg.Show(parentWindow, string.Format(Resources.VendorIssueHelper_ShowLibraryMissingExternalSpectraError_Could_not_find_an_external_spectrum_file_matching__0__in_the_same_directory_as_the_MaxQuant_input_file__1__, spectrumFilename, resultsFilepath) + string.Format(Resources.VendorIssueHelper_ShowLibraryMissingExternalSpectraError_ButtonDescriptionsSupportsExtensions__0__, BiblioSpecLiteBuilder.BiblioSpecSupportedFileExtensions), Resources.BiblioSpecLiteBuilder_Embedded, Resources.AlertDlg_GetDefaultButtonText__Retry, true); switch (dialogResult) { case DialogResult.Cancel: return(UpdateProgressResponse.cancel); case DialogResult.Yes: return(UpdateProgressResponse.normal); case DialogResult.No: return(UpdateProgressResponse.option1); default: throw new ArgumentOutOfRangeException(); } }
private bool ShowMissingMessage <TItem>(IWin32Window parent, int maxItems, HashSet <TItem> items, Func <TItem, string> printLine, Func <int, MissingMessageLines> getMessageLines) { if (items.Any()) { var sb = new StringBuilder(); var messageLines = getMessageLines(items.Count); sb.AppendLine(messageLines.First); sb.AppendLine(); int itemsToShow = Math.Min(items.Count, maxItems); var itemsList = items.ToList(); for (int i = 0; i < itemsToShow; ++i) { sb.AppendLine(printLine(itemsList[i])); } if (itemsToShow < items.Count) { sb.AppendLine(@"..."); } sb.AppendLine(); sb.Append(messageLines.Last); var dlgFiles = MultiButtonMsgDlg.Show(parent, sb.ToString(), MultiButtonMsgDlg.BUTTON_OK); if (dlgFiles == DialogResult.Cancel) { return(false); } } return(true); }
private void EnsureChorusAccount() { if (_chorusAccounts.Any()) { return; } DialogResult buttonPress = MultiButtonMsgDlg.Show( this, TextUtil.LineSeparate( Resources.OpenDataSourceDialog_EnsureChorusAccount_No_Chorus_acounts_have_been_specified, Resources.OpenDataSourceDialog_EnsureChorusAccount_Press_Register_to_register_for_an_account_on_the_Chorus_Project, Resources.OpenDataSourceDialog_EnsureChorusAccount_Press_Add_to_use_specify_an_existing_Chorus_account), Resources.OpenDataSourceDialog_EnsureChorusAccount_Register, Resources.OpenDataSourceDialog_EnsureChorusAccount_Add, true); if (buttonPress == DialogResult.Cancel) { return; } if (buttonPress == DialogResult.Yes) { // person intends to register WebHelpers.OpenLink(this, "https://chorusproject.org/pages/register.html"); // Not L10N } var newAccount = _chorusAccounts.NewItem(this, _chorusAccounts, null); if (null != newAccount) { _chorusAccounts.Add(newAccount); } }
public static bool?OverwriteAnnotations(Control parent, List <AnnotationDef> annotations) { List <string> annotationTitles = annotations.Select(annotation => annotation.GetKey()).ToList(); string annotationMultiMessage = TextUtil.LineSeparate(Resources.ConfigureToolsDlg_OverwriteAnnotations_Annotations_with_the_following_names_already_exist_, String.Empty, @"{0}", String.Empty); string annotationSingleMessage = TextUtil.LineSeparate(Resources.ConfigureToolsDlg_OverwriteAnnotations_An_annotation_with_the_following_name_already_exists_, String.Empty, @"{0}", String.Empty); string annotationMessage = annotations.Count == 1 ? annotationSingleMessage : annotationMultiMessage; string question = Resources.ConfigureToolsDlg_OverwriteAnnotations_Do_you_want_to_overwrite_or_keep_the_existing_annotations_; string messageFormat = TextUtil.LineSeparate(annotationMessage, question); DialogResult result = MultiButtonMsgDlg.Show( parent, String.Format(messageFormat, TextUtil.LineSeparate(annotationTitles)), Resources.ConfigureToolsDlg_OverwriteOrInParallel_Overwrite, Resources.ConfigureToolsDlg_OverwriteAnnotations_Keep_Existing, true); switch (result) { case DialogResult.Cancel: return(null); case DialogResult.Yes: return(true); case DialogResult.No: return(false); } return(false); }
private bool SetCalibrationPeptides(ICollection <PeptideDocNode> exclude) { CheckDisposed(); var document = Program.ActiveDocumentUI; if (!document.Settings.HasResults) { MessageDlg.Show(this, Resources.CalibrateIrtDlg_UseResults_The_document_must_contain_results_to_calibrate_a_standard); return(false); } var targetResolver = TargetResolver.MakeTargetResolver(document); _gridViewDriver.TargetResolver = targetResolver; var peptides = document.Molecules.Where(nodePep => nodePep.SchedulingTime.HasValue).ToArray(); var count = peptides.Length; if (exclude != null && exclude.Count > 0) { peptides = peptides.Where(nodePep => !exclude.Contains(nodePep)).ToArray(); count = peptides.Length; if (count < MIN_STANDARD_PEPTIDES) { MessageDlg.Show(this, ModeUIAwareStringFormat( Resources.CalibrateIrtDlg_SetCalibrationPeptides_The_document_contains_results_for__0__peptide_s__not_in_this_standard__which_is_less_than_the_minimum_requirement_of__1__to_calibrate_a_standard_, count, MIN_STANDARD_PEPTIDES)); return(false); } else if (count < MIN_SUGGESTED_STANDARD_PEPTIDES) { if (MultiButtonMsgDlg.Show(this, ModeUIAwareStringFormat( Resources.CalibrateIrtDlg_SetCalibrationPeptides_The_document_only_contains_results_for__0__peptide_s__not_in_this_standard__It_is_recommended_to_use_at_least__1__peptides_to_calibrate_a_standard__Are_you_sure_you_wish_to_continue_, count, MIN_SUGGESTED_STANDARD_PEPTIDES), MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false) != DialogResult.Yes) { return(false); } } } if (count > 20) { using (var dlg = new AddIrtStandardsDlg(count, exclude != null && exclude.Count > 0)) { if (dlg.ShowDialog(this) != DialogResult.OK) { return(false); } count = dlg.StandardCount; } } _gridViewDriver.Recalculate(document, count, exclude); return(true); }
public void OkDialog() { var reader = new StringReader(ProteinsText); var notFoundLines = new List <string>(); var acceptedProteins = new HashSet <string>(); var setProteinNames = GetProteinNames(); string line; while ((line = reader.ReadLine()) != null) { line = line.Trim(); if (string.IsNullOrEmpty(line)) { continue; } if (!setProteinNames.Contains(line)) { notFoundLines.Add(line); } else { acceptedProteins.Add(line); } } if (acceptedProteins.Count == 0) { MessageDlg.Show(this, Resources.RefineListDlgProtein_OkDialog_None_of_the_specified_proteins_are_in_the_document_); return; } if (notFoundLines.Count > 0) { string message; if (notFoundLines.Count == 1) { message = string.Format(Resources.RefineListDlgProtein_OkDialog_The_protein___0___is_not_in_the_document__Do_you_want_to_continue_, notFoundLines[0]); } else if (notFoundLines.Count < 15) { message = TextUtil.LineSeparate(Resources.RefineListDlgProtein_OkDialog_The_following_proteins_are_not_in_the_document_, string.Empty, TextUtil.LineSeparate(notFoundLines), string.Empty, Resources.RefineListDlgProtein_OkDialog_Do_you_want_to_continue); } else { message = string.Format(Resources.RefineListDlgProtein_OkDialog_Of_the_specified__0__proteins__1__are_not_in_the_document__Do_you_want_to_continue_, notFoundLines.Count + acceptedProteins.Count, notFoundLines.Count); } if (MultiButtonMsgDlg.Show(this, message, MultiButtonMsgDlg.BUTTON_OK) != DialogResult.OK) { return; } } AcceptedProteins = acceptedProteins; DialogResult = DialogResult.OK; }
public void ResetAllSettings() { if (MultiButtonMsgDlg.Show(this, string.Format( Resources .ToolOptionsUI_btnResetSettings_Click_Are_you_sure_you_want_to_clear_all_saved_settings__This_will_immediately_return__0__to_its_original_configuration_and_cannot_be_undone_, Program.Name), MultiButtonMsgDlg.BUTTON_OK) == DialogResult.OK) { Settings.Default.Reset(); } }
public void RemovePeaks(SrmDocument.DOCUMENT_TYPE docType, BoundDataGridView dataGridView) { var parent = FormUtil.FindTopLevelOwner(dataGridView); var selectedPeaks = GetSelectedPeaks(dataGridView).Distinct().ToArray(); if (selectedPeaks.Length == 0) { MessageDlg.Show(parent, Resources.RemovePeaksAction_RemovePeaks_No_peaks_are_selected); return; } var lookup = selectedPeaks.ToLookup(tuple => tuple.Item1, tuple => tuple.Item2).ToArray(); string message = GetConfirmRemoveMessage(docType, selectedPeaks.Length, lookup.Length); if (MultiButtonMsgDlg.Show(parent, message, MultiButtonMsgDlg.BUTTON_OK) != DialogResult.OK) { return; } var skylineWindow = GetSkylineWindow(dataGridView); lock (skylineWindow.GetDocumentChangeLock()) { skylineWindow.ModifyDocument(Resources.RemovePeaksAction_RemovePeaks_Remove_peaks, doc => { var longOperationRunner = new LongOperationRunner { ParentControl = parent, JobTitle = Resources.RemovePeaksAction_RemovePeaks_Removing_Peaks }; SrmDocument resultDocument = doc; doc = doc.BeginDeferSettingsChanges(); longOperationRunner.Run(broker => { for (int iGroup = 0; iGroup < lookup.Length; iGroup++) { broker.ProgressValue = iGroup * 100 / lookup.Length; if (broker.IsCanceled) { return; } doc = RemovePeaks(doc, lookup[iGroup]); } resultDocument = doc.EndDeferSettingsChanges(resultDocument, null); }); return(resultDocument); }, docPair => AuditLogEntry.CreateSingleMessageEntry( new MessageInfo(MessageType.removed_peaks, docPair.NewDocumentType, selectedPeaks.Length, lookup.Length))); } }
protected void DeleteSkylineDocNodes(Control owner, ICollection <SkylineDocNode> docNodes) { if (docNodes.Count == 0) { return; } var confirmationMessages = docNodes.Select(node => node.GetDeleteConfirmation(docNodes.Count)).Distinct() .ToArray(); string message = confirmationMessages.Length == 1 ? confirmationMessages[0] : SkylineDocNode.GetGenericDeleteConfirmation(docNodes.Count); if (MultiButtonMsgDlg.Show(owner, message, MultiButtonMsgDlg.BUTTON_OK) != DialogResult.OK) { return; } DeleteDocNodes(new HashSet <IdentityPath>(docNodes.Select(node => node.IdentityPath))); }
private void TestExportTransitionList() { var filePathActual = GetTestPath("actual.csv"); FileEx.SafeDelete(filePathActual); var exportDialog = ShowDialog <ExportMethodDlg>(() => SkylineWindow.ShowExportMethodDialog(ExportFileType.List)); // Export CE optimization transition list RunUI(() => { exportDialog.InstrumentType = ExportInstrumentType.THERMO_QUANTIVA; exportDialog.ExportStrategy = ExportStrategy.Single; exportDialog.MethodType = ExportMethodType.Standard; exportDialog.OptimizeType = ExportOptimize.NONE; exportDialog.WriteCompensationVoltages = true; }); MultiButtonMsgDlg errDlg1 = null; RunDlg <MultiButtonMsgDlg>(() => exportDialog.OkDialog(filePathActual), // Expect The_settings_for_this_document_do_not_match_the_instrument_type... errDlg => { errDlg1 = errDlg; RunUI(errDlg.ClickNo); }); // Expect You_are_missing_compensation_voltages_for_the_following... var errDlg2 = FindOpenForms <MultiButtonMsgDlg>().FirstOrDefault(f => f != errDlg1); // ReSharper disable once PossibleNullReferenceException RunUI(errDlg2.ClickOk); WaitForCondition(() => File.Exists(filePathActual)); var actual = File.ReadAllLines(filePathActual); var expected = File.ReadAllLines(GetTestPath("expected.csv")); for (var i = 0; i < Math.Min(expected.Length, actual.Length); i++) { AssertEx.AreEqual(expected[i], actual[i], $@"transitions differ at line {i}"); } AssertEx.AreEqual(expected.Length, actual.Length, @"different transition count"); }
/// <summary> /// Returns true if the tools are saved /// </summary> private bool PromptForSave() { if (Unsaved) { DialogResult toSave = MultiButtonMsgDlg.Show( this, string.Format(Resources.ConfigureToolsDlg_AddFromFile_You_must_save_changes_before_installing_tools__Would_you_like_to_save_changes_), MultiButtonMsgDlg.BUTTON_YES, Resources.ConfigureToolsDlg_AddFromFile_Cancel, false); switch (toSave) { case (DialogResult.Yes): SaveTools(); return(true); case (DialogResult.No): return(false); } } return(true); }
public static void DeleteSkylineDocNodes(SkylineWindow skylineWindow, BoundDataGridView dataGridView, IEnumerable <SkylineDocNode> docNodesToDelete) { var docNodes = (ICollection <SkylineDocNode>)DistinctNodes(docNodesToDelete).ToList(); if (docNodes.Count == 0) { return; } var owner = FormUtil.FindTopLevelOwner(dataGridView); var confirmationMessages = docNodes.Select(node => node.GetDeleteConfirmation(docNodes.Count)).Distinct() .ToArray(); string message = confirmationMessages.Length == 1 ? confirmationMessages[0] : SkylineDocNode.GetGenericDeleteConfirmation(docNodes.Count); if (MultiButtonMsgDlg.Show(owner, message, MultiButtonMsgDlg.BUTTON_OK) != DialogResult.OK) { return; } DeleteDocNodes(skylineWindow, new HashSet <IdentityPath>(docNodes.Select(node => node.IdentityPath))); }
public override void Delete() { var selectedItems = GetSelectedListItems(BoundDataGridView); if (selectedItems.Count == 0) { return; } string message = string.Format(Resources.ListViewContext_Delete_Are_you_sure_you_want_to_delete_the__0__selected_items_from_the_list___1___, selectedItems.Count, ListName); if (MultiButtonMsgDlg.Show(BoundDataGridView, message, MultiButtonMsgDlg.BUTTON_OK) != DialogResult.OK) { return; } SkylineDataSchema.ModifyDocument(EditDescription.Message(ListRef.PROTOTYPE.ChangeName(ListName), string.Format(Resources.ListViewContext_Delete_Delete_from_list___0__, ListName)), doc => { var listData = doc.Settings.DataSettings.FindList(ListName); listData = listData.DeleteItems(selectedItems); return(doc.ChangeSettings( doc.Settings.ChangeDataSettings(doc.Settings.DataSettings.ReplaceList(listData)))); }, AuditLogEntry.SettingsLogFunction); }
public bool ValidateNewRow(RowItem rowItem, out bool cancelRowEdit) { cancelRowEdit = false; var listItem = rowItem.Value as ListItem; if (listItem == null) { return(true); } var values = ((ListItem.NewRecordData)listItem.GetRecord()).UncommittedValues; if (values.Count == 0) { return(true); } try { ListItemId listItemId; var listData = SkylineDataSchema.Document.Settings.DataSettings.FindList(ListName); listData.AddRow(values, out listItemId); return(true); } catch (Exception exception) { if (MultiButtonMsgDlg.Show(BoundDataGridView, TextUtil.LineSeparate(Resources.ListViewContext_ValidateNewRow_The_new_row_could_not_be_added_because_of_the_following_error_, exception.Message, Resources.ListViewContext_ValidateNewRow_Press_OK_to_continue_editing_your_row__or_Cancel_to_throw_away_the_new_row_) , MultiButtonMsgDlg.BUTTON_OK) == DialogResult.Cancel) { cancelRowEdit = true; } return(false); } }
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 bool AddIrts(LibraryManager.BuildState buildState) { try { Library lib; ProcessedIrtAverages processed = null; var initialMessage = Resources.LibraryBuildNotificationHandler_LibraryBuildCompleteCallback_Adding_iRTs_to_library; using (var longWait = new LongWaitDlg { Text = Resources.LibraryBuildNotificationHandler_LibraryBuildCompleteCallback_Adding_iRTs_to_library }) { var status = longWait.PerformWork(TopMostApplicationForm, 800, monitor => { var initStatus = new ProgressStatus(initialMessage).ChangeSegments(0, 2); monitor.UpdateProgress(initStatus); lib = NotificationContainer.LibraryManager.TryGetLibrary(buildState.LibrarySpec) ?? NotificationContainer.LibraryManager.LoadLibrary(buildState.LibrarySpec, () => new DefaultFileLoadMonitor(monitor)); foreach (var stream in lib.ReadStreams) { stream.CloseStream(); } if (longWait.IsCanceled) { return; } var irtProviders = lib.RetentionTimeProvidersIrt.ToArray(); if (!irtProviders.Any()) { irtProviders = lib.RetentionTimeProviders.ToArray(); } processed = RCalcIrt.ProcessRetentionTimes(monitor, irtProviders, irtProviders.Length, buildState.IrtStandard.Peptides.ToArray(), new DbIrtPeptide[0]); }); if (status.IsCanceled) { return(false); } if (status.IsError) { throw status.ErrorException; } } using (var resultsDlg = new AddIrtPeptidesDlg(AddIrtPeptidesLocation.spectral_library, processed)) { if (resultsDlg.ShowDialog(TopMostApplicationForm) != DialogResult.OK) { return(false); } } var recalibrate = false; if (processed.CanRecalibrateStandards(buildState.IrtStandard.Peptides)) { using (var dlg = new MultiButtonMsgDlg( TextUtil.LineSeparate(Resources.LibraryGridViewDriver_AddToLibrary_Do_you_want_to_recalibrate_the_iRT_standard_values_relative_to_the_peptides_being_added_, Resources.LibraryGridViewDriver_AddToLibrary_This_can_improve_retention_time_alignment_under_stable_chromatographic_conditions_), MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false)) { if (dlg.ShowDialog(TopMostApplicationForm) == DialogResult.Yes) { recalibrate = true; } } } var processedDbIrtPeptides = processed.DbIrtPeptides.ToArray(); if (!processedDbIrtPeptides.Any()) { return(false); } using (var longWait = new LongWaitDlg { Text = Resources.LibraryBuildNotificationHandler_LibraryBuildCompleteCallback_Adding_iRTs_to_library }) { ImmutableList <DbIrtPeptide> newStandards = null; var status = longWait.PerformWork(TopMostApplicationForm, 800, monitor => { if (recalibrate) { monitor.UpdateProgress(new ProgressStatus().ChangeSegments(0, 2)); newStandards = ImmutableList.ValueOf(processed.RecalibrateStandards(buildState.IrtStandard.Peptides)); processed = RCalcIrt.ProcessRetentionTimes( monitor, processed.ProviderData.Select(data => data.Value.RetentionTimeProvider), processed.ProviderData.Count, newStandards.ToArray(), new DbIrtPeptide[0]); } var irtDb = IrtDb.CreateIrtDb(buildState.LibrarySpec.FilePath); irtDb.AddPeptides(monitor, (newStandards ?? buildState.IrtStandard.Peptides).Concat(processedDbIrtPeptides).ToList()); }); if (status.IsError) { throw status.ErrorException; } } } catch (Exception x) { MessageDlg.ShowWithException(TopMostApplicationForm, TextUtil.LineSeparate(Resources.LibraryBuildNotificationHandler_LibraryBuildCompleteCallback_An_error_occurred_trying_to_add_iRTs_to_the_library_, x.Message), x); return(false); } return(true); }
public void OkDialog() { IrtType irtType = GetIrtType(); if (textCalculatorName.Text.Length == 0) { MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Calculator_name_cannot_be_empty); return; } if (_existing.Select(spec => spec.Name).Contains(textCalculatorName.Text)) { var replaceResult = MultiButtonMsgDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_A_calculator_with_that_name_already_exists___Do_you_want_to_replace_it_, MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false); if (replaceResult == DialogResult.No) { return; } } if (irtType == IrtType.existing) { try { if (!File.Exists(textOpenDatabase.Text)) { MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_contain_a_path_to_a_valid_file_); textOpenDatabase.Focus(); return; } var db = IrtDb.GetIrtDb(textOpenDatabase.Text, null); if (db == null) { throw new DatabaseOpeningException(string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Cannot_read_the_database_file__0_, textOpenDatabase.Text)); } } catch (Exception x) { MessageDlg.ShowWithException(this, string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Failed_to_open_the_database_file___0_, x.Message), x); return; } } else if (irtType == IrtType.separate_list) { if (textNewDatabase.Text.Length == 0) { MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_not_be_empty_); textNewDatabase.Focus(); return; } if (!CreateIrtDatabase(textNewDatabase.Text)) { return; } } else { if (textNewDatabaseProteins.Text.Length == 0) { MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_not_be_empty_); textNewDatabaseProteins.Focus(); return; } if (comboBoxProteins.SelectedIndex == -1) { MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Please_select_a_protein_containing_the_list_of_standard_peptides_for_the_iRT_calculator_); comboBoxProteins.Focus(); return; } if (!CreateIrtDatabase(textNewDatabaseProteins.Text)) { return; } } // Make a version of the document with the new calculator in it var databaseFileName = irtType == IrtType.existing ? textOpenDatabase.Text : irtType == IrtType.separate_list ? textNewDatabase.Text : textNewDatabaseProteins.Text; var calculator = new RCalcIrt(textCalculatorName.Text, databaseFileName); // CONSIDER: Probably can't use just a static default like 10 below var retentionTimeRegression = new RetentionTimeRegression(calculator.Name, calculator, null, null, RetentionTimeRegression.DEFAULT_WINDOW, new List <MeasuredRetentionTime>()); var docNew = Document.ChangeSettings(Document.Settings.ChangePeptidePrediction(prediction => prediction.ChangeRetentionTime(retentionTimeRegression))); // Import transition list of standards, if applicable if (irtType == IrtType.separate_list) { try { if (!File.Exists(textImportText.Text)) { MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Transition_list_field_must_contain_a_path_to_a_valid_file_); return; } IdentityPath selectPath; List <MeasuredRetentionTime> irtPeptides; List <TransitionImportErrorInfo> errorList; var inputs = new MassListInputs(textImportText.Text); docNew = docNew.ImportMassList(inputs, null, out selectPath, out irtPeptides, out _librarySpectra, out errorList); if (errorList.Any()) { throw new InvalidDataException(errorList[0].ErrorMessage); } _dbIrtPeptides = irtPeptides.Select(rt => new DbIrtPeptide(rt.PeptideSequence, rt.RetentionTime, true, TimeSource.scan)).ToList(); IrtFile = textImportText.Text; } catch (Exception x) { MessageDlg.ShowWithException(this, string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Error_reading_iRT_standards_transition_list___0_, x.Message), x); return; } } else if (irtType == IrtType.protein) { PeptideGroupDocNode selectedGroup = comboBoxProteins.SelectedItem as PeptideGroupDocNode; // ReSharper disable PossibleNullReferenceException _irtPeptideSequences = new HashSet <Target>(selectedGroup.Peptides.Select(pep => pep.ModifiedTarget)); // ReSharper restore PossibleNullReferenceException } Document = docNew; DialogResult = DialogResult.OK; }
public void OkDialog() { var helper = new MessageBoxHelper(this); string name; if (!helper.ValidateNameTextBox(textName, out name)) { return; } if (_existing.Contains(en => !ReferenceEquals(_isolationScheme, en) && Equals(name, en.Name))) { helper.ShowTextBoxError(textName, Resources.EditIsolationSchemeDlg_OkDialog_The_isolation_scheme_named__0__already_exists, name); return; } if (rbUseResultsData.Checked) { double?precursorFilter = null; bool filterMargin = Equals(comboIsolationWidth.SelectedItem, IsolationWidthType.RESULTS_WITH_MARGIN); if (!Equals(comboIsolationWidth.SelectedItem, IsolationWidthType.RESULTS)) { double minFilt = filterMargin ? 0 : TransitionFullScan.MIN_PRECURSOR_MULTI_FILTER; double maxFilt = filterMargin ? TransitionFullScan.MAX_PRECURSOR_MULTI_FILTER_MARGIN : TransitionFullScan.MAX_PRECURSOR_MULTI_FILTER; double precFilt; if (!helper.ValidateDecimalTextBox(textPrecursorFilterMz, minFilt, maxFilt, out precFilt)) { return; } precursorFilter = precFilt; } try { _isolationScheme = new IsolationScheme(name, SpecialHandling, precursorFilter, null, filterMargin); } catch (InvalidDataException exception) { MessageDlg.ShowException(this, exception); return; } } else { // Validate prespecified windows. List <IsolationWindow> windowList; if ((windowList = GetIsolationWindows()) == null) { return; } // Must be at least one window. if (windowList.Count == 0) { _gridViewDriver.SelectCell(COLUMN_START, 0); MessageDlg.Show(this, Resources .EditIsolationSchemeDlg_OkDialog_Specify_Start_and_End_values_for_at_least_one_isolation_window); gridIsolationWindows.Focus(); _gridViewDriver.EditCell(); return; } int?windowsPerScan = null; if (Equals(SpecialHandling, IsolationScheme.SpecialHandlingType.MULTIPLEXED)) { int x; if (!helper.ValidateNumberTextBox(textWindowsPerScan, IsolationScheme.MIN_MULTIPLEXED_ISOLATION_WINDOWS, IsolationScheme.MAX_MULTIPLEXED_ISOLATION_WINDOWS, out x)) { return; } windowsPerScan = x; } // Check for overlap and gaps var sortedWindowList = windowList.OrderBy(o => o.Start).ToList(); bool gapsOk = false; bool overlapsOk = false; bool overlap = Overlap; int increment = overlap ? 2 : 1; int subtraction = overlap ? 3 : 1; const double tolerance = 0.0001; for (int i = 0; i < sortedWindowList.Count - subtraction; i += increment) { for (int j = 0; j < increment; j++) { IsolationWindow current = sortedWindowList.ElementAt(i + j); IsolationWindow next = sortedWindowList.ElementAt(i + j + increment); if (!gapsOk && next.Start - current.End > tolerance) { if (MultiButtonMsgDlg.Show(this, Resources .EditIsolationSchemeDlg_OkDialog_There_are_gaps_in_a_single_cycle_of_your_extraction_windows__Do_you_want_to_continue_, MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false) != DialogResult.Yes) { return; } gapsOk = true; } else if (!overlapsOk && current.End - next.Start > tolerance) { if (MultiButtonMsgDlg.Show(this, Resources.EditIsolationSchemeDlgOkDialogThereAreOverlapsContinue, MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false) != DialogResult.Yes) { return; } overlapsOk = true; } } } try { _isolationScheme = new IsolationScheme(name, windowList, SpecialHandling, windowsPerScan); } catch (InvalidDataException exception) { MessageDlg.ShowException(this, exception); return; } } DialogResult = DialogResult.OK; }
/// <summary> /// UI for warning about unrecognized peptides in imported file /// </summary> /// <param name="parent"></param> /// <returns></returns> public bool UnrecognizedPeptidesCancel(IWin32Window parent) { const int itemsToShow = 10; var peptides = UnrecognizedPeptides.ToList(); if (peptides.Any()) { var sb = new StringBuilder(); sb.AppendLine(peptides.Count == 1 ? Resources.PeakBoundaryImporter_UnrecognizedPeptidesCancel_The_following_peptide_in_the_peak_boundaries_file_was_not_recognized_ : string.Format(Resources.SkylineWindow_ImportPeakBoundaries_The_following__0__peptides_in_the_peak_boundaries_file_were_not_recognized__, peptides.Count)); sb.AppendLine(); int peptidesToShow = Math.Min(peptides.Count, itemsToShow); for (int i = 0; i < peptidesToShow; ++i) { sb.AppendLine(peptides[i]); } if (peptidesToShow < peptides.Count) { sb.AppendLine("..."); // Not L10N } sb.AppendLine(); sb.Append(peptides.Count == 1 ? Resources.PeakBoundaryImporter_UnrecognizedPeptidesCancel_Continue_peak_boundary_import_ignoring_this_peptide_ : Resources.SkylineWindow_ImportPeakBoundaries_Continue_peak_boundary_import_ignoring_these_peptides_); var dlgPeptides = MultiButtonMsgDlg.Show(parent, sb.ToString(), MultiButtonMsgDlg.BUTTON_OK); if (dlgPeptides == DialogResult.Cancel) { return(false); } } var files = UnrecognizedFiles.ToList(); if (files.Any()) { var sb = new StringBuilder(); sb.AppendLine(files.Count == 1 ? Resources.PeakBoundaryImporter_UnrecognizedPeptidesCancel_The_following_file_name_in_the_peak_boundaries_file_was_not_recognized_ : string.Format(Resources.SkylineWindow_ImportPeakBoundaries_The_following__0__file_names_in_the_peak_boundaries_file_were_not_recognized_, files.Count)); sb.AppendLine(); int filesToShow = Math.Min(files.Count, itemsToShow); for (int i = 0; i < filesToShow; ++i) { sb.AppendLine(files[i]); } if (filesToShow < files.Count) { sb.AppendLine("..."); // Not L10N } sb.AppendLine(); sb.Append(files.Count == 1 ? Resources.PeakBoundaryImporter_UnrecognizedPeptidesCancel_Continue_peak_boundary_import_ignoring_this_file_ : Resources.SkylineWindow_ImportPeakBoundaries_Continue_peak_boundary_import_ignoring_these_files_); var dlgFiles = MultiButtonMsgDlg.Show(parent, sb.ToString(), MultiButtonMsgDlg.BUTTON_OK); if (dlgFiles == DialogResult.Cancel) { return(false); } } var charges = UnrecognizedChargeStates.ToList(); if (charges.Any()) { var sb = new StringBuilder(); sb.AppendLine(files.Count == 1 ? Resources.PeakBoundaryImporter_UnrecognizedPeptidesCancel_The_following_peptide__file__and_charge_state_combination_was_not_recognized_ : string.Format(Resources.PeakBoundaryImporter_UnrecognizedPeptidesCancel_The_following__0__peptide__file__and_charge_state_combinations_were_not_recognized_, charges.Count())); sb.AppendLine(); int chargesToShow = Math.Min(charges.Count, itemsToShow); for (int i = 0; i < chargesToShow; ++i) { sb.AppendLine(charges[i].PrintLine(' ')); // Not L10N } if (chargesToShow < charges.Count) { sb.AppendLine("..."); // Not L10N } sb.AppendLine(); sb.Append(files.Count == 1 ? Resources.PeakBoundaryImporter_UnrecognizedPeptidesCancel_Continue_peak_boundary_import_ignoring_these_charge_states_ : Resources.PeakBoundaryImporter_UnrecognizedPeptidesCancel_Continue_peak_boundary_import_ignoring_this_charge_state_); var dlgFiles = MultiButtonMsgDlg.Show(parent, sb.ToString(), MultiButtonMsgDlg.BUTTON_OK); if (dlgFiles == DialogResult.Cancel) { return(false); } } return(true); }
private bool AddIrtLibraryTable(string path, IrtStandard standard) { if (!ImportPeptideSearch.HasDocLib || !ImportPeptideSearch.DocLib.IsLoaded) { return(false); } var lib = ImportPeptideSearch.DocLib; ProcessedIrtAverages processed = null; using (var longWait = new LongWaitDlg { Text = Resources.BuildPeptideSearchLibraryControl_AddIrtLibraryTable_Processing_Retention_Times }) { try { var status = longWait.PerformWork(WizardForm, 800, monitor => { var irtProviders = lib.RetentionTimeProvidersIrt.ToArray(); if (!irtProviders.Any()) { irtProviders = lib.RetentionTimeProviders.ToArray(); } processed = RCalcIrt.ProcessRetentionTimes(monitor, irtProviders, irtProviders.Length, standard.Peptides.ToArray(), new DbIrtPeptide[0]); }); if (status.IsError) { throw status.ErrorException; } } catch (Exception x) { MessageDlg.ShowWithException(WizardForm, TextUtil.LineSeparate(Resources.BuildPeptideSearchLibraryControl_AddIrtLibraryTable_An_error_occurred_while_processing_retention_times_, x.Message), x); return(false); } } using (var resultsDlg = new AddIrtPeptidesDlg(AddIrtPeptidesLocation.spectral_library, processed)) { if (resultsDlg.ShowDialog(this) != DialogResult.OK) { return(false); } } var recalibrate = false; if (processed.CanRecalibrateStandards(standard.Peptides)) { using (var dlg = new MultiButtonMsgDlg( TextUtil.LineSeparate(Resources.LibraryGridViewDriver_AddToLibrary_Do_you_want_to_recalibrate_the_iRT_standard_values_relative_to_the_peptides_being_added_, Resources.LibraryGridViewDriver_AddToLibrary_This_can_improve_retention_time_alignment_under_stable_chromatographic_conditions_), MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false)) { if (dlg.ShowDialog(WizardForm) == DialogResult.Yes) { recalibrate = true; } } } using (var longWait = new LongWaitDlg { Text = Resources.BuildPeptideSearchLibraryControl_AddIrtLibraryTable_Adding_iRTs_to_Library }) { try { ImmutableList <DbIrtPeptide> newStandards = null; var status = longWait.PerformWork(WizardForm, 800, monitor => { if (recalibrate) { monitor.UpdateProgress(new ProgressStatus().ChangeSegments(0, 2)); newStandards = ImmutableList.ValueOf(processed.RecalibrateStandards(standard.Peptides)); processed = RCalcIrt.ProcessRetentionTimes( monitor, processed.ProviderData.Select(data => data.Value.RetentionTimeProvider), processed.ProviderData.Count, newStandards.ToArray(), new DbIrtPeptide[0]); } var irtDb = IrtDb.CreateIrtDb(path); irtDb.AddPeptides(monitor, (newStandards ?? standard.Peptides).Concat(processed.DbIrtPeptides).ToList()); }); if (status.IsError) { throw status.ErrorException; } } catch (Exception x) { MessageDlg.ShowWithException(WizardForm, TextUtil.LineSeparate(Resources.BuildPeptideSearchLibraryControl_AddIrtLibraryTable_An_error_occurred_trying_to_add_iRTs_to_the_library_, x.Message), x); return(false); } } return(true); }
public static bool AddIrts(Library lib, LibrarySpec libSpec, IrtStandard standard, Control parent, bool useTopMostForm = false) { if (lib == null || !lib.IsLoaded || standard == null || standard.Name.Equals(IrtStandard.EMPTY.Name)) { return(false); } Control GetParent() { return(useTopMostForm ? FormUtil.FindTopLevelOpenForm(f => f is BuildLibraryNotification) ?? parent : parent); } IRetentionTimeProvider[] irtProviders = null; var cirtPeptides = new DbIrtPeptide[0]; using (var longWait = new LongWaitDlg { Text = Resources.LibraryBuildNotificationHandler_AddIrts_Loading_retention_time_providers }) { var status = longWait.PerformWork(GetParent(), 800, monitor => { monitor.UpdateProgress(new ProgressStatus().ChangePercentComplete(-1)); irtProviders = lib.RetentionTimeProvidersIrt.ToArray(); if (!irtProviders.Any()) { irtProviders = lib.RetentionTimeProviders.ToArray(); } if (ReferenceEquals(standard, IrtStandard.CIRT_SHORT)) { var libPeptides = irtProviders.SelectMany(provider => provider.PeptideRetentionTimes).Select(rt => rt.PeptideSequence).ToHashSet(); cirtPeptides = IrtStandard.CIRT.Peptides.Where(pep => libPeptides.Contains(pep.ModifiedTarget)).ToArray(); } }); if (status.IsCanceled) { return(false); } if (status.IsError) { throw status.ErrorException; } } int?numCirt = null; if (cirtPeptides.Length >= RCalcIrt.MIN_PEPTIDES_COUNT) { using (var dlg = new AddIrtStandardsDlg(cirtPeptides.Length, string.Format( Resources.LibraryBuildNotificationHandler_AddIrts__0__distinct_CiRT_peptides_were_found__How_many_would_you_like_to_use_as_iRT_standards_, cirtPeptides.Length))) { if (dlg.ShowDialog(GetParent()) != DialogResult.OK) { return(false); } numCirt = dlg.StandardCount; } } var standardPeptides = standard.Peptides.ToArray(); ProcessedIrtAverages processed = null; using (var longWait = new LongWaitDlg { Text = Resources.LibraryBuildNotificationHandler_AddIrts_Processing_retention_times }) { try { var status = longWait.PerformWork(GetParent(), 800, monitor => { processed = !numCirt.HasValue ? RCalcIrt.ProcessRetentionTimes(monitor, irtProviders, standardPeptides, new DbIrtPeptide[0]) : RCalcIrt.ProcessRetentionTimesCirt(monitor, irtProviders, cirtPeptides, numCirt.Value, out standardPeptides); }); if (status.IsCanceled) { return(false); } if (status.IsError) { throw status.ErrorException; } } catch (Exception x) { MessageDlg.ShowWithException(GetParent(), TextUtil.LineSeparate( Resources.BuildPeptideSearchLibraryControl_AddIrtLibraryTable_An_error_occurred_while_processing_retention_times_, x.Message), x); return(false); } } using (var resultsDlg = new AddIrtPeptidesDlg(AddIrtPeptidesLocation.spectral_library, processed)) { if (resultsDlg.ShowDialog(GetParent()) != DialogResult.OK) { return(false); } } var recalibrate = false; if (processed.CanRecalibrateStandards(standardPeptides)) { using (var dlg = new MultiButtonMsgDlg( TextUtil.LineSeparate(Resources.LibraryGridViewDriver_AddToLibrary_Do_you_want_to_recalibrate_the_iRT_standard_values_relative_to_the_peptides_being_added_, Resources.LibraryGridViewDriver_AddToLibrary_This_can_improve_retention_time_alignment_under_stable_chromatographic_conditions_), MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false)) { recalibrate = dlg.ShowDialog(GetParent()) == DialogResult.Yes; } } var processedDbIrtPeptides = processed.DbIrtPeptides.ToArray(); if (!processedDbIrtPeptides.Any()) { return(false); } using (var longWait = new LongWaitDlg { Text = Resources.LibraryBuildNotificationHandler_AddIrts_Adding_iRTs_to_library }) { try { DbIrtPeptide[] newStandards = null; var status = longWait.PerformWork(GetParent(), 800, monitor => { if (recalibrate) { monitor.UpdateProgress(new ProgressStatus().ChangeSegments(0, 2)); newStandards = processed.RecalibrateStandards(standardPeptides).ToArray(); processed = RCalcIrt.ProcessRetentionTimes(monitor, processed.ProviderData.Select(data => data.RetentionTimeProvider).ToArray(), newStandards.ToArray(), new DbIrtPeptide[0]); } var irtDb = IrtDb.CreateIrtDb(libSpec.FilePath); irtDb.AddPeptides(monitor, (newStandards ?? standardPeptides).Concat(processed.DbIrtPeptides).ToList()); }); if (status.IsError) { throw status.ErrorException; } } catch (Exception x) { MessageDlg.ShowWithException(GetParent(), TextUtil.LineSeparate( Resources.LibraryBuildNotificationHandler_AddIrts_An_error_occurred_trying_to_add_iRTs_to_the_library_, x.Message), x); return(false); } } return(true); }
public void OkDialog() { bool isModel = radioButtonModel.Checked; if (isModel) { var model = _driverPeakScoringModel.SelectedItem; if (model == null) { MessageDlg.Show(this, Resources.PeakBoundaryCompareTest_DoTest_Must_select_a_model_for_comparison_); return; } if (!model.IsTrained) { MessageDlg.Show(this, Resources.AddPeakCompareDlg_OkDialog_Model_must_be_trained_before_it_can_be_used_for_peak_boundary_comparison_); return; } BoundaryComparer = new ComparePeakBoundaries(model); } else { string displayName = textName.Text; if (displayName.Length == 0) { MessageDlg.Show(this, Resources.AddPeakCompareDlg_OkDialog_Comparison_name_cannot_be_empty_); return; } string filePath = textFilePath.Text; if (filePath.Length == 0) { MessageDlg.Show(this, Resources.AddPeakCompareDlg_OkDialog_File_path_cannot_be_empty_); return; } if (!File.Exists(filePath)) { MessageDlg.Show(this, Resources.AddPeakCompareDlg_OkDialog_File_path_field_must_contain_a_path_to_a_valid_file_); return; } BoundaryComparer = new ComparePeakBoundaries(displayName, filePath); } var compNames = _existing.Select(comp => comp.Name); if (compNames.Contains(BoundaryComparer.Name) && (_current == null || _current.Name != BoundaryComparer.Name)) { var message = isModel ? Resources.AddPeakCompareDlg_OkDialog_The_selected_model_is_already_included_in_the_list_of_comparisons__Please_choose_another_model_ : Resources.AddPeakCompareDlg_OkDialog_There_is_already_an_imported_file_with_the_current_name___Please_choose_another_name; MessageDlg.Show(this, message); return; } using (var longWaitDlg = new LongWaitDlg { Text = isModel ? Resources.AddPeakCompareDlg_OkDialog_Comparing_Models : Resources.AddPeakCompareDlg_OkDialog_Comparing_Imported_Files }) { try { longWaitDlg.PerformWork(this, 1000, pm => BoundaryComparer.GenerateComparison(Document, pm)); if (BoundaryComparer.Matches.Count == 0) { throw new IOException(Resources.AddPeakCompareDlg_OkDialog_Document_has_no_eligible_chromatograms_for_analysis___Valid_chromatograms_must_not_be_decoys_or_iRT_standards_); } if (BoundaryComparer.Matches.All(match => match.IsMissingPickedPeak)) { throw new IOException(Resources.AddPeakCompareDlg_OkDialog_The_selected_file_or_model_does_not_assign_peak_boundaries_to_any_chromatograms_in_the_document___Please_select_a_different_model_or_file_); } if (BoundaryComparer.HasNoQValues && BoundaryComparer.HasNoScores) { throw new IOException(Resources.AddPeakCompareDlg_OkDialog_The_current_file_or_model_has_no_q_values_or_scores_to_analyze___Either_q_values_or_scores_are_necessary_to_compare_peak_picking_tools_); } if (BoundaryComparer.CountMissing > 0) { var missingMessage = string.Format(Resources.AddPeakCompareDlg_OkDialog_The_imported_file_does_not_contain_any_peak_boundaries_for__0__transition_group___file_pairs___These_chromatograms_will_be_treated_as_if_no_boundary_was_selected_, BoundaryComparer.CountMissing); var dlgMissing = MultiButtonMsgDlg.Show(this, missingMessage, MultiButtonMsgDlg.BUTTON_OK); if (dlgMissing == DialogResult.Cancel) { return; } } // Show a warning message and give a chance to cancel, if there are unrecognized peptides if (BoundaryComparer.Importer != null && !BoundaryComparer.Importer.UnrecognizedPeptidesCancel(this)) { return; } } catch (Exception x) { string initMessage = isModel ? Resources.AddPeakCompareDlg_OkDialog_Error_comparing_model_peak_boundaries___0_ : Resources.AddPeakCompareDlg_OkDialog_Error_applying_imported_peak_boundaries___0_; MessageDlg.ShowWithException(this, string.Format(initMessage, x.Message), x); return; } } DialogResult = DialogResult.OK; }
public static bool?OverwriteOrInParallel(Control parent, string toolCollectionName, string toolCollectionVersion, List <ReportOrViewSpec> reportList, string foundVersion, string newCollectionName) { string message; string buttonText; if (toolCollectionName != null) { RelativeVersion relativeVersion = DetermineRelativeVersion(toolCollectionVersion, foundVersion); string toolMessage; switch (relativeVersion) { case RelativeVersion.upgrade: toolMessage = TextUtil.LineSeparate(Resources.ConfigureToolsDlg_OverwriteOrInParallel_The_tool__0__is_currently_installed_, String.Empty, String.Format(Resources.ConfigureToolsDlg_OverwriteOrInParallel_Do_you_wish_to_upgrade_to__0__or_install_in_parallel_, foundVersion)); buttonText = Resources.ConfigureToolsDlg_OverwriteOrInParallel_Upgrade; break; case RelativeVersion.olderversion: toolMessage = TextUtil.LineSeparate( String.Format(Resources.ConfigureToolsDlg_OverwriteOrInParallel_This_is_an_older_installation_v_0__of_the_tool__1_, foundVersion, @"{0}"), String.Empty, String.Format(Resources.ConfigureToolsDlg_OverwriteOrInParallel_Do_you_wish_to_overwrite_with_the_older_version__0__or_install_in_parallel_, foundVersion)); buttonText = Resources.ConfigureToolsDlg_OverwriteOrInParallel_Overwrite; break; case RelativeVersion.reinstall: toolMessage = TextUtil.LineSeparate(Resources.ConfigureToolsDlg_OverwriteOrInParallel_The_tool__0__is_already_installed_, String.Empty, Resources.ConfigureToolsDlg_OverwriteOrInParallel_Do_you_wish_to_reinstall_or_install_in_parallel_); buttonText = Resources.ConfigureToolsDlg_OverwriteOrInParallel_Reinstall; break; default: toolMessage = TextUtil.LineSeparate( Resources.ConfigureToolsDlg_OverwriteOrInParallel_The_tool__0__is_in_conflict_with_the_new_installation, String.Empty, Resources.ConfigureToolsDlg_OverwriteOrInParallel_Do_you_wish_to_overwrite_or_install_in_parallel_); buttonText = Resources.ConfigureToolsDlg_OverwriteOrInParallel_Overwrite; // Or update? break; } message = String.Format(toolMessage, toolCollectionName); } else //Warn about overwritng report. { List <string> reportTitles = reportList.Select(sp => sp.GetKey()).ToList(); string reportMultiMessage = TextUtil.LineSeparate(Resources.ConfigureToolsDlg_OverwriteOrInParallel_This_installation_would_modify_the_following_reports, String.Empty, @"{0}", String.Empty); string reportSingleMessage = TextUtil.LineSeparate(Resources.ConfigureToolsDlg_OverwriteOrInParallel_This_installation_would_modify_the_report_titled__0_, String.Empty); string reportMessage = reportList.Count == 1 ? reportSingleMessage : reportMultiMessage; string question = Resources.ConfigureToolsDlg_OverwriteOrInParallel_Do_you_wish_to_overwrite_or_install_in_parallel_; buttonText = Resources.ConfigureToolsDlg_OverwriteOrInParallel_Overwrite; string reportMessageFormat = TextUtil.LineSeparate(reportMessage, question); message = String.Format(reportMessageFormat, TextUtil.LineSeparate(reportTitles)); } DialogResult result = MultiButtonMsgDlg.Show( parent, message, buttonText, Resources.ConfigureToolsDlg_OverwriteOrInParallel_In_Parallel, true); switch (result) { case DialogResult.Cancel: return(null); case DialogResult.Yes: return(true); case DialogResult.No: return(false); } return(false); }
public void UploadSharedZipFile(Control parent, Server server, string zipFilePath, string folderPath) { Uri result = null; if (server == null) { return; } try { var isCanceled = false; using (var waitDlg = new LongWaitDlg { Text = Resources.PublishDocumentDlg_UploadSharedZipFile_Uploading_File }) { waitDlg.PerformWork(parent, 1000, longWaitBroker => { result = SendZipFile(server, folderPath, zipFilePath, longWaitBroker); if (longWaitBroker.IsCanceled) { isCanceled = true; } }); } if (!isCanceled) // if user not canceled { String message = Resources.WebPanoramaPublishClient_UploadSharedZipFile_Publish_succeeded__would_you_like_to_view_the_file_in_Panorama_; if (MultiButtonMsgDlg.Show(parent, message, MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false) == DialogResult.Yes) { Process.Start(result.ToString()); } } } catch (Exception x) { var panoramaEx = x.InnerException as PanoramaImportErrorException; if (panoramaEx != null) { var message = Resources.WebPanoramaPublishClient_UploadSharedZipFile_An_error_occured_while_publishing_to_Panorama__would_you_like_to_go_to_Panorama_; if (MultiButtonMsgDlg.Show(parent, message, MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, false) == DialogResult.Yes) { Process.Start(panoramaEx.JobUrl.ToString()); } } else { MessageDlg.ShowException(parent, x); } } // Change PanoramaUrl setting to the successful url used var uriString = server.GetKey() + folderPath; uriString = Uri.EscapeUriString(uriString); var window = parent as SkylineWindow; if (window != null && Uri.IsWellFormedUriString(uriString, UriKind.Absolute)) // cant do Uri.isWellFormed because of port and ip { window.ChangeDocPanoramaUri(new Uri(uriString)); } }
public void OkDialog() { var reader = new StringReader(PeptidesText); var invalidLines = new List <string>(); var notFoundLines = new List <string>(); var acceptedPeptides = new List <LibraryKey>(); var peptideSequences = GetPeptideSequences(); string line; while ((line = reader.ReadLine()) != null) { line = line.Trim(); if (string.IsNullOrEmpty(line)) { continue; } int foundAt; var charge = Transition.GetChargeFromIndicator(line, TransitionGroup.MIN_PRECURSOR_CHARGE, TransitionGroup.MAX_PRECURSOR_CHARGE, out foundAt); if (!charge.IsEmpty) { line = line.Substring(0, foundAt); } Target target; try { // CONSIDER(bspratt) small molecule equivalent? if (!FastaSequence.IsExSequence(line)) { invalidLines.Add(line); continue; } line = SequenceMassCalc.NormalizeModifiedSequence(line); target = new Target(line); } catch (Exception) { invalidLines.Add(line); continue; } if (!peptideSequences.ContainsKey(target)) { notFoundLines.Add(line); } else { acceptedPeptides.Add(new LibKey(target, charge).LibraryKey); } } if (invalidLines.Count > 0) { if (invalidLines.Count == 1) { MessageDlg.Show(this, string.Format(Resources.RefineListDlg_OkDialog_The_sequence__0__is_not_a_valid_peptide, invalidLines[0])); } else { MessageDlg.Show(this, TextUtil.LineSeparate(Resources.RefineListDlg_OkDialog_The_following_sequences_are_not_valid_peptides, string.Empty, TextUtil.LineSeparate(invalidLines))); } return; } if (acceptedPeptides.Count == 0) { MessageDlg.Show(this, Resources.RefineListDlg_OkDialog_None_of_the_specified_peptides_are_in_the_document); return; } if (notFoundLines.Count > 0) { string message; if (notFoundLines.Count == 1) { message = string.Format(Resources.RefineListDlg_OkDialog_The_peptide__0__is_not_in_the_document_Do_you_want_to_continue, notFoundLines[0]); } else if (notFoundLines.Count < 15) { message = TextUtil.LineSeparate(Resources.RefineListDlg_OkDialog_The_following_peptides_are_not_in_the_document, string.Empty, TextUtil.LineSeparate(notFoundLines), string.Empty, Resources.RefineListDlg_OkDialog_Do_you_want_to_continue); } else { message = string.Format(Resources.RefineListDlg_OkDialog_Of_the_specified__0__peptides__1__are_not_in_the_document_Do_you_want_to_continue, notFoundLines.Count + acceptedPeptides.Count, notFoundLines.Count); } if (MultiButtonMsgDlg.Show(this, message, MultiButtonMsgDlg.BUTTON_OK) != DialogResult.OK) { return; } } AcceptedPeptides = acceptedPeptides.ToArray(); DialogResult = DialogResult.OK; }
private bool GetPackages() { ICollection <string> downloadablePackages = new Collection <string>(); ICollection <string> localPackages = new Collection <string>(); AssignPackagesToInstall(ref downloadablePackages, ref localPackages); IEnumerable <string> packagePaths = null; try { // download packages using (var waitDlg = new LongWaitDlg { ProgressValue = 0 }) { waitDlg.PerformWork(this, 500, longWaitBroker => packagePaths = DownloadPackages(longWaitBroker, downloadablePackages)); } // separate packages ICollection <string> exePaths = new Collection <string>(); ICollection <string> sourcePaths = new Collection <string>(); foreach (var package in (packagePaths == null) ? localPackages : packagePaths.Concat(localPackages)) { if (package.EndsWith(@".exe")) { exePaths.Add(package); } else { sourcePaths.Add(package); } } // first install executable packages, if any if (exePaths.Count != 0) { using (var waitDlg = new LongWaitDlg(null, false) { Message = Resources.PythonInstaller_GetPackages_Installing_Packages }) { waitDlg.PerformWork(this, 500, () => InstallExecutablePackages(exePaths)); } } // then install source paths, if any if (sourcePaths.Count != 0) { // try and find the path to the pip package manager .exe string pipPath = PythonUtil.GetPipPath(_version); // if it can't be found, install it if (pipPath == null || TestingPip) { DialogResult result = MultiButtonMsgDlg.Show( this, Resources.PythonInstaller_InstallPackages_Skyline_uses_the_Python_tool_setuptools_and_the_Python_package_manager_Pip_to_install_packages_from_source__Click_install_to_begin_the_installation_process_, Resources.PythonInstaller_InstallPackages_Install); if (result == DialogResult.OK && GetPip()) { pipPath = PythonUtil.GetPipPath(_version); MessageDlg.Show(this, Resources.PythonInstaller_InstallPackages_Pip_installation_complete_); } else { MessageDlg.Show(this, Resources.PythonInstaller_InstallPackages_Python_package_installation_cannot_continue__Canceling_tool_installation_); return(false); } } using (var waitDlg = new LongWaitDlg(null, false) { Message = Resources.PythonInstaller_GetPackages_Installing_Packages }) { waitDlg.PerformWork(this, 500, () => InstallSourcePackages(sourcePaths, pipPath)); } } MessageDlg.Show(this, Resources.PythonInstaller_GetPackages_Package_installation_completed_); return(true); } catch (TargetInvocationException ex) { if (ex.InnerException is ToolExecutionException) { MessageDlg.ShowException(this, ex); return(false); } throw; } }
private void populateListViewFromDirectory(MsDataFileUri directory) { _abortPopulateList = false; listView.Cursor = Cursors.Default; _waitingForData = false; listView.Items.Clear(); var listSourceInfo = new List <SourceInfo>(); if (null == directory || directory is MsDataFilePath && string.IsNullOrEmpty(((MsDataFilePath)directory).FilePath)) { foreach (DriveInfo driveInfo in DriveInfo.GetDrives()) { string label = string.Empty; string sublabel = driveInfo.Name; ImageIndex imageIndex = ImageIndex.Folder; _driveReadiness[sublabel] = false; try { switch (driveInfo.DriveType) { case DriveType.Fixed: imageIndex = ImageIndex.LocalDrive; label = Resources.OpenDataSourceDialog_populateListViewFromDirectory_Local_Drive; if (driveInfo.VolumeLabel.Length > 0) { label = driveInfo.VolumeLabel; } break; case DriveType.CDRom: imageIndex = ImageIndex.OpticalDrive; label = Resources.OpenDataSourceDialog_populateListViewFromDirectory_Optical_Drive; if (driveInfo.IsReady && driveInfo.VolumeLabel.Length > 0) { label = driveInfo.VolumeLabel; } break; case DriveType.Removable: imageIndex = ImageIndex.OpticalDrive; label = Resources.OpenDataSourceDialog_populateListViewFromDirectory_Removable_Drive; if (driveInfo.IsReady && driveInfo.VolumeLabel.Length > 0) { label = driveInfo.VolumeLabel; } break; case DriveType.Network: label = Resources.OpenDataSourceDialog_populateListViewFromDirectory_Network_Share; break; } _driveReadiness[sublabel] = IsDriveReady(driveInfo); } catch (Exception) { label += string.Format(@" ({0})", Resources.OpenDataSourceDialog_populateListViewFromDirectory_access_failure); } string name = driveInfo.Name; if (label != string.Empty) { name = string.Format(@"{0} ({1})", label, name); } listSourceInfo.Add(new SourceInfo(new MsDataFilePath(driveInfo.RootDirectory.FullName)) { type = DataSourceUtil.FOLDER_TYPE, imageIndex = imageIndex, name = name, dateModified = GetDriveModifiedTime(driveInfo) }); } } else if (directory is RemoteUrl) { RemoteUrl remoteUrl = directory as RemoteUrl; if (string.IsNullOrEmpty(remoteUrl.ServerUrl)) { foreach (var remoteAccount in _remoteAccounts) { listSourceInfo.Add(new SourceInfo(remoteAccount.GetRootUrl()) { name = remoteAccount.GetKey(), type = DataSourceUtil.FOLDER_TYPE, imageIndex = ImageIndex.MyNetworkPlaces, }); } } else { RemoteAccount remoteAccount = GetRemoteAccount(remoteUrl); if (RemoteSession == null || !Equals(remoteAccount, RemoteSession.Account)) { RemoteSession = RemoteSession.CreateSession(remoteAccount); } RemoteServerException exception; bool isComplete = _remoteSession.AsyncFetchContents(remoteUrl, out exception); foreach (var item in _remoteSession.ListContents(remoteUrl)) { var imageIndex = DataSourceUtil.IsFolderType(item.Type) ? ImageIndex.Folder : ImageIndex.MassSpecFile; listSourceInfo.Add(new SourceInfo(item.MsDataFileUri) { name = item.Label, type = item.Type, imageIndex = imageIndex, dateModified = item.LastModified, size = item.FileSize }); } if (null != exception) { if (MultiButtonMsgDlg.Show(this, exception.Message, Resources.OpenDataSourceDialog_populateListViewFromDirectory_Retry) != DialogResult.Cancel) { RemoteSession.RetryFetchContents(remoteUrl); isComplete = false; } } if (!isComplete) { listView.Cursor = Cursors.WaitCursor; _waitingForData = true; } } } else if (directory is MsDataFilePath) { MsDataFilePath msDataFilePath = (MsDataFilePath)directory; DirectoryInfo dirInfo = new DirectoryInfo(msDataFilePath.FilePath); try { // subitems: Name, Type, Spectra, Size, Date Modified var arraySubDirInfo = dirInfo.GetDirectories(); Array.Sort(arraySubDirInfo, (d1, d2) => string.Compare(d1.Name, d2.Name, StringComparison.CurrentCultureIgnoreCase)); var arrayFileInfo = dirInfo.GetFiles(); Array.Sort(arrayFileInfo, (f1, f2) => string.Compare(f1.Name, f2.Name, StringComparison.CurrentCultureIgnoreCase)); // Calculate information about the files, allowing the user to cancel foreach (var info in arraySubDirInfo) { listSourceInfo.Add(getSourceInfo(info)); Application.DoEvents(); if (_abortPopulateList) { //MessageBox.Show( "abort" ); break; } } if (!_abortPopulateList) { foreach (var info in arrayFileInfo) { listSourceInfo.Add(getSourceInfo(info)); Application.DoEvents(); if (_abortPopulateList) { //MessageBox.Show( "abort" ); break; } } } } catch (Exception x) { var message = TextUtil.LineSeparate( Resources.OpenDataSourceDialog_populateListViewFromDirectory_An_error_occurred_attempting_to_retrieve_the_contents_of_this_directory, x.Message); // Might throw access violation. MessageDlg.ShowWithException(this, message, x); return; } } // Populate the list var items = new List <ListViewItem>(); foreach (var sourceInfo in listSourceInfo) { if (sourceInfo != null && (sourceTypeComboBox.SelectedIndex == 0 || sourceTypeComboBox.SelectedItem.ToString() == sourceInfo.type || // Always show folders sourceInfo.isFolder)) { ListViewItem item = new ListViewItem(sourceInfo.ToArray(), (int)sourceInfo.imageIndex) { Tag = sourceInfo, }; item.SubItems[2].Tag = sourceInfo.size; item.SubItems[3].Tag = sourceInfo.dateModified; items.Add(item); } } listView.Items.AddRange(items.ToArray()); }
public override void Delete() { if (null == BoundDataGridView) { return; } var selectedRows = GetSelectedRows <FoldChangeBindingSource.FoldChangeRow>(BoundDataGridView); if (!selectedRows.Any()) { MessageDlg.Show(BoundDataGridView, GroupComparisonStrings.GroupComparisonViewContext_Delete_No_rows_are_selected); return; } var docNodes = new Dictionary <IdentityPath, SkylineDocNode>(); foreach (var row in selectedRows) { if (row.Peptide != null) { docNodes[row.Peptide.IdentityPath] = row.Peptide; } else { docNodes[row.Protein.IdentityPath] = row.Protein; } } string message; if (docNodes.Count == 1) { var peptide = docNodes.Values.First() as Peptide; if (null != peptide) { message = string.Format(GroupComparisonStrings.GroupComparisonViewContext_Delete_Are_you_sure_you_want_to_delete_the_peptide__0_, peptide); } else { var protein = docNodes.Values.First() as Protein; message = string.Format(GroupComparisonStrings.GroupComparisonViewContext_Delete_Are_you_sure_you_want_to_delete_the_protein__0_, protein); } } else { if (docNodes.Values.First() is Peptide) { message = string.Format(GroupComparisonStrings.GroupComparisonViewContext_Delete_Are_you_sure_you_want_to_delete_these__0__peptides, docNodes.Count); } else { message = string.Format(GroupComparisonStrings.GroupComparisonViewContext_Delete_Are_you_sure_you_want_to_delete_these__0__proteins, docNodes.Count); } } if (MultiButtonMsgDlg.Show(BoundDataGridView, message, Resources.OK) != DialogResult.OK) { return; } var identityPathsToDelete = new HashSet <IdentityPath>(docNodes.Keys); var skylineWindow = ((SkylineDataSchema)DataSchema).SkylineWindow; if (null != skylineWindow) { skylineWindow.ModifyDocument(GroupComparisonStrings.GroupComparisonViewContext_Delete_Delete_items, doc => DeleteProteins(doc, identityPathsToDelete)); } }