/// <summary>
/// the same with the itemset extension ,picku all the sequence node and do sequence extension
/// </summary>
/// <returns></returns>
private SequenceTree <string> SequenceExtension()
{
SequenceTree = new SequenceTree <string>(DataSet.NumberOfRows);
var queue = new Queue <SequenceNode <string> >();
Sequence <string> s;
SequenceNode <string> node;
// first we insert all the itemset into the sequence tree as the children of the root node
foreach (var frequentItemset in DataSet.GetItemSILDic())
{
s = new Sequence <string>(new Itemset <string>(frequentItemset.Key.Split(' ')), 0);
var VIL = frequentItemset.Value.GetStartingVIL();
node = SequenceTree.AddChild(SequenceTree.Root, s, VIL, frequentItemset.Value.Support);
queue.Enqueue(node);
}
// then we pick every node of the root's children then do the the sequence extension
while (queue.Count != 0)
{
node = queue.Dequeue();
SequenceExtension(SequenceTree, node);
foreach (var child in node.GetChildren)
{
queue.Enqueue(child);
}
}
return(SequenceTree);
}
public static Image GetPeakImage(TransitionDocNode nodeTran,
PeptideDocNode nodePep, SequenceTree sequenceTree)
{
int imageIndex = GetPeakImageIndex(nodeTran, nodePep, sequenceTree);
return(imageIndex != -1 ? sequenceTree.StateImageList.Images[imageIndex] : null);
}
protected override void OnModelChanged()
{
int typeImageIndex = TypeImageIndex;
if (typeImageIndex != ImageIndex)
{
ImageIndex = SelectedImageIndex = typeImageIndex;
}
int peakImageIndex = PeakImageIndex;
// ReSharper disable RedundantCheckBeforeAssignment
if (peakImageIndex != StateImageIndex)
{
StateImageIndex = peakImageIndex;
}
// ReSharper restore RedundantCheckBeforeAssignment
var nodePep = (PeptideDocNode)Model;
string label = DisplayText(nodePep, SequenceTree.GetDisplaySettings(nodePep));
if (!string.Equals(label, Text))
{
Text = label;
}
// Hard to tell what might cause label formatting to change
_textSequences = null;
// Make sure children are up to date
OnUpdateChildren(SequenceTree.ExpandPeptides);
}
protected override void OnModelChanged()
{
int typeImageIndex = TypeImageIndex;
if (typeImageIndex != ImageIndex)
{
ImageIndex = SelectedImageIndex = typeImageIndex;
}
int peakImageIndex = PeakImageIndex;
// ReSharper disable RedundantCheckBeforeAssignment
if (peakImageIndex != StateImageIndex)
{
StateImageIndex = peakImageIndex;
}
// ReSharper restore RedundantCheckBeforeAssignment
string label = DisplayText(DocNode, SequenceTree.GetDisplaySettings(PepNode));
if (!Equals(label, Text))
{
Text = label;
}
// Make sure children are up to date
OnUpdateChildren(SequenceTree.ExpandPrecursors);
}
public static int GetPeakImageIndex(PeptideDocNode nodePep, SequenceTree sequenceTree)
{
var settings = sequenceTree.Document.Settings;
if (!settings.HasResults)
{
return(-1);
}
int index = sequenceTree.GetDisplayResultsIndex(nodePep);
float?ratio = (nodePep.HasResults ? nodePep.GetPeakCountRatio(index) : null);
if (ratio == null)
{
return((int)SequenceTree.StateImageId.peak_blank);
}
if (ratio < 0.5)
{
return((int)SequenceTree.StateImageId.no_peak);
}
if (ratio < 1.0)
{
return((int)SequenceTree.StateImageId.keep);
}
return((int)SequenceTree.StateImageId.peak);
}
//public string PROTEIN_TITLE = "Protein";
//public const string PEPTIDE_LIST_TITLE = "Peptide List";
public static PeptideGroupTreeNode CreateInstance(SequenceTree tree, DocNode nodeDoc)
{
var nodeTree = new PeptideGroupTreeNode(tree, (PeptideGroupDocNode)nodeDoc);
if (tree.ExpandProteins)
{
nodeTree.Expand();
}
return(nodeTree);
}
public static PeptideTreeNode CreateInstance(SequenceTree tree, DocNode nodeDoc)
{
Debug.Assert(nodeDoc is PeptideDocNode);
var nodeTree = new PeptideTreeNode(tree, (PeptideDocNode)nodeDoc);
if (tree.ExpandPeptides)
{
nodeTree.Expand();
}
return(nodeTree);
}
public static TransitionGroupTreeNode CreateInstance(SequenceTree tree, DocNode nodeDoc)
{
Debug.Assert(nodeDoc is TransitionGroupDocNode);
var nodeTree = new TransitionGroupTreeNode(tree, (TransitionGroupDocNode)nodeDoc);
if (tree.ExpandPrecursors)
{
nodeTree.Expand();
}
return(nodeTree);
}
public void EndUpdateDoc()
{
if (_updateLockCountDoc == 0)
{
return;
}
SequenceTree.EndUpdateDoc();
if (--_updateLockCountDoc == 0 && !ReferenceEquals(_updateDocPrevious, SequenceTree.DocumentContainer.Document))
{
var settingsPrevious = _updateDocPrevious != null ? _updateDocPrevious.Settings : null;
UpdateResultsUI(SequenceTree.DocumentContainer.Document.Settings, settingsPrevious);
_updateDocPrevious = null;
}
}
private void SetSequenceTree(SequenceTree sequenceTree)
{
if (ReferenceEquals(_sequenceTree, sequenceTree))
{
return;
}
if (null != _sequenceTree)
{
_sequenceTree.AfterSelect -= SequenceTreeOnAfterSelect;
}
_sequenceTree = sequenceTree;
if (null != _sequenceTree)
{
_sequenceTree.AfterSelect += SequenceTreeOnAfterSelect;
SelectedIdentityPaths = _sequenceTree.SelectedPaths;
}
}
public override Size RenderTip(Graphics g, Size sizeMax, bool draw)
{
var size = base.RenderTip(g, sizeMax, draw);
if (ShowAnnotationTipOnly)
{
return(size);
}
if (draw)
{
g.TranslateTransform(0, size.Height);
}
Size sizeMaxNew = new Size(sizeMax.Width, sizeMax.Height - size.Height);
var nodeTranTree = SequenceTree.GetNodeOfType <TransitionTreeNode>();
var nodeTranSelected = (nodeTranTree != null ? nodeTranTree.DocNode : null);
var sizeNew = RenderTip(DocNode, nodeTranSelected, DocSettings, g, sizeMaxNew, draw);
return(new Size(Math.Max(size.Width, sizeNew.Width), size.Height + sizeNew.Height));
}
public ImportFastaControl(IModifyDocumentContainer documentContainer, SequenceTree sequenceTree)
{
DocumentContainer = documentContainer;
_sequenceTree = sequenceTree;
InitializeComponent();
ImportFastaHelper = new ImportFastaHelper(tbxFasta, tbxError, panelError, helpTipFasta);
tbxFastaHeightDifference = Height - tbxFasta.Height;
_driverEnzyme = new SettingsListComboDriver <Enzyme>(comboEnzyme, Settings.Default.EnzymeList);
_driverEnzyme.LoadList(DocumentContainer.Document.Settings.PeptideSettings.Enzyme.GetKey());
MaxMissedCleavages = documentContainer.Document.Settings.PeptideSettings.DigestSettings.MaxMissedCleavages;
cbDecoyMethod.Items.Add(string.Empty);
cbDecoyMethod.Items.Add(DecoyGeneration.SHUFFLE_SEQUENCE);
cbDecoyMethod.Items.Add(DecoyGeneration.REVERSE_SEQUENCE);
cbDecoyMethod.SelectedIndex = 0;
}
// Support multiple selection (though using peptide settings is more efficient way to do this filtering)
public static List <PeptideGroupTreeNode> PeptideSelection(SequenceTree sequenceTree)
{
var peptideGroupTreeNodes = new List <PeptideGroupTreeNode>();
foreach (var node in sequenceTree.SelectedNodes)
{
PeptideGroupTreeNode peptideGroupTreeNode = null;
var treeNode = node as SrmTreeNode;
if (treeNode != null)
{
peptideGroupTreeNode = treeNode.GetNodeOfType <PeptideGroupTreeNode>();
}
if (peptideGroupTreeNode != null && peptideGroupTreeNode.ChildDocNodes.Cast <PeptideDocNode>().Any(n => n.IsProteomic))
{
peptideGroupTreeNodes.Add(peptideGroupTreeNode);
}
}
return(peptideGroupTreeNodes);
}
private bool TryGetSelectedPeptide(out PeptideGroupDocNode peptideGroup, out PeptideDocNode peptide)
{
peptide = null;
peptideGroup = null;
SequenceTree sequenceTree = _skylineWindow.SequenceTree;
if (null != sequenceTree)
{
PeptideTreeNode peptideTreeNode = sequenceTree.GetNodeOfType<PeptideTreeNode>();
if (null != peptideTreeNode)
{
peptide = peptideTreeNode.DocNode;
}
PeptideGroupTreeNode peptideGroupTreeNode = sequenceTree.GetNodeOfType<PeptideGroupTreeNode>();
if (null != peptideGroupTreeNode)
{
peptideGroup = peptideGroupTreeNode.DocNode;
}
}
return peptide != null;
}
protected override void OnModelChanged()
{
int typeImageIndex = TypeImageIndex;
if (typeImageIndex != ImageIndex)
{
ImageIndex = SelectedImageIndex = typeImageIndex;
}
int peakImageIndex = PeakImageIndex;
// ReSharper disable RedundantCheckBeforeAssignment
if (peakImageIndex != StateImageIndex)
{
StateImageIndex = peakImageIndex;
}
// ReSharper restore RedundantCheckBeforeAssignment
string label = DisplayText(DocNode, SequenceTree.GetDisplaySettings(PepNode));
if (!Equals(label, Text))
{
Text = label;
}
ForeColor = DocNode.ExplicitQuantitative ? SystemColors.WindowText : SystemColors.GrayText;
}
// Support multiple selection (though using peptide settings is more efficient way to do this filtering)
public static List <PeptideGroupTreeNode> PeptideSelection(SequenceTree sequenceTree)
{
HashSet <PeptideGroupTreeNode> treeNodeSet = new HashSet <PeptideGroupTreeNode>();
var peptideGroupTreeNodes = new List <PeptideGroupTreeNode>();
foreach (var node in sequenceTree.SelectedNodes)
{
PeptideGroupTreeNode peptideGroupTreeNode = null;
var treeNode = node as SrmTreeNode;
if (treeNode != null)
{
peptideGroupTreeNode = treeNode.GetNodeOfType <PeptideGroupTreeNode>();
}
if (peptideGroupTreeNode == null || !treeNodeSet.Add(peptideGroupTreeNode))
{
continue;
}
if (peptideGroupTreeNode.DocNode.Peptides.Any())
{
peptideGroupTreeNodes.Add(peptideGroupTreeNode);
}
}
return(peptideGroupTreeNodes);
}
//public string PROTEIN_TITLE = "Protein";
//public const string PEPTIDE_LIST_TITLE = "Peptide List";
public static PeptideGroupTreeNode CreateInstance(SequenceTree tree, DocNode nodeDoc)
{
var nodeTree = new PeptideGroupTreeNode(tree, (PeptideGroupDocNode)nodeDoc);
if (tree.ExpandProteins)
nodeTree.Expand();
return nodeTree;
}
private void SetSequenceTree(SequenceTree sequenceTree)
{
if (ReferenceEquals(_sequenceTree, sequenceTree))
{
return;
}
if (null != _sequenceTree)
{
_sequenceTree.AfterSelect -= SequenceTreeOnAfterSelect;
}
_sequenceTree = sequenceTree;
if (null != _sequenceTree)
{
_sequenceTree.AfterSelect += SequenceTreeOnAfterSelect;
SelectedIdentityPaths = _sequenceTree.SelectedPaths;
}
}
public static TransitionTreeNode CreateInstance(SequenceTree tree, DocNode nodeDoc)
{
Debug.Assert(nodeDoc is TransitionDocNode);
return new TransitionTreeNode(tree, (TransitionDocNode)nodeDoc);
}
// ReSharper disable SuggestBaseTypeForParameter
public PeptideTreeNode(SequenceTree tree, PeptideDocNode nodePeptide)
// ReSharper restore SuggestBaseTypeForParameter
: base(tree, nodePeptide)
{
}
public static TransitionGroupTreeNode CreateInstance(SequenceTree tree, DocNode nodeDoc)
{
Debug.Assert(nodeDoc is TransitionGroupDocNode);
var nodeTree = new TransitionGroupTreeNode(tree, (TransitionGroupDocNode) nodeDoc);
if (tree.ExpandPrecursors)
nodeTree.Expand();
return nodeTree;
}
public static Image GetTypeImage(PeptideDocNode nodePep, SequenceTree sequenceTree)
{
return(sequenceTree.ImageList.Images[GetTypeImageIndex(nodePep)]);
}
private const string DOTP_FORMAT = "0.##"; // Not L10N
#endregion Fields
#region Constructors
public TransitionGroupTreeNode(SequenceTree tree, TransitionGroupDocNode nodeGroup)
: base(tree, nodeGroup)
{
}
public static Image GetTypeImage(TransitionDocNode nodeTran, SequenceTree sequenceTree)
{
return(sequenceTree.ImageList.Images[GetTypeImageIndex(nodeTran)]);
}
public static TransitionTreeNode CreateInstance(SequenceTree tree, DocNode nodeDoc)
{
Debug.Assert(nodeDoc is TransitionDocNode);
return(new TransitionTreeNode(tree, (TransitionDocNode)nodeDoc));
}
public TransitionTreeNode(SequenceTree tree, TransitionDocNode ion)
: base(tree, ion)
{
}
// ReSharper restore SuggestBaseTypeForParameter
// ReSharper disable SuggestBaseTypeForParameter
public PeptideTreeNode(SequenceTree tree, PeptideDocNode nodePeptide)
: base(tree, nodePeptide)
{
}
public static Image GetTypeImage(PeptideDocNode nodePep, SequenceTree sequenceTree)
{
return sequenceTree.ImageList.Images[GetTypeImageIndex(nodePep)];
}
public static int GetPeakImageIndex(PeptideDocNode nodePep, SequenceTree sequenceTree)
{
var settings = sequenceTree.Document.Settings;
if (!settings.HasResults)
return -1;
int index = sequenceTree.GetDisplayResultsIndex(nodePep);
float? ratio = (nodePep.HasResults ? nodePep.GetPeakCountRatio(index) : null);
if (ratio == null)
return (int)SequenceTree.StateImageId.peak_blank;
if (ratio < 0.5)
return (int)SequenceTree.StateImageId.no_peak;
if (ratio < 1.0)
return (int)SequenceTree.StateImageId.keep;
return (int)SequenceTree.StateImageId.peak;
}
public static Image GetPeakImage(PeptideDocNode nodePep, SequenceTree sequenceTree)
{
int imageIndex = GetPeakImageIndex(nodePep, sequenceTree);
return (imageIndex != -1 ? sequenceTree.StateImageList.Images[imageIndex] : null);
}
public static PeptideTreeNode CreateInstance(SequenceTree tree, DocNode nodeDoc)
{
Debug.Assert(nodeDoc is PeptideDocNode);
var nodeTree = new PeptideTreeNode(tree, (PeptideDocNode)nodeDoc);
if (tree.ExpandPeptides)
nodeTree.Expand();
return nodeTree;
}
public TransitionTreeNode(SequenceTree tree, TransitionDocNode ion)
: base(tree, ion)
{
}
public override string GetPickLabel(DocNode child)
{
return(TransitionTreeNode.DisplayText((TransitionDocNode)child, SequenceTree.GetDisplaySettings(PepNode)));
}
public override Size RenderTip(Graphics g, Size sizeMax, bool draw)
{
var sizeInitial = base.RenderTip(g, sizeMax, draw);
if (ShowAnnotationTipOnly)
{
return(sizeInitial);
}
g.TranslateTransform(0, sizeInitial.Height);
FastaSequence fastaSeq = DocNode.Id as FastaSequence;
var tableDetails = new TableDesc();
using (RenderTools rt = new RenderTools())
{
SizeF sizeX80 = g.MeasureString(X80, rt.FontNormal);
float widthLine = sizeX80.Width;
float heightLine = sizeX80.Height;
float heightMax = sizeMax.Height;
tableDetails.AddDetailRow(Resources.PeptideGroupTreeNode_RenderTip_Name, DocNode.Name, rt);
// If current name isn't the original, show that.
if (DocNode.PeptideGroup.Name != null && !Equals(DocNode.Name, DocNode.PeptideGroup.Name))
{
tableDetails.AddDetailRow(Resources.PeptideGroupTreeNode_RenderTip_Original_Name, DocNode.OriginalName, rt);
}
if (!String.IsNullOrEmpty(DocNode.ProteinMetadata.Accession))
{
tableDetails.AddDetailRow(Resources.PeptideGroupTreeNode_RenderTip_Accession, DocNode.ProteinMetadata.Accession, rt);
}
if (!String.IsNullOrEmpty(DocNode.ProteinMetadata.PreferredName))
{
tableDetails.AddDetailRow(Resources.PeptideGroupTreeNode_RenderTip_Preferred_Name, DocNode.ProteinMetadata.PreferredName, rt);
}
if (!String.IsNullOrEmpty(DocNode.ProteinMetadata.Gene))
{
tableDetails.AddDetailRow(Resources.PeptideGroupTreeNode_RenderTip_Gene, DocNode.ProteinMetadata.Gene, rt);
}
if (!String.IsNullOrEmpty(DocNode.ProteinMetadata.Species))
{
tableDetails.AddDetailRow(Resources.PeptideGroupTreeNode_RenderTip_Species, DocNode.ProteinMetadata.Species, rt);
}
if (!String.IsNullOrEmpty(DocNode.ProteinMetadata.DisplaySearchHistory()))
{
tableDetails.AddDetailRow(Resources.PeptideGroupTreeNode_RenderTip_Searched, DocNode.ProteinMetadata.DisplaySearchHistory(), rt);
}
if (!String.IsNullOrEmpty(DocNode.ProteinMetadata.Description))
{
tableDetails.AddDetailRowLineWrap(g, Resources.PeptideGroupTreeNode_RenderTip_Description, DocNode.ProteinMetadata.Description, rt);
}
if (DocNode.PeptideGroup.Description != null && !Equals(DocNode.Description, DocNode.PeptideGroup.Description))
{
tableDetails.AddDetailRow(Resources.PeptideGroupTreeNode_RenderTip_Original_Description, DocNode.OriginalDescription, rt);
}
SizeF sizeDetails = tableDetails.CalcDimensions(g);
sizeDetails.Height += TableDesc.TABLE_SPACING; // Spacing between details and fragments
float heightTotal = sizeDetails.Height;
widthLine = Math.Max(widthLine, sizeDetails.Width);
if (draw)
{
tableDetails.Draw(g);
}
if (fastaSeq != null)
{
IList <DocNode> peptidesChoices = GetChoices(true).ToArray();
HashSet <DocNode> peptidesChosen = new HashSet <DocNode>(Chosen);
// Make sure all chosen peptides get listed
HashSet <DocNode> setChoices = new HashSet <DocNode>(peptidesChoices);
setChoices.UnionWith(peptidesChosen);
var arrayChoices = setChoices.ToArray();
Array.Sort(arrayChoices, (choice1, choice2) =>
PeptideFromChoice(choice1).Order - PeptideFromChoice(choice2).Order);
peptidesChoices = arrayChoices;
// Get the selected peptide, if there is one
PeptideTreeNode nodePepTree = SequenceTree.GetNodeOfType <PeptideTreeNode>();
Peptide peptideSelected = (nodePepTree != null ? nodePepTree.DocNode.Peptide : null);
int i = 0;
string aa = fastaSeq.Sequence;
const bool peptideList = false;
while (i < aa.Length)
{
// If this is not the last possible line, just render it.
if (heightTotal + heightLine * 2 <= heightMax)
{
i = RenderAALine(aa, peptideList, i, false, draw,
peptidesChoices, peptidesChosen, peptideSelected,
g, rt, heightTotal, widthLine);
heightTotal += heightLine;
}
// If not drawing, then this is the last possible line, and
// it will have content.
else if (!draw)
{
heightTotal += heightLine;
break;
}
// Otherwise, measure first, and then re-render, with an elipsis
// if the full sequence cannot be shown.
else
{
RenderAALine(aa, peptideList, i, false, false,
peptidesChoices, peptidesChosen, peptideSelected,
g, rt, heightTotal, widthLine);
RenderAALine(aa, peptideList, i, i < aa.Length, true,
peptidesChoices, peptidesChosen, peptideSelected,
g, rt, heightTotal, widthLine);
heightTotal += heightLine;
break;
}
}
}
return(TipSize(Math.Max(widthLine, sizeInitial.Width), heightTotal + sizeInitial.Height));
}
}
public static Image GetTypeImage(TransitionDocNode nodeTran, SequenceTree sequenceTree)
{
return sequenceTree.ImageList.Images[GetTypeImageIndex(nodeTran)];
}
// ReSharper disable SuggestBaseTypeForParameter
public PeptideGroupTreeNode(SequenceTree tree, PeptideGroupDocNode group)
// ReSharper restore SuggestBaseTypeForParameter
: base(tree, group)
{
}
public TransitionGroupTreeNode(SequenceTree tree, TransitionGroupDocNode nodeGroup)
: base(tree, nodeGroup)
{
}
public static Image GetPeakImage(TransitionGroupDocNode nodeGroup,
PeptideDocNode nodeParent, SequenceTree sequenceTree)
{
int imageIndex = GetPeakImageIndex(nodeGroup, nodeParent, sequenceTree);
return (imageIndex != -1 ? sequenceTree.StateImageList.Images[imageIndex] : null);
}
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"; // Not L10N
#endregion Fields
#region Constructors
// ReSharper restore SuggestBaseTypeForParameter
// ReSharper disable SuggestBaseTypeForParameter
public PeptideGroupTreeNode(SequenceTree tree, PeptideGroupDocNode group)
: base(tree, group)
{
}
public override string GetPickLabel(DocNode child)
{
return(TransitionGroupTreeNode.DisplayText((TransitionGroupDocNode)child,
SequenceTree.GetDisplaySettings((PeptideDocNode)Model)));
}
protected override void DoTest()
{
RunUI(() => SkylineWindow.OpenFile(TestFilesDir.GetTestPath("CE_Vantage_15mTorr_scheduled_mini_withMod.sky")));
WaitForGraphs();
RunUI(() =>
{
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
// Test single node copy.
sequenceTree.ExpandAll();
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode = sequenceTree.Nodes[0];
SkylineWindow.Copy();
CheckCopiedNodes(0, 1);
// Test multiple selection copy.
sequenceTree.KeysOverride = Keys.Shift;
sequenceTree.SelectedNode = sequenceTree.Nodes[1];
SkylineWindow.Copy();
// Test multiple selection disjoint, reverse order copy.
CheckCopiedNodes(0, 1);
Assert.AreSame(sequenceTree, SkylineWindow.SequenceTree);
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode = sequenceTree.Nodes[1].Nodes[0];
sequenceTree.KeysOverride = Keys.Control;
sequenceTree.SelectedNode = sequenceTree.Nodes[0].Nodes[0];
SkylineWindow.Copy();
// After copying in reverse order, reselect the nodes in sorted order so we don't have to
// sort them in the test code.
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode = sequenceTree.Nodes[0];
sequenceTree.SelectedNode = sequenceTree.Nodes[0].Nodes[0];
sequenceTree.KeysOverride = Keys.Control;
sequenceTree.SelectedNode = sequenceTree.Nodes[1].Nodes[0];
Assert.AreSame(sequenceTree, SkylineWindow.SequenceTree);
CheckCopiedNodes(1, 2);
// Test no space between parent and descendents if immediate child is not selected.
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode = sequenceTree.Nodes[0];
sequenceTree.KeysOverride = Keys.Control;
sequenceTree.SelectedNode = sequenceTree.Nodes[0].Nodes[0].Nodes[0].Nodes[0];
sequenceTree.SelectedNode = sequenceTree.Nodes[0].Nodes[0].Nodes[0].Nodes[2];
SkylineWindow.Copy();
CheckCopiedNodes(0, 1);
// Test paste menu item enabled, copy menu item disabled when dummy node is selected.
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode =
sequenceTree.Nodes[SkylineWindow.SequenceTree.Nodes.Count - 1];
Assert.IsFalse(SkylineWindow.CopyMenuItemEnabled(), "Copy menu should not be enabled");
Assert.IsTrue(SkylineWindow.PasteMenuItemEnabled());
// Test FASTA sequence copy HTML formatting
sequenceTree.SelectedNode = sequenceTree.Nodes[0];
SkylineWindow.Copy();
string clipboardHtml = GetClipboardHtml();
Assert.AreEqual(4, Regex.Matches(clipboardHtml, "<font style=\"font-weight: bold").Count);
Assert.AreEqual(4, Regex.Matches(clipboardHtml, "</font>").Count);
Assert.AreEqual(1, Regex.Matches(clipboardHtml, "color: blue").Count);
sequenceTree.SelectedNode = sequenceTree.Nodes[1];
SkylineWindow.Copy();
clipboardHtml = GetClipboardHtml();
Assert.AreEqual(19, Regex.Matches(clipboardHtml, "<font style=\"font-weight: bold").Count);
Assert.AreEqual(19, Regex.Matches(clipboardHtml, "</font>").Count);
Assert.AreEqual(2, Regex.Matches(clipboardHtml, "color: blue").Count);
sequenceTree.SelectedNode = sequenceTree.Nodes[2];
SkylineWindow.Copy();
clipboardHtml = GetClipboardHtml();
Assert.AreEqual(18, Regex.Matches(clipboardHtml, "<font style=\"font-weight: bold").Count);
Assert.AreEqual(18, Regex.Matches(clipboardHtml, "</font>").Count);
Assert.AreEqual(2, Regex.Matches(clipboardHtml, "color: blue").Count);
// Test clipboard HTML contains formatting for modified peptides.
sequenceTree.SelectedNode = sequenceTree.Nodes[3].Nodes[0];
SkylineWindow.Copy();
clipboardHtml = GetClipboardHtml();
Assert.IsTrue(clipboardHtml.Contains("font") && clipboardHtml.Contains("color"));
});
// Paste a protein list
var document = WaitForProteinMetadataBackgroundLoaderCompletedUI();
RunUI(() =>
{
SetClipboardText(PROTEINLIST_CLIPBOARD_TEXT);
SkylineWindow.Paste();
});
var docPaste = WaitForDocumentChange(document);
Assert.AreEqual(document.PeptideGroupCount + 3, docPaste.PeptideGroupCount);
Assert.AreEqual("P23978", docPaste.PeptideGroups.Last().ProteinMetadata.Accession); // Did builtin IPI conversion work?
// Paste an invalid protein list
RunDlg <MessageDlg>(() =>
{
SetClipboardText(PROTEINLIST_CLIPBOARD_TEXT.Replace("MDAL", "***"));
SkylineWindow.Paste();
},
msgDlg => msgDlg.OkDialog());
Assert.AreSame(docPaste, WaitForProteinMetadataBackgroundLoaderCompletedUI());
// Test border case where protein/peptide/transition list contains a blank line
// Should give generic error, not crash
RunDlg <MessageDlg>(() =>
{
SetClipboardText(PROTEIN_LIST_BAD_FORMAT);
SkylineWindow.Paste();
},
msgDlg =>
{
Assert.AreEqual(msgDlg.Message, Resources.CopyPasteTest_DoTest_Could_not_read_the_pasted_transition_list___Transition_list_must_be_in_separated_columns_and_cannot_contain_blank_lines_);
msgDlg.OkDialog();
});
// Paste peptides
const int precursorCharge = 2;
List <Tuple <string, int> > peptidePaste = new List <Tuple <string, int> >
{
new Tuple <string, int>("FVEGLPINDFSR", 3),
new Tuple <string, int>("FVEGLPINDFSR", 2),
new Tuple <string, int>("FVEGLPINDFSR", 0),
new Tuple <string, int>("DLNELQALIEAHFENR", 0),
new Tuple <string, int>(string.Format("C[+{0:F01}]QPLELAGLGFAELQDLC[+{1:F01}]R", 57.0, 57.0), 3),
new Tuple <string, int>("PEPTIDER", 5),
new Tuple <string, int>("PEPTIDER", 15)
};
var peptidePasteSb = new StringBuilder();
foreach (var pep in peptidePaste)
{
peptidePasteSb.AppendLine(pep.Item1 + Transition.GetChargeIndicator(pep.Item2));
}
RunUI(() =>
{
SkylineWindow.NewDocument(true);
document = SkylineWindow.Document;
document = document.ChangeSettings(document.Settings.ChangeTransitionFilter(f => f.ChangePrecursorCharges(new[] { precursorCharge })));
SetClipboardText(peptidePasteSb.ToString());
SkylineWindow.Paste();
});
document = WaitForDocumentChange(document);
Assert.AreEqual(peptidePaste.Count, document.PeptideTransitionGroupCount);
for (int i = 0; i < document.PeptideTransitionGroupCount; i++)
{
TransitionGroupDocNode transition = document.PeptideTransitionGroups.ElementAt(i);
string seq = transition.TransitionGroup.Peptide.Sequence;
int charge = transition.PrecursorCharge;
Assert.AreEqual(FastaSequence.StripModifications(peptidePaste[i].Item1), seq);
var pastedCharge = peptidePaste[i].Item2;
Assert.AreEqual(pastedCharge != 0 ? pastedCharge : precursorCharge, charge);
}
// Undo paste
RunUI(() => SkylineWindow.Undo());
document = WaitForDocumentChange(document);
// Change precursor charges
int[] precursorCharges = { 2, 3, 4 };
RunUI(() => SkylineWindow.ModifyDocument("Change precursor charges", doc => doc.ChangeSettings((document.Settings.ChangeTransitionFilter(f => f.ChangePrecursorCharges(precursorCharges))))));
document = WaitForDocumentChange(document);
// Re-paste in peptides
RunUI(() => SkylineWindow.Paste());
document = WaitForDocumentChange(document);
int curTransitionGroup = 0;
foreach (var peptide in peptidePaste)
{
if (peptide.Item2 > 0)
{
// Pasted peptides with a charge indicator should have a single precursor with the specified charge state
TransitionGroupDocNode group = document.PeptideTransitionGroups.ElementAt(curTransitionGroup++);
string seq = group.TransitionGroup.Peptide.Sequence;
int charge = group.PrecursorCharge;
Assert.AreEqual(FastaSequence.StripModifications(peptide.Item1), seq);
var pastedCharge = peptide.Item2;
Assert.AreEqual(pastedCharge, charge);
}
else
{
// Pasted peptides with no charge indicator should have a precursor for every charge state in transition filter settings
for (int j = 0; j < precursorCharges.Count(); j++)
{
TransitionGroupDocNode group = document.PeptideTransitionGroups.ElementAt(curTransitionGroup++);
string seq = group.TransitionGroup.Peptide.Sequence;
int charge = group.PrecursorCharge;
Assert.AreEqual(FastaSequence.StripModifications(peptide.Item1), seq);
Assert.AreEqual(precursorCharges[j], charge);
}
}
}
Assert.AreEqual(curTransitionGroup, document.PeptideTransitionGroupCount);
}
protected override void DoTest()
{
// Formerly this little .sky file would not update its (unsearchable) protein metdata on load
RunUI(() => SkylineWindow.OpenFile(TestFilesDir.GetTestPath("Mutant Peptides with Braf AG A00Y - Cut Down.sky")));
var doc = WaitForDocumentLoaded();
var nodeProt = doc.MoleculeGroups.First();
var metadata = nodeProt.ProteinMetadata;
Assert.IsFalse(metadata.NeedsSearch());
RunUI(() => SkylineWindow.OpenFile(TestFilesDir.GetTestPath("ProteinMetadataFunctionalTests.sky")));
doc = WaitForDocumentLoaded();
nodeProt = doc.MoleculeGroups.First();
metadata = nodeProt.ProteinMetadata;
// Examine the various View | Targets | By* modes
foreach (ProteinMetadataManager.ProteinDisplayMode mode in Enum.GetValues(typeof(ProteinMetadataManager.ProteinDisplayMode)))
{
ProteinMetadataManager.ProteinDisplayMode arg = mode;
RunUI(() => SkylineWindow.UpdateTargetsDisplayMode(arg)); // This should alter the text displayed by the node in the sequence tree view
WaitForConditionUI(() =>
{
var displayText = SkylineWindow.SequenceTree.GetSequenceNodes().First().Text;
if (arg != ProteinMetadataManager.ProteinDisplayMode.ByName &&
Equals(displayText, GetDisplayText(ProteinMetadataManager.ProteinDisplayMode.ByName, metadata)))
{
return(false);
}
return(Equals(displayText, GetDisplayText(arg, metadata)));
});
}
// Examine the various Edit | Refine | Sort Proteins | By* modes
Assert.AreEqual("YIL075C", nodeProt.Name); // unsorted
foreach (ProteinMetadataManager.ProteinDisplayMode mode in Enum.GetValues(typeof(ProteinMetadataManager.ProteinDisplayMode)))
{
string expectedTopName = null;
switch (mode)
{
case ProteinMetadataManager.ProteinDisplayMode.ByName:
expectedTopName = "YAL003W";
RunUI(() => SkylineWindow.sortProteinsByNameToolStripMenuItem_Click(null, null));
break;
case ProteinMetadataManager.ProteinDisplayMode.ByAccession:
expectedTopName = TestSmallMolecules ? "ZZZTESTINGNONPROTEOMICMOLECULEGROUP" : "YFL038C";
RunUI(() => SkylineWindow.sortProteinsByAccessionToolStripMenuItem_Click(null, null));
break;
case ProteinMetadataManager.ProteinDisplayMode.ByPreferredName:
RunUI(() => SkylineWindow.sortProteinsByPreferredNameToolStripMenuItem_Click(null, null));
expectedTopName = TestSmallMolecules ? "ZZZTESTINGNONPROTEOMICMOLECULEGROUP" : "YAL016W";
break;
case ProteinMetadataManager.ProteinDisplayMode.ByGene:
RunUI(() => SkylineWindow.sortProteinsByGeneToolStripMenuItem_Click(null, null));
expectedTopName = TestSmallMolecules ? "ZZZTESTINGNONPROTEOMICMOLECULEGROUP" : "YGL234W";
break;
}
var actualTopName = WaitForDocumentLoaded().MoleculeGroups.First().Name.ToUpperInvariant();
Assert.AreEqual(expectedTopName, actualTopName);
}
// Now paste in our fake fasta test data, and handle it with our fake webaccess handler
var protdbLoader = SkylineWindow.BackgroundProteomeManager;
protdbLoader.FastaImporter = new WebEnabledFastaImporter(new CommonTest.FastaImporterTest.PlaybackProvider());
var treeLoader = SkylineWindow.ProteinMetadataManager;
treeLoader.FastaImporter = new WebEnabledFastaImporter(new CommonTest.FastaImporterTest.PlaybackProvider());
const int maxEntries = 5;
var fastaText = CommonTest.FastaImporterTest.GetFastaTestText(maxEntries); // Just get the first few
SetClipboardTextUI(fastaText);
var pasteDlg = ShowDialog <PasteDlg>(SkylineWindow.ShowPasteFastaDlg); // Show the paste dialog
RunDlg <EmptyProteinsDlg>(() => // Anticpate the EmptyProteinsDialog as a side effect
{
pasteDlg.PasteFasta(); // Doing this in pastDlg...
pasteDlg.OkDialog();
},
dlg =>
{
Assert.AreEqual(maxEntries, dlg.EmptyProteins);
dlg.KeepEmptyProteins();
dlg.OkDialog(); // ... will cause EmptyProteinsDlg to pop up, so OK it.
});
// Check that IPI:IPI00197700.1 got an accession number P04638
WaitForCondition(() => SkylineWindow.Document.MoleculeGroups.Any(pg => Equals("IPI:IPI00197700.1", pg.Name)));
doc = WaitForDocumentLoaded();
nodeProt = doc.MoleculeGroups.First(pg => Equals("IPI:IPI00197700.1", pg.Name));
Assert.AreEqual("P04638", nodeProt.ProteinMetadata.Accession);
// Now make our fake fasta into a protdb file, and check statement completion against that
const string basename = "fake.fasta";
var protdbPath = TestFilesDir.GetTestPath(basename + ProteomeDb.EXT_PROTDB);
var fastapath = TestFilesDir.GetTestPath(basename);
using (StreamWriter outfile = new StreamWriter(fastapath))
{
outfile.Write(CommonTest.FastaImporterTest.GetFastaTestText()); // write them all
}
BackgroundProteomeTest.CreateBackgroundProteome(protdbPath, basename, fastapath);
doc = WaitForDocumentChange(doc);
// Test for getting accession info from protdb
RunUI(() =>
{
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
SkylineWindow.SequenceTree.SelectedNode = SkylineWindow.SequenceTree.Nodes[SkylineWindow.SequenceTree.Nodes.Count - 1]; // Select the creation node
sequenceTree.BeginEdit(false);
// ReSharper disable LocalizableElement
sequenceTree.StatementCompletionEditBox.TextBox.Text = "NP_313205";
// ReSharper restore LocalizableElement
sequenceTree.CommitEditBox(false);
});
doc = WaitForDocumentChange(doc);
nodeProt = doc.MoleculeGroups.First(pg => Equals("NP_313205", pg.Name));
Assert.AreEqual("P0A7T9", nodeProt.ProteinMetadata.Accession);
var snapshot = SkylineWindow.Document;
// Test for getting protein from protdb by preferredName
const string uniRef100A5Di11 = "UniRef100_A5DI11";
const string a5Di11 = "A5DI11";
RunUI(() =>
{
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
SkylineWindow.SequenceTree.SelectedNode = SkylineWindow.SequenceTree.Nodes[SkylineWindow.SequenceTree.Nodes.Count - 1]; // Select the creation node
sequenceTree.BeginEdit(false);
// ReSharper disable LocalizableElement
sequenceTree.StatementCompletionEditBox.TextBox.Text = "EF2_PICGU"; // PreferredName for UniRef100_A5DI11
// ReSharper restore LocalizableElement
sequenceTree.CommitEditBox(false);
});
WaitForCondition(() => SkylineWindow.Document.MoleculeGroups.Any(pg => Equals(uniRef100A5Di11, pg.Name)));
doc = WaitForDocumentChange(doc);
nodeProt = doc.MoleculeGroups.First(pg => Equals(uniRef100A5Di11, pg.Name));
Assert.AreEqual(a5Di11, nodeProt.ProteinMetadata.Accession);
// Paste in some junk and make sure we handle the View Targets By* gracefully
const string badname = "badname";
RunUI(() =>
{
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
SkylineWindow.SequenceTree.SelectedNode = SkylineWindow.SequenceTree.Nodes[SkylineWindow.SequenceTree.Nodes.Count - 1]; // Select the creation node
sequenceTree.BeginEdit(false);
sequenceTree.StatementCompletionEditBox.TextBox.Text = badname;
sequenceTree.CommitEditBox(false);
});
doc = WaitForDocumentChange(doc);
var nodeText = SkylineWindow.SequenceTree.GetSequenceNodes().Last(n => !SrmDocument.IsSpecialNonProteomicTestDocNode(n.DocNode)).Text;
var failsafe = String.Format(Resources.PeptideGroupTreeNode_ProteinModalDisplayText__name___0__, badname); // As in PeptideGroupTreeNode.cs
Assert.AreEqual(failsafe, nodeText);
// Revert those changes, so we can insert another way
Assert.IsTrue(SkylineWindow.SetDocument(snapshot, doc));
WaitForCondition(() => !SkylineWindow.Document.MoleculeGroups.Any(pg => Equals(uniRef100A5Di11, pg.Name)));
doc = SkylineWindow.Document;
// Test for pasting accession number in protein paste dialog, and having it populate with correct name
SetClipboardTextUI(a5Di11);
PasteDlg pasteProteinsDlgA = ShowDialog <PasteDlg>(SkylineWindow.ShowPasteProteinsDlg);
RunUI(() =>
{
var selectedNode = SkylineWindow.SequenceTree.Nodes[SkylineWindow.SequenceTree.Nodes.Count - 1];
SkylineWindow.SequenceTree.SelectedNode = selectedNode;
pasteProteinsDlgA.SelectedPath = SkylineWindow.SequenceTree.SelectedPath;
pasteProteinsDlgA.PasteProteins();
});
OkDialog(pasteProteinsDlgA, pasteProteinsDlgA.OkDialog);
WaitForCondition(() => SkylineWindow.Document.MoleculeGroups.Any(pg => Equals(uniRef100A5Di11, pg.Name)));
doc = WaitForDocumentChange(doc);
nodeProt = doc.MoleculeGroups.First(pg => Equals(uniRef100A5Di11, pg.Name));
Assert.AreEqual(a5Di11, nodeProt.ProteinMetadata.Accession);
// See what happens when you paste in a gene name shared by a couple of proteins
const string dupeGene = "Apoa2";
const string ipi00197700 = "IPI:IPI00197700.1";
SetClipboardTextUI(dupeGene);
PasteDlg pasteProteinsDlgB = ShowDialog <PasteDlg>(SkylineWindow.ShowPasteProteinsDlg);
RunUI(() =>
{
var selectedNode = SkylineWindow.SequenceTree.Nodes[SkylineWindow.SequenceTree.Nodes.Count - 1];
SkylineWindow.SequenceTree.SelectedNode = selectedNode;
pasteProteinsDlgB.SelectedPath = SkylineWindow.SequenceTree.SelectedPath;
pasteProteinsDlgB.PasteProteins();
});
OkDialog(pasteProteinsDlgB, pasteProteinsDlgB.OkDialog);
WaitForCondition(() => SkylineWindow.Document.MoleculeGroups.Any(pg => Equals(ipi00197700, pg.Name)));
doc = WaitForDocumentChange(doc);
nodeProt = doc.MoleculeGroups.First(pg => Equals(ipi00197700, pg.Name));
Assert.AreEqual(dupeGene, nodeProt.ProteinMetadata.Gene);
// Test for pasting in protein PasteDlg with sequence and metadata - metadata values are same as DocumentGrid column names
const string pasteProteinName = "Protein";
const string pasteProteinDescription = "Description";
const string pasteProteinAccession = "Accession";
const string pasteProteinPreferredName = "PreferredName";
const string pasteProteinGene = "Gene";
const string pasteProteinSpecies = "Species";
var pasteProteinText = String.Join("\t", pasteProteinName, pasteProteinDescription,
"MFEQFDLDSELLASINK IGYTKPTSIQELVIPQAMV", pasteProteinAccession, pasteProteinPreferredName, // Note the whitespace embedded in the sequence - UI should deal with that
pasteProteinGene, pasteProteinSpecies);
SetClipboardTextUI(pasteProteinText);
PasteDlg pasteProteinsDlg = ShowDialog <PasteDlg>(SkylineWindow.ShowPasteProteinsDlg);
RunUI(() =>
{
var selectedNode = SkylineWindow.SequenceTree.Nodes[SkylineWindow.SequenceTree.Nodes.Count - 1];
SkylineWindow.SequenceTree.SelectedNode = selectedNode;
pasteProteinsDlg.SelectedPath = SkylineWindow.SequenceTree.SelectedPath;
pasteProteinsDlg.PasteProteins();
});
OkDialog(pasteProteinsDlg, pasteProteinsDlg.OkDialog);
WaitForCondition(() => SkylineWindow.Document.MoleculeGroups.Any(pg => Equals(pasteProteinName, pg.Name)));
doc = WaitForDocumentChange(doc);
nodeProt = doc.MoleculeGroups.First(pg => Equals(pasteProteinName, pg.Name));
Assert.AreEqual(pasteProteinAccession, nodeProt.ProteinMetadata.Accession);
// Verify DocumentGrid's use of protein metadata - last line should agree with var pasteProteinText
var documentGrid = ShowDialog <DocumentGridForm>(() => SkylineWindow.ShowDocumentGrid(true));
RunUI(() => documentGrid.ChooseView(Resources.SkylineViewContext_GetDocumentGridRowSources_Proteins));
WaitForCondition(() => (documentGrid.RowCount > 0)); // Let it initialize
foreach (var colName in new[]
{
pasteProteinAccession,
pasteProteinPreferredName,
pasteProteinGene,
pasteProteinSpecies
})
{ // Column content should match column name, for pasteProteinText as input
string value = null;
string name = colName;
RunUI(() =>
{
var col = documentGrid.FindColumn(PropertyPath.Parse(name));
value =
documentGrid.DataGridView.Rows[documentGrid.RowCount - 1].Cells[col.Index].Value.ToString();
});
Assert.AreEqual(colName, value);
}
}
public static void LoadSequences()
{
m_sequences = new SequenceTree();
m_sequence_count = 0;
LoadSequenceFile(Path.Combine(GetDataDir(), "Xorg.txt"));
LoadSequenceFile(Path.Combine(GetDataDir(), "XCompose.txt"));
LoadSequenceFile(Path.Combine(GetDataDir(), "Emoji.txt"));
LoadSequenceFile(Path.Combine(GetDataDir(), "WinCompose.txt"));
LoadSequenceFile(Path.Combine(GetUserDir(), ".XCompose"));
LoadSequenceFile(Path.Combine(GetUserDir(), ".XCompose.txt"));
}
protected override void DoTest()
{
var protdbPath = TestFilesDir.GetTestPath(_backgroundProteomeName + ProteomeDb.EXT_PROTDB);
CreateBackgroundProteome(protdbPath, _backgroundProteomeName, TestFilesDir.GetTestPath("celegans_mini.fasta"));
WaitForProteinMetadataBackgroundLoaderCompleted();
RunUI(() =>
{
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
sequenceTree.BeginEdit(false);
sequenceTree.StatementCompletionEditBox.TextBox.Text = "Y18D10A.20"; // Not L10N
sequenceTree.CommitEditBox(false);
});
WaitForProteinMetadataBackgroundLoaderCompleted();
RunUI(() =>
{
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
sequenceTree.BeginEdit(false);
sequenceTree.StatementCompletionEditBox.TextBox.Text = "AccessionWithout";
});
WaitForOpenForm <StatementCompletionForm>();
Assert.IsNotNull(FindOpenForm <StatementCompletionForm>());
RunUI(() =>
{
var statementCompletionForm = FindOpenForm <StatementCompletionForm>();
Assert.IsNotNull(statementCompletionForm);
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
Assert.IsNotNull(sequenceTree.StatementCompletionEditBox);
sequenceTree.StatementCompletionEditBox.OnSelectionMade(
(StatementCompletionItem)statementCompletionForm.ListView.Items[0].Tag);
});
WaitForProteinMetadataBackgroundLoaderCompleted();
RunUI(() =>
{
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
sequenceTree.BeginEdit(false);
sequenceTree.StatementCompletionEditBox.TextBox.Text = "TISEVIAQGK"; // Not L10N
});
WaitForOpenForm <StatementCompletionForm>();
RunUI(() =>
{
var statementCompletionForm = FindOpenForm <StatementCompletionForm>();
Assert.IsNotNull(statementCompletionForm);
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
Assert.IsNotNull(sequenceTree.StatementCompletionEditBox);
sequenceTree.StatementCompletionEditBox.OnSelectionMade(
(StatementCompletionItem)statementCompletionForm.ListView.Items[0].Tag);
});
var peptideGroups = new List <PeptideGroupDocNode>(Program.ActiveDocument.PeptideGroups);
Assert.AreEqual(3, peptideGroups.Count);
Assert.AreEqual("Y18D10A.20", peptideGroups[0].Name);
Assert.IsTrue(peptideGroups[0].AutoManageChildren);
Assert.AreEqual("AccessionWithoutDescription", peptideGroups[1].Name);
Assert.IsTrue(peptideGroups[1].AutoManageChildren);
Assert.AreEqual("C37A2.7", peptideGroups[2].Name);
Assert.IsFalse(peptideGroups[2].AutoManageChildren);
// Save and re-open with prot db moved to see MissingFileDlg
int pepCount = SkylineWindow.Document.PeptideCount;
string documentPath = TestFilesDir.GetTestPath("BackgroundProtDoc.sky");
RunUI(() =>
{
SkylineWindow.SaveDocument(documentPath);
SkylineWindow.SwitchDocument(new SrmDocument(SrmSettingsList.GetDefault()), null);
});
Assert.AreEqual(0, SkylineWindow.Document.PeptideCount);
// Wait until protein metadata manager is finished before trying to rename the background proteome database.
WaitForCondition(() => !SkylineWindow.BackgroundLoaders.OfType <ProteinMetadataManager>()
.Any(loader => loader.AnyProcessing()));
File.Move(protdbPath, TestFilesDir.GetTestPath(_backgroundProteomeName + "-copy" + ProteomeDb.EXT_PROTDB));
RunDlg <MissingFileDlg>(() => SkylineWindow.OpenFile(documentPath),
dlg => dlg.OkDialog());
Assert.AreEqual(pepCount, SkylineWindow.Document.PeptideCount);
RunUI(() => SkylineWindow.NewDocument());
RunDlg <MissingFileDlg>(() => SkylineWindow.OpenFile(documentPath),
dlg => dlg.CancelDialog());
Assert.AreEqual(0, SkylineWindow.Document.PeptideCount);
}
private void removePeakMenuItem_DropDownOpening(object sender, EventArgs e)
{
SkylineWindow.EditMenu.CanApplyOrRemovePeak(null, null, out _, out var canRemove);
if (!canRemove)
{
return;
}
if (!(sender is ToolStripMenuItem menu) || !menu.DropDownItems.OfType <object>().Any())
{
return;
}
var nodeGroupTree = SequenceTree.GetNodeOfType <TransitionGroupTreeNode>();
if (nodeGroupTree != null)
{
var nodeGroup = nodeGroupTree.DocNode;
var pathGroup = nodeGroupTree.Path;
var nodeTranTree = (TransitionTreeNode)SelectedNode;
var nodeTran = nodeTranTree.DocNode;
menu.DropDownItems.Clear();
if (nodeGroup.TransitionCount > 1)
{
var handler = new RemovePeakHandler(SkylineWindow, pathGroup, nodeGroup, null);
var item = new ToolStripMenuItem(
Resources.SkylineWindow_removePeaksGraphMenuItem_DropDownOpening_All, null,
handler.menuItem_Click);
menu.DropDownItems.Insert(0, item);
}
var chromInfo = nodeTran.GetChromInfo(SequenceTree.ResultsIndex, GetSelectedChromFileId());
if (chromInfo != null && !chromInfo.IsEmpty)
{
var handler = new RemovePeakHandler(SkylineWindow, pathGroup, nodeGroup, nodeTran);
var item = new ToolStripMenuItem(ChromGraphItem.GetTitle(nodeTran), null, handler.menuItem_Click);
menu.DropDownItems.Insert(0, item);
}
return;
}
var nodePepTree = SequenceTree.GetNodeOfType <PeptideTreeNode>();
if (nodePepTree != null)
{
var placeholder = menu.DropDownItems.OfType <object>().FirstOrDefault() as ToolStripMenuItem;
if (placeholder == null)
{
return;
}
var isotopeLabelType = placeholder.Tag as IsotopeLabelType;
if (isotopeLabelType == null)
{
return;
}
menu.DropDownItems.Clear();
var transitionGroupDocNode = nodePepTree.DocNode.TransitionGroups.FirstOrDefault(transitionGroup =>
Equals(transitionGroup.TransitionGroup.LabelType, isotopeLabelType));
if (transitionGroupDocNode == null)
{
return;
}
var item = new ToolStripMenuItem(Resources.SkylineWindow_removePeaksGraphMenuItem_DropDownOpening_All,
null, removePeakMenuItem_Click);
menu.DropDownItems.Insert(0, item);
var handler = new RemovePeakHandler(SkylineWindow,
new IdentityPath(nodePepTree.Path, transitionGroupDocNode.Id), transitionGroupDocNode, null);
item = new ToolStripMenuItem(isotopeLabelType.Title, null, handler.menuItem_Click);
menu.DropDownItems.Insert(0, item);
}
}
