示例#1
0
        public static PeptideFormatter MakePeptideFormatter(SrmSettings srmSettings, Peptide peptide,
                                                            ExplicitMods explicitMods, ICollection <IsotopeLabelType> heavyLabelTypes,
                                                            ModFontHolder modFontHolder)
        {
            var lightModifiedSequence =
                ModifiedSequence.GetModifiedSequence(srmSettings, peptide.Sequence, explicitMods, IsotopeLabelType.light);
            var heavyModifiedSequences = new List <KeyValuePair <IsotopeLabelType, ModifiedSequence> >();

            foreach (var labelType in srmSettings.PeptideSettings.Modifications.GetHeavyModificationTypes())
            {
                if (!heavyLabelTypes.Contains(labelType))
                {
                    continue;
                }

                heavyModifiedSequences.Add(new KeyValuePair <IsotopeLabelType, ModifiedSequence>(labelType,
                                                                                                 ModifiedSequence.GetModifiedSequence(srmSettings, peptide.Sequence, explicitMods, labelType)));
            }

            var peptideFormatter = new PeptideFormatter(srmSettings, lightModifiedSequence, heavyModifiedSequences, modFontHolder);

            if (explicitMods != null && explicitMods.HasCrosslinks)
            {
                var linkedPeptides = new List <KeyValuePair <ModificationSite, PeptideFormatter> >();
                foreach (var entry in explicitMods.Crosslinks)
                {
                    if (entry.Value.Peptide == null)
                    {
                        continue;
                    }

                    var childFormatter = MakePeptideFormatter(srmSettings, entry.Value.Peptide,
                                                              entry.Value.ExplicitMods, heavyLabelTypes, modFontHolder)
                                         .ChangeCrosslinkedIndexAa(entry.Value.IndexAa);
                    linkedPeptides.Add(new KeyValuePair <ModificationSite, PeptideFormatter>(entry.Key, childFormatter));
                }

                peptideFormatter = peptideFormatter
                                   .ChangeLinkedPeptides(ImmutableSortedList.FromValues(linkedPeptides));
            }

            return(peptideFormatter);
        }
示例#2
0
        public static TextSequence[] CreateTextSequences(PeptideDocNode nodePep,
                                                         SrmSettings settings, string label, IDeviceContext g, ModFontHolder fonts)
        {
            // Store text and font information for all label types
            bool heavyMods         = false;
            var  listTypeSequences = new List <TextSequence> {
                CreateTypeTextSequence(nodePep, settings, IsotopeLabelType.light, fonts)
            };

            foreach (var labelType in settings.PeptideSettings.Modifications.GetHeavyModificationTypes())
            {
                // Only color for the label types actually measured in this peptide
                if (!nodePep.HasChildType(labelType))
                {
                    continue;
                }

                var textSequence = CreateTypeTextSequence(nodePep, settings, labelType, fonts);
                listTypeSequences.Add(textSequence);
                heavyMods = (heavyMods || textSequence != null);
            }

            // Calculate text sequence values for the peptide display string
            var listTextSequences = new List <TextSequence>();

            if (nodePep.Peptide.IsCustomMolecule)
            {
                listTextSequences.Add(CreatePlainTextSequence(label, fonts));
            }
            // If no modifications, use a single plain text sequence
            else if (!heavyMods && !listTypeSequences[0].Text.Contains(@"[")) // For identifying modifications
            {
                listTextSequences.Add(CreatePlainTextSequence(label, fonts));
            }
            else
            {
                var peptideFormatter = PeptideFormatter.MakePeptideFormatter(settings, nodePep, fonts);
                peptideFormatter.DisplayModificationOption = DisplayModificationOption.Current;
                peptideFormatter.DeviceContext             = g;
                string pepSequence = peptideFormatter.UnmodifiedSequence;
                int    startPep    = label.IndexOf(pepSequence, StringComparison.Ordinal);
                int    endPep      = startPep + pepSequence.Length;


                IEnumerable <TextSequence> rawTextSequences = new TextSequence[0];
                // Add prefix plain-text if necessary
                if (startPep > 0)
                {
                    string prefix = label.Substring(0, startPep);
                    rawTextSequences = rawTextSequences.Append(CreatePlainTextSequence(prefix, fonts));
                }

                rawTextSequences = rawTextSequences.Concat(Enumerable.Range(0, pepSequence.Length).Select(aaIndex => peptideFormatter.GetTextSequenceAtAaIndex(aaIndex)));
                if (endPep < label.Length)
                {
                    string suffix = label.Substring(endPep);
                    rawTextSequences = rawTextSequences.Append(CreatePlainTextSequence(suffix, fonts));
                }

                listTextSequences.AddRange(TextSequence.Coalesce(rawTextSequences));
            }

            if (g != null)
            {
                // Calculate placement for each text sequence
                int textRectWidth = 0;
                foreach (var textSequence in listTextSequences)
                {
                    Size sizeMax = new Size(int.MaxValue, int.MaxValue);
                    textSequence.Position = textRectWidth;
                    textSequence.Width    = TextRenderer.MeasureText(g, textSequence.Text,
                                                                     textSequence.Font, sizeMax, FORMAT_TEXT_SEQUENCE).
                                            Width;
                    textRectWidth += textSequence.Width;
                }
            }

            return(listTextSequences.ToArray());
        }