private const string BULLET = "\u2022 "; // Not L10N

        #endregion Fields

        #region Constructors

        public ShareTypeDlg(SrmDocument document)
        {
            InitializeComponent();

            int lineHeight = labelMessage.Height;

            StringBuilder sbLabel = new StringBuilder();
            sbLabel.AppendLine(Resources.ShareTypeDlg_ShareTypeDlg_The_document_can_be_shared_either_in_its_complete_form_or_in_a_minimal_form_intended_for_read_only_use_with);
            var listMinimizations = new List<string>();
            if (document.Settings.HasBackgroundProteome)
                listMinimizations.Add(BULLET + Resources.ShareTypeDlg_ShareTypeDlg_its_background_proteome_disconnected);
            if (document.Settings.HasRTCalcPersisted)
                listMinimizations.Add(BULLET + Resources.ShareTypeDlg_ShareTypeDlg_its_retention_time_calculator_minimized_to_contain_only_standard_peptides_and_library_peptides_used_in_the_document);
            if (document.Settings.HasLibraries)
                listMinimizations.Add(BULLET + Resources.ShareTypeDlg_ShareTypeDlg_all_libraries_minimized_to_contain_only_precursors_used_in_the_document);
            int lastIndex = listMinimizations.Count - 1;
            if (lastIndex < 0)
            {
                throw new InvalidOperationException(
                    string.Format(Resources.ShareTypeDlg_ShareTypeDlg_Invalid_use_of__0__for_document_without_background_proteome_retention_time_calculator_or_libraries,
                        typeof(ShareTypeDlg).Name));
            }
            if (listMinimizations.Count > 0)
                sbLabel.AppendLine().Append(TextUtil.LineSeparate(listMinimizations)).AppendLine();

            sbLabel.AppendLine().Append(Resources.ShareTypeDlg_ShareTypeDlg_Choose_the_appropriate_sharing_option_below);
            labelMessage.Text = sbLabel.ToString();
            Height += Math.Max(0, labelMessage.Height - lineHeight * 3);
        }

        public RefineDlg(SrmDocument document)
        {
            _document = document;
            _settings = document.Settings;

            InitializeComponent();

            Icon = Resources.Skyline;

            // Fill label type combo box
            comboRefineLabelType.Items.Add(string.Empty);
            comboRefineLabelType.Items.Add(IsotopeLabelType.LIGHT_NAME);
            foreach (var typedMods in _settings.PeptideSettings.Modifications.GetHeavyModifications())
                comboRefineLabelType.Items.Add(typedMods.LabelType.Name);
            comboRefineLabelType.SelectedIndex = 0;
            comboReplicateUse.SelectedIndex = 0;

            var settings = document.Settings;
            if (!settings.HasResults)
            {
                tabControl1.TabPages.Remove(tabResults);
            }

            if (settings.PeptideSettings.Libraries.HasLibraries)
            {
                labelMinDotProduct.Enabled = textMinDotProduct.Enabled = groupLibCorr.Enabled = true;
            }
            if (settings.TransitionSettings.FullScan.IsHighResPrecursor)
            {
                labelMinIdotProduct.Enabled = textMinIdotProduct.Enabled = groupLibCorr.Enabled = true;
            }
        }

 protected override GraphData CreateGraphData(SrmDocument document, PeptideGroupDocNode selectedProtein, TransitionGroupDocNode selectedGroup, DisplayTypeChrom displayType)
 {
     int? result = null;
     if (RTLinearRegressionGraphPane.ShowReplicate == ReplicateDisplay.single)
         result = GraphSummary.ResultsIndex;
     return new AreaGraphData(document, selectedGroup, selectedProtein, result, displayType, PaneKey);
 }

 public static void CheckAll(SrmDocument document)
 {
     using (var checkReportCompatibility = new CheckReportCompatibility(document))
     {
         checkReportCompatibility.CheckAll();
     }
 }

        protected override bool LoadBackground(IDocumentContainer container, SrmDocument document, SrmDocument docCurrent)
        {
            var lib = GetOptimizationLibrary(docCurrent);
            if (lib != null && !lib.IsNone && !lib.IsUsable)
                lib = LoadLibrary(container, lib);
            if (lib == null || !ReferenceEquals(document.Id, container.Document.Id))
            {
                // Loading was cancelled or document changed
                EndProcessing(document);
                return false;
            }

            SrmDocument docNew;
            do
            {
                // Change the document to use the new library
                docCurrent = container.Document;
                if (!ReferenceEquals(GetOptimizationLibrary(docCurrent), GetOptimizationLibrary(container.Document)))
                    return false;
                docNew = docCurrent.ChangeSettings(docCurrent.Settings.ChangeTransitionPrediction(predict =>
                    predict.ChangeOptimizationLibrary(lib)));
            }
            while (!CompleteProcessing(container, docNew, docCurrent));
            return true;
        }

 public RemoteChromDataProvider(SrmDocument document, IRetentionTimePredictor retentionTimePredictor, ChromFileInfo chromFileInfo, ProgressStatus progressStatus, int startPercent,
     int endPercent, ILoadMonitor loader)
     : base(chromFileInfo, progressStatus, startPercent, endPercent, loader)
 {
     _document = document;
     ChorusUrl chorusUrl = (ChorusUrl)chromFileInfo.FilePath;
     _chorusAccount = chorusUrl.FindChorusAccount(Settings.Default.ChorusAccountList);
     var chromatogramRequestProviders = new List<ChromatogramRequestProvider>();
     foreach (bool firstPass in new[] {true, false})
     {
         if (null == retentionTimePredictor && !firstPass)
         {
             continue;
         }
         var chromatogramRequestProvider = new ChromatogramRequestProvider(document, chorusUrl,
             retentionTimePredictor, firstPass);
         if (0 == chromatogramRequestProvider.ChromKeys.Count)
         {
             continue;
         }
         chromatogramRequestProviders.Add(chromatogramRequestProvider);
     }
     _chromatogramRequestProviders = chromatogramRequestProviders.ToArray();
     _chromTaskLists = new ChromTaskList[_chromatogramRequestProviders.Length];
 }

        public static SrmDocument ApplyPeak(SrmDocument doc, PeptideTreeNode nodePepTree, TransitionGroupDocNode nodeTranGroup,
            int resultsIndex, int? resultsFile, bool subsequent, ILongWaitBroker longWaitBroker)
        {
            nodeTranGroup = nodeTranGroup ?? PickTransitionGroup(doc, nodePepTree, resultsIndex);

            PeakMatchData referenceTarget;
            PeakMatchData[] referenceMatchData;
            DateTime? runTime;
            GetReferenceData(doc, nodePepTree.DocNode, nodeTranGroup, resultsIndex, resultsFile, out referenceTarget, out referenceMatchData, out runTime);

            var chromatograms = doc.Settings.MeasuredResults.Chromatograms;
            for (int i = 0; i < chromatograms.Count; i++)
            {
                var chromSet = chromatograms[i];
                for (int j = 0; j < chromSet.MSDataFileInfos.Count; j++)
                {
                    var fileInfo = chromSet.MSDataFileInfos[j];
                    if ((i == resultsIndex && (!resultsFile.HasValue || resultsFile.Value == j)) ||
                        (subsequent && runTime != null && fileInfo.RunStartTime < runTime))
                    {
                        continue;
                    }

                    var bestMatch = GetPeakMatch(doc, chromSet, fileInfo, nodeTranGroup, referenceTarget, referenceMatchData);
                    if (bestMatch != null)
                        doc = bestMatch.ChangePeak(doc, nodePepTree, nodeTranGroup, chromSet.Name, fileInfo.FilePath);
                }
                longWaitBroker.SetProgressCheckCancel(i + 1, chromatograms.Count);
            }
            return doc;
        }

 public SrmDocumentSharing(SrmDocument document, string documentPath, string sharedPath, bool completeSharing)
 {
     Document = document;
     DocumentPath = documentPath;
     SharedPath = sharedPath;
     CompleteSharing = completeSharing;
 }

 public CheckReportCompatibility(SrmDocument document)
 {
     IDocumentContainer documentContainer = new MemoryDocumentContainer();
     Assert.IsTrue(documentContainer.SetDocument(document, null));
     _database = new Database(document.Settings);
     _database.AddSrmDocument(document);
     _dataSchema = new SkylineDataSchema(documentContainer, DataSchemaLocalizer.INVARIANT);
 }

        protected override GraphData CreateGraphData(SrmDocument document, PeptideGroupDocNode selectedProtein, TransitionGroupDocNode selectedGroup, DisplayTypeChrom displayType)
        {
            int? result = null;
            if (RTLinearRegressionGraphPane.ShowReplicate == ReplicateDisplay.single)
                result = GraphSummary.ResultsIndex;

            return new RTGraphData(document, selectedGroup, selectedProtein, result, displayType, GraphSummary.StateProvider.GetRetentionTimeTransformOperation());
        }

 public PeakBoundaryImporter(SrmDocument document)
 {
     Document = document;
     AnnotationsAdded = new List<string>();
     UnrecognizedFiles = new HashSet<string>();
     UnrecognizedPeptides = new HashSet<string>();
     UnrecognizedChargeStates = new HashSet<UnrecognizedChargeState>();
 }

 /// <summary>
 /// Finds drift times by examining loaded results in a document.
 /// </summary>
 /// <param name="document">The document to be inspected</param>
 /// <param name="documentFilePath">Aids in locating the raw files</param>
 /// <param name="existing">If non-null, will be examined for any existing drift time measurements (which may be overwritten) </param>
 /// <param name="progressMonitor">Optional progress monitor for this potentially long operation</param>
 public DriftTimeFinder(SrmDocument document, string documentFilePath, DriftTimePredictor existing, IProgressMonitor progressMonitor)
 {
     _document = document;
     _documentFilePath = documentFilePath;
     _existing = existing;
     _currentDisplayedTransitionGroupDocNode = null;
     _progressMonitor = progressMonitor;
 }

 public ChromatogramExporter(SrmDocument document)
 {
     Document = document;
     _settings = Document.Settings;
     _measuredResults = _settings.MeasuredResults;
     _matchTolerance = (float)_settings.TransitionSettings.Instrument.MzMatchTolerance;
     _chromatogramSets = _measuredResults.Chromatograms;
 }

 public static string IsNotLoadedDocumentExplained(SrmDocument document)
 {
     // Not loaded if the predictor is not usable
     var calc = GetIonMobilityLibrary(document);
     if (calc == null || calc.IsNone || calc.IsUsable)
         return null;
     return "IonMobilityLibraryManager : GetIonMobilityLibrary(document) not usable and not none"; // Not L10N
 }

 public ChromCacheMinimizer(SrmDocument document, ChromatogramCache chromatogramCache)
 {
     Document = document;
     ChromatogramCache = chromatogramCache;
     var chromGroupHeaderInfos = chromatogramCache.ChromGroupHeaderInfos.ToArray();
     Array.Sort(chromGroupHeaderInfos, CompareLocation);
     ChromGroupHeaderInfos = Array.AsReadOnly(chromGroupHeaderInfos);
     _tolerance = (float) Document.Settings.TransitionSettings.Instrument.MzMatchTolerance;
 }

 public AreaGraphData(SrmDocument document,
     TransitionGroupDocNode selectedGroup,
     PeptideGroupDocNode selectedProtein,
     int? result,
     DisplayTypeChrom displayType,
     PaneKey paneKey)
     : base(document, selectedGroup, selectedProtein, result, displayType, null, paneKey)
 {
 }

 public static string IsNotLoadedDocumentExplained(SrmDocument document)
 {
     // Not loaded if the library is not usable
     var lib = GetOptimizationLibrary(document);
     if (lib == null || lib.IsUsable || lib.IsNone)
     {
         return null;
     }
     return "OptimizationDbManager: GetOptimizationLibrary(document) not usable and not none"; // Not L10N
 }

 public ChromatogramRequestProvider(SrmDocument srmDocument, ChorusUrl chorusUrl, IRetentionTimePredictor retentionTimePredictor, bool firstPass)
 {
     _srmDocument = srmDocument;
     _chorusUrl = chorusUrl;
     _retentionTimePredictor = retentionTimePredictor;
     _firstPass = firstPass;
     // Create a SpectrumFilter without an IRetentionTimeProvider in order to get the list of ChromKeys that we will eventually provide.
     SpectrumFilter spectrumFilter = new SpectrumFilter(_srmDocument, _chorusUrl, null);
     _chromKeys = ImmutableList.ValueOf(ListChromKeys(GetChromatogramRequestDocument(spectrumFilter)));
 }

 public ReplicateSummaries(SrmDocument document)
 {
     Document = document;
     int replicateCount = 0;
     if (Document.Settings.HasResults)
     {
         replicateCount = Document.Settings.MeasuredResults.Chromatograms.Count;
     }
     _allTotalAreas = new ImmutableSortedList<IsotopeLabelType, double>[replicateCount];
 }

 public ExportChromatogramDlg(SrmDocument document, string documentPath)
 {
     InitializeComponent();
     Icon = Resources.Skyline;
     Document = document;
     DocumentFilePath = documentPath;
     MakeCheckedList();
     _chromExtractors = new List<ChromExtractor>();
     _chromSources = new List<ChromSource>();
 }