Changeset 3872


Ignore:
Timestamp:
Sep 29, 2010, 11:17:38 AM (13 years ago)
Author:
Gregory Vincic
Message:

Refs #698. Removed method getXtandemParameterSetForm from FormFactory and placed it within the one action that uses it.

Location:
trunk/client/servlet/src/org/proteios
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/client/servlet/src/org/proteios/action/xTandemInput/ViewActiveXTandemParameterSetStorage.java

    r3825 r3872  
    4747import se.lu.thep.waf.constraints.InvalidParameterValue;
    4848import se.lu.thep.waf.constraints.VInteger;
     49import se.lu.thep.waf.constraints.VString;
    4950
    5051/**
    … …  
    120121    // XTandem parameter set form
    121122    //Form xTandemParameterSetForm = getFormFactory().getXTandemParameterSetForm(xTandemParameterSet);
    122     Form xTandemParameterSetForm = getFormFactory().getXTandemParameterSetForm(xTandemParameterSet,
     123    Form xTandemParameterSetForm = getXTandemParameterSetForm(xTandemParameterSet,
    123124      listPathDefaultParametersOptionList,
    124125      speciesOptionList,
    … …  
    246247    return optionList;
    247248  }
     249
     250  public Form getXTandemParameterSetForm(
     251      XTandemParameterSet xTandemParameterSet,
     252      List<Option> listPathDefaultParametersOptionList,
     253      List<Option> speciesOptionList, List<Option> proSpeciesOptionList,
     254      List<Option> residueModificationMassOptionList,
     255      List<Option> residuePotentialModificationMassOptionList,
     256      List<Option> proteinCleavageSiteOptionList,
     257      List<Option> refinePotentialModificationMassOptionList)
     258  {
     259    // DbControl dc = project.getDbControl();
     260    Form form = new Form("XTandemParameterSetForm");
     261    /*
     262     * String select box variables
     263     */
     264    VString validStringParam = null;
     265    List<String> stringList = null;
     266    List<Option> optionList = null;
     267    String selected = null;
     268    List<String> selectedList = null;
     269    /*
     270     * List path field set
     271     */
     272    Fieldset listPathFS = new Fieldset();
     273    listPathFS.setTitle("XTandemParameterSetListPath");
     274    form.addFieldset(listPathFS);
     275    // List path, default parameters
     276    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_LIST_PATH_DEFAULT_PARAMETERS;
     277    optionList = new ArrayList<Option>();
     278    optionList.add(new Option("/tandem/methods/fticr.xml", "FTICR (10 ppm)"));
     279    optionList.add(new Option("/tandem/methods/qstar.xml",  "Quad-TOF (100 ppm)"));
     280    optionList.add(new Option("/tandem/methods/qstar_l.xml",  "Quad-TOF (0.5 Da)"));
     281    optionList.add(new Option("/tandem/methods/iontrap.xml",  "Ion Trap (4 Da)"));
     282    // Use input list path default parameters option list if present
     283    if (listPathDefaultParametersOptionList != null && listPathDefaultParametersOptionList.size() > 0)
     284    {
     285      optionList = listPathDefaultParametersOptionList;
     286    }
     287    selected = xTandemParameterSet.getListPathDefaultParameters();
     288    Select<VString> listPathDefaultParametersSelectBox = new Select<VString>(validStringParam, optionList);
     289  listPathDefaultParametersSelectBox.selectOption( selected);
     290    listPathDefaultParametersSelectBox.setLabel("XTandemListPathDefaultParameters");
     291    listPathDefaultParametersSelectBox.setMultiple(false);
     292    int selectBoxSize = 4;
     293    if (optionList.size() < selectBoxSize)
     294    {
     295      selectBoxSize = optionList.size();
     296    }
     297    listPathDefaultParametersSelectBox.setSize(selectBoxSize);
     298    listPathFS.add(listPathDefaultParametersSelectBox);
     299    // List path, taxonomy information
     300    TextField<String> taxonomyInformationListPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_LIST_PATH_TAXONOMY_INFORMATION);
     301    taxonomyInformationListPath.setValue(xTandemParameterSet
     302      .getListPathTaxonomyInformation());
     303    listPathFS.add(taxonomyInformationListPath);
     304    /*
     305     * Spectrum field set
     306     */
     307    Fieldset spectrumFS = new Fieldset();
     308    spectrumFS.setTitle("XTandemParameterSetSpectrum");
     309    form.addFieldset(spectrumFS);
     310    // Spectrum, path
     311    TextField<String> spectrumPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PATH);
     312    spectrumPath.setValue(xTandemParameterSet.getSpectrumPath());
     313    spectrumFS.add(spectrumPath);
     314    // Spectrum, fragment monoisotopic mass error
     315    TextField<String> fragMiMassError = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MI_MASS_ERROR);
     316    fragMiMassError.setValue(xTandemParameterSet
     317      .getSpectrumFragmentMonoisotopicMassError());
     318    spectrumFS.add(fragMiMassError);
     319    // Spectrum, parent monoisotopic mass error plus
     320    TextField<String> parentMiMassErrorPlus = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_PLUS);
     321    parentMiMassErrorPlus.setValue(xTandemParameterSet
     322      .getSpectrumParentMonoisotopicMassErrorPlus());
     323    spectrumFS.add(parentMiMassErrorPlus);
     324    // Spectrum, parent monoisotopic mass error minus
     325    TextField<String> parentMiMassErrorMinus = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_MINUS);
     326    parentMiMassErrorMinus.setValue(xTandemParameterSet
     327      .getSpectrumParentMonoisotopicMassErrorMinus());
     328    spectrumFS.add(parentMiMassErrorMinus);
     329    // Spectrum, parent monoisotopic mass isotope error
     330    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ISOTOPE_ERROR;
     331    stringList = new ArrayList<String>();
     332    stringList.add("yes");
     333    stringList.add("no");
     334    selected = xTandemParameterSet
     335      .getSpectrumParentMonoisotopicMassIsotopeError();
     336    Select<VString> parentMiMassIsotopeError = new Select<VString>(validStringParam, stringList, selected);
     337    spectrumFS.add(parentMiMassIsotopeError);
     338    // Spectrum, fragment monoisotopic mass error units
     339    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MI_MASS_ERROR_UNITS;
     340    stringList = new ArrayList<String>();
     341    stringList.add("Daltons");
     342    stringList.add("ppm");
     343    selected = xTandemParameterSet
     344      .getSpectrumFragmentMonoisotopicMassErrorUnits();
     345    Select<VString> fragMiMassErrorUnits = new Select<VString>(validStringParam, stringList, selected);
     346    spectrumFS.add(fragMiMassErrorUnits);
     347    // Spectrum, parent monoisotopic mass error units
     348    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_UNITS;
     349    stringList = new ArrayList<String>();
     350    stringList.add("Daltons");
     351    stringList.add("ppm");
     352    selected = xTandemParameterSet
     353      .getSpectrumParentMonoisotopicMassErrorUnits();
     354    Select<VString> parentMiMassErrorUnits = new Select<VString>(validStringParam, stringList, selected);
     355    spectrumFS.add(parentMiMassErrorUnits);
     356    // Spectrum, fragment mass type
     357    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MASS_TYPE;
     358    stringList = new ArrayList<String>();
     359    stringList.add("monoisotopic");
     360    stringList.add("average");
     361    selected = xTandemParameterSet.getSpectrumFragmentMassType();
     362    Select<VString> fragMassType = new Select<VString>(validStringParam,  stringList, selected);
     363    spectrumFS.add(fragMassType);
     364    // Spectrum, dynamic range
     365    TextField<String> dynamicRange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_DYNAMIC_RANGE);
     366    dynamicRange.setValue(xTandemParameterSet.getSpectrumDynamicRange());
     367    spectrumFS.add(dynamicRange);
     368    // Spectrum, total peaks
     369    TextField<String> totalPeaks = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_TOTAL_PEAKS);
     370    totalPeaks.setValue(xTandemParameterSet.getSpectrumTotalPeaks());
     371    spectrumFS.add(totalPeaks);
     372    // Spectrum, maximum parent charge
     373    TextField<String> maxParentCharge = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MAX_PARENT_CHARGE);
     374    maxParentCharge.setValue(xTandemParameterSet
     375      .getSpectrumMaximumParentCharge());
     376    spectrumFS.add(maxParentCharge);
     377    // Spectrum, use noise suppression
     378    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_USE_NOISE_SUPPRESSION;
     379    stringList = new ArrayList<String>();
     380    stringList.add("yes");
     381    stringList.add("no");
     382    selected = xTandemParameterSet.getSpectrumUseNoiseSuppression();
     383    Select<VString> useNoiseSuppression = new Select<VString>(validStringParam, stringList, selected);
     384    spectrumFS.add(useNoiseSuppression);
     385    // Spectrum, minimum parent m+h
     386    TextField<String> minParentMPlusH = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_PARENT_M_PLUS_H);
     387    minParentMPlusH.setValue(xTandemParameterSet
     388      .getSpectrumMinimumParentMPlusH());
     389    spectrumFS.add(minParentMPlusH);
     390    // Spectrum, maximum parent m+h
     391    TextField<String> maxParentMPlusH = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MAX_PARENT_M_PLUS_H);
     392    maxParentMPlusH.setValue(xTandemParameterSet
     393      .getSpectrumMaximumParentMPlusH());
     394    spectrumFS.add(maxParentMPlusH);
     395    // Spectrum, minimum fragment mz
     396    TextField<String> minFragmentMz = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_FRAG_MZ);
     397    minFragmentMz.setValue(xTandemParameterSet
     398      .getSpectrumMinimumFragmentMz());
     399    spectrumFS.add(minFragmentMz);
     400    // Spectrum, minimum peaks
     401    TextField<String> minPeaks = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_PEAKS);
     402    minPeaks.setValue(xTandemParameterSet.getSpectrumMinimumPeaks());
     403    spectrumFS.add(minPeaks);
     404    // Spectrum, threads
     405    TextField<String> threads = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_THREADS);
     406    threads.setValue(xTandemParameterSet.getSpectrumThreads());
     407    spectrumFS.add(threads);
     408    // Spectrum, sequence batch size
     409    TextField<String> spectrumSequenceBatchSize = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_SEQUENCE_BATCH_SIZE);
     410    spectrumSequenceBatchSize.setValue(xTandemParameterSet
     411      .getSpectrumSequenceBatchSize());
     412    spectrumFS.add(spectrumSequenceBatchSize);
     413    /*
     414     * Residue field set
     415     */
     416    Fieldset residueFS = new Fieldset();
     417    residueFS.setTitle("XTandemParameterSetResidue");
     418    form.addFieldset(residueFS);
     419    // Residue, modification mass select
     420    /*
     421     * Residue modification mass selection has one peculiarity: 1. The GUI
     422     * selection is divided into one selection box and an entry field. A
     423     * selection in the selection box will only be used if the entry field
     424     * is empty.
     425     */
     426    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_MODIFICATION_MASS_SELECT;
     427    optionList = new ArrayList<Option>();
     428    optionList.add(new Option("", "none"));
     429    optionList.add(new Option("57.021464@C", "Carbamidomethyl (C)"));
     430    optionList.add(new Option("442.224991@C", "ICAT-D (C)"));
     431    optionList.add(new Option("227.126991@C", "ICAT-C (C)"));
     432    optionList.add(new Option("58.005479@C", "Carboxymethyl (C)"));
     433    optionList.add(new Option("105.057849@C", "Pyridylethyl (C)"));
     434    optionList.add(new Option("71.037114@C", "Propionamide (C)"));
     435    optionList.add(new Option("144.102063@[,144.102063@K",
     436      "iTRAQ (N-term,K)"));
     437    // Use input residue modification mass option list if present
     438    if (residueModificationMassOptionList != null && residueModificationMassOptionList
     439      .size() > 0)
     440    {
     441      optionList = residueModificationMassOptionList;
     442    }
     443    selected = xTandemParameterSet.getResidueModificationMass();
     444    Select<VString> residueModificationMassSelectBox = new Select<VString>(
     445      validStringParam, optionList);
     446  residueModificationMassSelectBox.selectOption( selected);
     447    residueModificationMassSelectBox
     448      .setLabel("XTandemResidueModificationMassSelect");
     449    residueFS.add(residueModificationMassSelectBox);
     450    // Residue, modification mass (own entered value)
     451    TextField<String> modificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_MODIFICATION_MASS);
     452    modificationMass.setLabel("XTandemResidueModificationMassEnter");
     453    // Only insert selected value if not found in select box
     454    if (!itemInOptionList(optionList, selected))
     455    {
     456      log
     457        .debug("residue modification mass, inserted value = \"" + xTandemParameterSet
     458          .getResidueModificationMass() + "\"");
     459      modificationMass.setValue(xTandemParameterSet
     460        .getResidueModificationMass());
     461    }
     462    else
     463    {
     464
     465      modificationMass.setValue("");
     466    }
     467    log
     468      .debug("residue modification mass, modificationMass.getValue() = \"" + modificationMass
     469        .getValue() + "\"");
     470    residueFS.add(modificationMass);
     471    // Residue, potential modification mass select
     472    /*
     473     * Residue potential modification mass selection has two peculiarities:
     474     * 1. It supports selection of multiple items. 2. The GUI selection is
     475     * divided into one multiple selection box and an entry field.
     476     * Selections in the selection box will only be used if the entry field
     477     * is empty. The multiple selection items are stored in XML as a string
     478     * with items separated by ", ".
     479     */
     480    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MASS_SELECT;
     481    optionList = new ArrayList<Option>();
     482    optionList.add(new Option("", "none"));
     483    optionList.add(new Option("15.994915@M", "Oxidation (M)"));
     484    optionList.add(new Option("15.994915@W", "Oxidation (W)"));
     485    optionList.add(new Option("0.984016@N", "Deamidation (N)"));
     486    optionList.add(new Option("0.984016@Q", "Deamidation (Q)"));
     487    optionList.add(new Option("8.0502@C", "ICAT-D:2H(8) (C)"));
     488    optionList.add(new Option("9.0302@C", "ICAT-C:13C(9) (C)"));
     489    optionList.add(new Option("144.102063@[", "iTRAQ (N-term)"));
     490    optionList.add(new Option("144.102063@K", "iTRAQ (K)"));
     491    optionList.add(new Option("79.966331@S", "Phospho (S)"));
     492    optionList.add(new Option("79.966331@T", "Phospho (T)"));
     493    optionList.add(new Option("79.966331@Y", "Phospho (Y)"));
     494    optionList.add(new Option("79.956815@Y", "Sulfo (Y)"));
     495    optionList.add(new Option("42.010565@K", "Acetyl (K)"));
     496    // Use input residue potential modification mass option list if present
     497    if (residuePotentialModificationMassOptionList != null && residuePotentialModificationMassOptionList
     498      .size() > 0)
     499    {
     500      optionList = residuePotentialModificationMassOptionList;
     501      log
     502        .debug("Input residue potential modification mass option list used");
     503    }
     504    else
     505    {
     506      log
     507        .debug("Default residue potential modification mass option list used");
     508    }
     509    selected = xTandemParameterSet.getResiduePotentialModificationMass();
     510    log
     511      .debug("residue potential modification mass selected = \"" + selected + "\"");
     512    selectedList = listStringToStringList(selected, ",");
     513    log
     514      .debug("residue potential modification mass selectedList = " + selectedList);
     515    Select<VString> residuePotentialModificationMassSelectBox = new Select<VString>(
     516      validStringParam, optionList, selectedList);
     517    residuePotentialModificationMassSelectBox
     518      .setLabel("XTandemResiduePotentialModificationMassSelect");
     519    residuePotentialModificationMassSelectBox.setMultiple(true);
     520    residuePotentialModificationMassSelectBox.setSize(4);
     521    residueFS.add(residuePotentialModificationMassSelectBox);
     522    // Residue, potential modification mass
     523    TextField<String> potentialModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MASS);
     524    potentialModificationMass
     525      .setLabel("XTandemResiduePotentialModificationMassEnter");
     526    potentialModificationMass.setValue(xTandemParameterSet
     527      .getResiduePotentialModificationMass());
     528    // Only insert selected values if not all found in select box
     529    if (!allItemsInOptionList(optionList, selectedList))
     530    {
     531      log
     532        .debug("residue potential modification mass, inserted value = \"" + xTandemParameterSet
     533          .getResiduePotentialModificationMass() + "\"");
     534      potentialModificationMass.setValue(xTandemParameterSet
     535        .getResiduePotentialModificationMass());
     536    }
     537    else
     538    {
     539      potentialModificationMass.setValue("");
     540    }
     541    residueFS.add(potentialModificationMass);
     542    // Residue, potential modification motif
     543    TextField<String> potentialModificationMotif = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MOTIF);
     544    potentialModificationMotif.setValue(xTandemParameterSet
     545      .getResiduePotentialModificationMotif());
     546    residueFS.add(potentialModificationMotif);
     547    /*
     548     * Protein field set
     549     */
     550    Fieldset proteinFS = new Fieldset();
     551    proteinFS.setTitle("XTandemParameterSetProtein");
     552    form.addFieldset(proteinFS);
     553    // Protein, taxon
     554    /*
     555     * Taxonomy selection has two peculiarities: 1. It supports selection of
     556     * multiple items. 2. The GUI selection is divided into two multiple
     557     * selection boxes. The multiple selection items are stored in XML as a
     558     * string with items separated by ", ".
     559     */
     560    // Taxon - Eukaryotes
     561    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_TAXON;
     562    optionList = new ArrayList<Option>();
     563    optionList.add(new Option("", "none"));
     564    optionList.add(new Option("human", "H. sapiens (human)"));
     565    optionList.add(new Option("mouse", "M. musculus (mouse)"));
     566    optionList.add(new Option("rat", "R. norvegicus (rat)"));
     567    optionList.add(new Option("yeast", "S. cerevisiae (budding yeast)"));
     568    optionList.add(new Option("", "------------------"));
     569    optionList.add(new Option("mosquito", "A. gambiae (mosquito)"));
     570    optionList.add(new Option("aspergillus_fumigatus",
     571      "A. fumigatus (mould)"));
     572    optionList.add(new Option("bee", "A. mellifera (honey bee)"));
     573    optionList.add(new Option("thalecress", "A. thaliana (thale cress)"));
     574    optionList.add(new Option("cow", "B. taurus (cow)"));
     575    optionList.add(new Option("dog", "C. familiaris (dog)"));
     576    optionList.add(new Option("worm", "C. elegans (round worm)"));
     577    optionList.add(new Option("zebrafish", "D. rerio (zebra fish)"));
     578    optionList.add(new Option("fly", "D. melanogaster (fruit fly)"));
     579    optionList.add(new Option("chicken", "G. gallus (hen)"));
     580    optionList.add(new Option("human", "H. sapiens (human)"));
     581    optionList.add(new Option("mouse", "M. musculus (mouse)"));
     582    optionList.add(new Option("rice", "O.sativa (rice)"));
     583    optionList.add(new Option("rat", "R. norvegicus (rat)"));
     584    optionList.add(new Option("spombe", "S. pombe (fission yeast)"));
     585    optionList.add(new Option("yeast", "S. cerevisiae (budding yeast)"));
     586    optionList.add(new Option("frog", "S. tropicalis (toad)"));
     587    // Use input species option list if present
     588    if (speciesOptionList != null && speciesOptionList.size() > 0)
     589    {
     590      optionList = speciesOptionList;
     591    }
     592    selected = xTandemParameterSet.getProteinTaxon();
     593    selectedList = listStringToStringList(selected, ",\\ ");
     594    Select<VString> taxon = new Select<VString>(validStringParam,
     595      optionList, selectedList);
     596    taxon.setLabel("XTandemProteinTaxonEukaryotes");
     597    taxon.setMultiple(true);
     598    taxon.setSize(5);
     599    proteinFS.add(taxon);
     600    // Taxon - Prokaryotes
     601    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_TAXON1;
     602    optionList = new ArrayList<Option>();
     603    optionList.add(new Option("", "none"));
     604    optionList.add(new Option("Bacillus_subtilis", "Bacillus subtilis"));
     605    optionList.add(new Option("Clostridium_perfringens",
     606      "Clostridium perfringens"));
     607    optionList.add(new Option("Deinococcus_radiodurans",
     608      "Deinococcus radiodurans"));
     609    optionList.add(new Option("Escherichia_coli_K12",
     610      "Escherichia coli K12"));
     611    optionList.add(new Option("Francisella_tularensis_tularensis",
     612      "Francisella tularensis tularensis"));
     613    optionList.add(new Option("Geobacter_sulfurreducens",
     614      "Geobacter sulfurreducens"));
     615    optionList.add(new Option("Haemophilus_influenzae",
     616      "Haemophilus influenzae"));
     617    optionList.add(new Option("Listeria_innocua", "Listeria innocua"));
     618    optionList.add(new Option("Mycobacterium_leprae",
     619      "Mycobacterium leprae"));
     620    optionList.add(new Option("Mycobacterium_tuberculosis_CDC1551",
     621      "Mycobacterium tuberculosis CDC1551"));
     622    optionList
     623      .add(new Option("Mycoplasma_pulmonis", "Mycoplasma pulmonis"));
     624    optionList.add(new Option("Staphylococcus_aureus_MW2",
     625      "Staphylococcus aureus MW2"));
     626    optionList.add(new Option("Streptococcus_pneumoniae_TIGR4",
     627      "Streptococcus pneumoniae TIGR4"));
     628    optionList.add(new Option("Streptococcus_pyogenes_M1_GAS",
     629      "Streptococcus pyogenes M1 GAS"));
     630    optionList.add(new Option("Yersinia_pestis_CO92",
     631      "Yersinia pestis CO92"));
     632    // Use input species option list if present
     633    if (proSpeciesOptionList != null && proSpeciesOptionList.size() > 0)
     634    {
     635      optionList = proSpeciesOptionList;
     636    }
     637    // Same selection list as for Eukaryotes taxon is used for Prokaryotes
     638    Select<VString> taxon1 = new Select<VString>(validStringParam,
     639      optionList, selectedList);
     640    taxon1.setLabel("XTandemProteinTaxonProkaryotes");
     641    taxon1.setMultiple(true);
     642    taxon1.setSize(5);
     643    proteinFS.add(taxon1);
     644    // Protein, cleavage site
     645    /*
     646     * Protein cleavage site selection has one peculiarity: 1. The GUI
     647     * selection is divided into one selection box and an entry field. A
     648     * selection in the selection box will only be used if the entry field
     649     * is empty.
     650     */
     651    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_SITE_SELECT;
     652    optionList = new ArrayList<Option>();
     653    optionList.add(new Option("[RK]|{P}", "trypsin, [RK]|{P}"));
     654    optionList.add(new Option("[R]|[X]", "endo-arg-C, [R]|[X]"));
     655    optionList.add(new Option("[K]|[X]", "endo-lys-C, [K]|[X]"));
     656    optionList.add(new Option("[E]|[X]", "endo-glu-C, [E]|[X]"));
     657    optionList.add(new Option("[X]|[D]", "endo-asp-N, [X]|[D]"));
     658    optionList.add(new Option("[ED]|[X]", "V8, [ED]|[X]"));
     659    // Use input protein cleavage site option list if present
     660    if (proteinCleavageSiteOptionList != null && proteinCleavageSiteOptionList
     661      .size() > 0)
     662    {
     663      optionList = proteinCleavageSiteOptionList;
     664    }
     665    selected = xTandemParameterSet.getProteinCleavageSite();
     666    Select<VString> proteinCleavageSiteSelectBox = new Select<VString>(
     667      validStringParam, optionList);
     668  proteinCleavageSiteSelectBox.selectOption( selected);
     669    proteinCleavageSiteSelectBox
     670      .setLabel("XTandemProteinCleavageSiteSelect");
     671    proteinFS.add(proteinCleavageSiteSelectBox);
     672    // Protein, cleavage site (own entered value)
     673    TextField<String> cleavageSite = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_SITE);
     674    cleavageSite.setLabel("XTandemProteinCleavageSiteEnter");
     675    // Only insert selected value if not found in select box
     676    if (!itemInOptionList(optionList, selected))
     677    {
     678      cleavageSite.setValue(xTandemParameterSet.getProteinCleavageSite());
     679    }
     680    else
     681    {
     682      cleavageSite.setValue("");
     683    }
     684    proteinFS.add(cleavageSite);
     685    // Protein, modified residue mass file
     686    TextField<String> proteinModifiedResidueMassFile = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_MODIFIED_RESIDUE_MASS_FILE);
     687    proteinModifiedResidueMassFile.setValue(xTandemParameterSet
     688      .getProteinModifiedResidueMassFile());
     689    proteinFS.add(proteinModifiedResidueMassFile);
     690    // Protein, cleavage N-terminal mass change
     691    TextField<String> proteinCleavageNTerminalMassChange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_N_TERMINAL_MASS_CHANGE);
     692    proteinCleavageNTerminalMassChange.setValue(xTandemParameterSet
     693      .getProteinCleavageNTerminalMassChange());
     694    proteinFS.add(proteinCleavageNTerminalMassChange);
     695    // Protein, cleavage C-terminal mass change
     696    TextField<String> proteinCleavageCTerminalMassChange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_C_TERMINAL_MASS_CHANGE);
     697    proteinCleavageCTerminalMassChange.setValue(xTandemParameterSet
     698      .getProteinCleavageCTerminalMassChange());
     699    proteinFS.add(proteinCleavageCTerminalMassChange);
     700    // Protein, N-terminal residue modification mass
     701    TextField<String> nTerminalResidueModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_N_TERMINAL_RESIDUE_MODIFICATION_MASS);
     702    nTerminalResidueModificationMass.setValue(xTandemParameterSet
     703      .getProteinNTerminalResidueModificationMass());
     704    proteinFS.add(nTerminalResidueModificationMass);
     705    // Protein, C-terminal residue modification mass
     706    TextField<String> cTerminalResidueModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_C_TERMINAL_RESIDUE_MODIFICATION_MASS);
     707    cTerminalResidueModificationMass.setValue(xTandemParameterSet
     708      .getProteinCTerminalResidueModificationMass());
     709    proteinFS.add(cTerminalResidueModificationMass);
     710    // Protein, homolog management
     711    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_HOMOLOG_MANAGEMENT;
     712    stringList = new ArrayList<String>();
     713    stringList.add("yes");
     714    stringList.add("no");
     715    selected = xTandemParameterSet.getProteinHomologManagement();
     716    Select<VString> homologManagement = new Select<VString>(validStringParam, stringList, selected);
     717    proteinFS.add(homologManagement);
     718    /*
     719     * Refine field set
     720     */
     721    Fieldset refineFS = new Fieldset();
     722    refineFS.setTitle("XTandemParameterSetRefine");
     723    form.addFieldset(refineFS);
     724    // Refine
     725    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE;
     726    stringList = new ArrayList<String>();
     727    stringList.add("yes");
     728    stringList.add("no");
     729    selected = xTandemParameterSet.getRefine();
     730    Select<VString> refine = new Select<VString>(validStringParam,  stringList, selected);
     731    refineFS.add(refine);
     732    // Refine, modification mass
     733    TextField<String> refineModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_MODIFICATION_MASS);
     734    refineModificationMass.setValue(xTandemParameterSet
     735      .getRefineModificationMass());
     736    refineFS.add(refineModificationMass);
     737    // Refine, sequence path
     738    TextField<String> refineSequencePath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_SEQUENCE_PATH);
     739    refineSequencePath
     740      .setValue(xTandemParameterSet.getRefineSequencePath());
     741    refineFS.add(refineSequencePath);
     742    // Refine, tic percent
     743    TextField<String> refineTicPercent = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_TIC_PERCENT);
     744    refineTicPercent.setValue(xTandemParameterSet.getRefineTicPercent());
     745    refineFS.add(refineTicPercent);
     746    // Refine, spectrum synthesis
     747    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_SPECTRUM_SYNTHESIS;
     748    stringList = new ArrayList<String>();
     749    stringList.add("yes");
     750    stringList.add("no");
     751    selected = xTandemParameterSet.getRefineSpectrumSynthesis();
     752    Select<VString> spectrumSynthesis = new Select<VString>(validStringParam, stringList, selected);
     753    refineFS.add(spectrumSynthesis);
     754    // Refine, maximum valid expectation value
     755    TextField<String> maxValidExpectationValue = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_MAX_VALID_EXPECTATION_VALUE);
     756    maxValidExpectationValue.setValue(xTandemParameterSet
     757      .getRefineMaximumValidExpectationValue());
     758    refineFS.add(maxValidExpectationValue);
     759    // Refine, potential N-terminus modifications
     760    TextField<String> potentialNTerminusModifications = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_N_TERMINUS_MODIFICATIONS);
     761    potentialNTerminusModifications.setValue(xTandemParameterSet
     762      .getRefinePotentialNTerminusModifications());
     763    refineFS.add(potentialNTerminusModifications);
     764    // Refine, potential C-terminus modifications
     765    TextField<String> potentialCTerminusModifications = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_C_TERMINUS_MODIFICATIONS);
     766    potentialCTerminusModifications.setValue(xTandemParameterSet
     767      .getRefinePotentialCTerminusModifications());
     768    refineFS.add(potentialCTerminusModifications);
     769    // Refine, unanticipated cleavage
     770    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_UNANTICIPATED_CLEAVAGE;
     771    stringList = new ArrayList<String>();
     772    stringList.add("yes");
     773    stringList.add("no");
     774    selected = xTandemParameterSet.getRefineUnanticipatedCleavage();
     775    Select<VString> unanticipatedCleavage = new Select<VString>(validStringParam, stringList, selected);
     776    refineFS.add(unanticipatedCleavage);
     777    // Refine, potential modification mass select
     778    /*
     779     * Refine potential modification mass selection has two peculiarities:
     780     * 1. It supports selection of multiple items. 2. The GUI selection is
     781     * divided into one multiple selection box and an entry field.
     782     * Selections in the selection box will only be used if the entry field
     783     * is empty. The multiple selection items are stored in XML as a string
     784     * with items separated by ", ".
     785     */
     786    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MASS_SELECT;
     787    optionList = new ArrayList<Option>();
     788    optionList.add(new Option("", "none"));
     789    optionList.add(new Option("15.994915@M", "Oxidation (M)"));
     790    optionList.add(new Option("15.994915@W", "Oxidation (W)"));
     791    optionList.add(new Option("0.984016@N", "Deamidation (N)"));
     792    optionList.add(new Option("0.984016@Q", "Deamidation (Q)"));
     793    optionList.add(new Option("8.0502@C", "ICAT-D:2H(8) (C)"));
     794    optionList.add(new Option("9.0302@C", "ICAT-C:13C(9) (C)"));
     795    optionList.add(new Option("144.102063@[", "iTRAQ (N-term)"));
     796    optionList.add(new Option("144.102063@K", "iTRAQ (K)"));
     797    optionList.add(new Option("79.966331@S", "Phospho (S)"));
     798    optionList.add(new Option("79.966331@T", "Phospho (T)"));
     799    optionList.add(new Option("79.966331@Y", "Phospho (Y)"));
     800    optionList.add(new Option("79.956815@Y", "Sulfo (Y)"));
     801    optionList.add(new Option("42.010565@K", "Acetyl (K)"));
     802    // Use input refine potential modification mass option list if present
     803    if (refinePotentialModificationMassOptionList != null && refinePotentialModificationMassOptionList
     804      .size() > 0)
     805    {
     806      optionList = refinePotentialModificationMassOptionList;
     807      log
     808        .debug("Input refine potential modification mass option list used");
     809    }
     810    else
     811    {
     812      log
     813        .debug("Default refine potential modification mass option list used");
     814    }
     815    selected = xTandemParameterSet.getRefinePotentialModificationMass();
     816    log
     817      .debug("refine potential modification mass selected = \"" + selected + "\"");
     818    selectedList = listStringToStringList(selected, ",");
     819    log
     820      .debug("refine potential modification mass selectedList = " + selectedList);
     821    Select<VString> refinePotentialModificationMassSelectBox = new Select<VString>(
     822      validStringParam, optionList, selectedList);
     823    refinePotentialModificationMassSelectBox
     824      .setLabel("XTandemRefinePotentialModificationMassSelect");
     825    refinePotentialModificationMassSelectBox.setMultiple(true);
     826    refinePotentialModificationMassSelectBox.setSize(4);
     827    refineFS.add(refinePotentialModificationMassSelectBox);
     828    // Refine, potential modification mass
     829    TextField<String> refinePotentialModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MASS);
     830    refinePotentialModificationMass
     831      .setLabel("XTandemRefinePotentialModificationMassEnter");
     832    refinePotentialModificationMass.setValue(xTandemParameterSet
     833      .getRefinePotentialModificationMass());
     834    // Only insert selected values if not all found in select box
     835    if (!allItemsInOptionList(optionList, selectedList))
     836    {
     837      log
     838        .debug("refine potential modification mass, inserted value = \"" + xTandemParameterSet
     839          .getRefinePotentialModificationMass() + "\"");
     840      refinePotentialModificationMass.setValue(xTandemParameterSet
     841        .getRefinePotentialModificationMass());
     842    }
     843    else
     844    {
     845      refinePotentialModificationMass.setValue("");
     846    }
     847    refineFS.add(refinePotentialModificationMass);
     848    /** **************************************** */
     849    // Refine, point mutations
     850    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POINT_MUTATIONS;
     851    stringList = new ArrayList<String>();
     852    stringList.add("yes");
     853    stringList.add("no");
     854    selected = xTandemParameterSet.getRefinePointMutations();
     855    Select<VString> pointMutations = new Select<VString>(validStringParam,  stringList, selected);
     856    refineFS.add(pointMutations);
     857    // Refine, use potential modifications for full refinement
     858    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_USE_POTENTIAL_MODIFICATIONS_FOR_FULL_REFINEMENT;
     859    stringList = new ArrayList<String>();
     860    stringList.add("yes");
     861    stringList.add("no");
     862    selected = xTandemParameterSet
     863      .getRefineUsePotentialModificationsForFullRefinement();
     864    Select<VString> usePotentialModificationsForFullRefinement = new Select<VString>(validStringParam, stringList, selected);
     865    refineFS.add(usePotentialModificationsForFullRefinement);
     866    // Refine, potential modification motif
     867    TextField<String> potentialModificationMotifRefine = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MOTIF);
     868    potentialModificationMotifRefine.setValue(xTandemParameterSet
     869      .getRefinePotentialModificationMotif());
     870    refineFS.add(potentialModificationMotifRefine);
     871    /*
     872     * Scoring field set
     873     */
     874    Fieldset scoringFS = new Fieldset();
     875    scoringFS.setTitle("XTandemParameterSetScoring");
     876    form.addFieldset(scoringFS);
     877    // Scoring, minimum ion count
     878    TextField<String> minIonCount = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_MIN_ION_COUNT);
     879    minIonCount.setValue(xTandemParameterSet.getScoringMinimumIonCount());
     880    scoringFS.add(minIonCount);
     881    // Scoring, maximum missed cleavage sites
     882    TextField<String> maxMissedCleavageSites = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_MAX_MISSED_CLEAVAGE_SITES);
     883    maxMissedCleavageSites.setValue(xTandemParameterSet
     884      .getScoringMaximumMissedCleavageSites());
     885    scoringFS.add(maxMissedCleavageSites);
     886    // Scoring, x ions
     887    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_X_IONS;
     888    stringList = new ArrayList<String>();
     889    stringList.add("yes");
     890    stringList.add("no");
     891    selected = xTandemParameterSet.getScoringXIons();
     892    Select<VString> xIons = new Select<VString>(validStringParam, stringList, selected);
     893    scoringFS.add(xIons);
     894    // Scoring, y ions
     895    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_Y_IONS;
     896    stringList = new ArrayList<String>();
     897    stringList.add("yes");
     898    stringList.add("no");
     899    selected = xTandemParameterSet.getScoringYIons();
     900    Select<VString> yIons = new Select<VString>(validStringParam, stringList, selected);
     901    scoringFS.add(yIons);
     902    // Scoring, z ions
     903    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_Z_IONS;
     904    stringList = new ArrayList<String>();
     905    stringList.add("yes");
     906    stringList.add("no");
     907    selected = xTandemParameterSet.getScoringZIons();
     908    Select<VString> zIons = new Select<VString>(validStringParam, stringList, selected);
     909    scoringFS.add(zIons);
     910    // Scoring, a ions
     911    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_A_IONS;
     912    stringList = new ArrayList<String>();
     913    stringList.add("yes");
     914    stringList.add("no");
     915    selected = xTandemParameterSet.getScoringAIons();
     916    Select<VString> aIons = new Select<VString>(validStringParam, stringList, selected);
     917    scoringFS.add(aIons);
     918    // Scoring, b ions
     919    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_B_IONS;
     920    stringList = new ArrayList<String>();
     921    stringList.add("yes");
     922    stringList.add("no");
     923    selected = xTandemParameterSet.getScoringBIons();
     924    Select<VString> bIons = new Select<VString>(validStringParam, stringList, selected);
     925    scoringFS.add(bIons);
     926    // Scoring, c ions
     927    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_C_IONS;
     928    stringList = new ArrayList<String>();
     929    stringList.add("yes");
     930    stringList.add("no");
     931    selected = xTandemParameterSet.getScoringCIons();
     932    Select<VString> cIons = new Select<VString>(validStringParam, stringList, selected);
     933    scoringFS.add(cIons);
     934    // Scoring, cyclic permutation
     935    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_CYCLIC_PERMUTATION;
     936    stringList = new ArrayList<String>();
     937    stringList.add("yes");
     938    stringList.add("no");
     939    selected = xTandemParameterSet.getScoringCyclicPermutation();
     940    Select<VString> cyclicPermutation = new Select<VString>(validStringParam, stringList, selected);
     941    scoringFS.add(cyclicPermutation);
     942    // Scoring, include reverse
     943    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_INCLUDE_REVERSE;
     944    stringList = new ArrayList<String>();
     945    stringList.add("yes");
     946    stringList.add("no");
     947    selected = xTandemParameterSet.getScoringIncludeReverse();
     948    Select<VString> includeReverse = new Select<VString>(validStringParam, stringList, selected);
     949    scoringFS.add(includeReverse);
     950    // Scoring, algorithm
     951    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_ALGORITHM;
     952    optionList = new ArrayList<Option>();
     953    optionList.add(new Option("", "native"));
     954    optionList.add(new Option("k-score", "k-score"));
     955    selected = xTandemParameterSet.getScoringAlgorithm();
     956    Select<VString> algorithmSelectBox = new Select<VString>(
     957      validStringParam, optionList);
     958  algorithmSelectBox.selectOption( selected);
     959    scoringFS.add(algorithmSelectBox);
     960    /*
     961     * Output field set
     962     */
     963    Fieldset outputFS = new Fieldset();
     964    outputFS.setTitle("XTandemParameterSetOutput");
     965    form.addFieldset(outputFS);
     966    // Output, path
     967    TextField<String> outputPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PATH);
     968    outputPath.setValue(xTandemParameterSet.getOutputPath());
     969    outputFS.add(outputPath);
     970    // Output, log path
     971    TextField<String> outputLogPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_LOG_PATH);
     972    outputLogPath.setValue(xTandemParameterSet.getOutputLogPath());
     973    outputFS.add(outputLogPath);
     974    // Output, message
     975    TextField<String> outputMessage = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_MESSAGE);
     976    outputMessage.setValue(xTandemParameterSet.getOutputMessage());
     977    outputFS.add(outputMessage);
     978    // Output, sequence path
     979    TextField<String> outputSequencePath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SEQUENCE_PATH);
     980    outputSequencePath
     981      .setValue(xTandemParameterSet.getOutputSequencePath());
     982    outputFS.add(outputSequencePath);
     983    // Output, sort results by
     984    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SORT_RESULTS_BY;
     985    stringList = new ArrayList<String>();
     986    stringList.add("protein");
     987    stringList.add("spectrum");
     988    selected = xTandemParameterSet.getOutputSortResultsBy();
     989    Select<VString> outputSortResultsBy = new Select<VString>(validStringParam, stringList, selected);
     990    outputFS.add(outputSortResultsBy);
     991    // Output, path hashing
     992    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PATH_HASHING;
     993    stringList = new ArrayList<String>();
     994    stringList.add("yes");
     995    stringList.add("no");
     996    selected = xTandemParameterSet.getOutputPathHashing();
     997    Select<VString> pathHashing = new Select<VString>(validStringParam, stringList, selected);
     998    outputFS.add(pathHashing);
     999    // Output, xsl path
     1000    TextField<String> xslPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_XSL_PATH);
     1001    xslPath.setValue(xTandemParameterSet.getOutputXslPath());
     1002    outputFS.add(xslPath);
     1003    // Output, parameters
     1004    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PARAMETERS;
     1005    stringList = new ArrayList<String>();
     1006    stringList.add("yes");
     1007    stringList.add("no");
     1008    selected = xTandemParameterSet.getOutputParameters();
     1009    Select<VString> parameters = new Select<VString>(validStringParam, stringList, selected);
     1010    outputFS.add(parameters);
     1011    // Output, performance
     1012    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PERFORMANCE;
     1013    stringList = new ArrayList<String>();
     1014    stringList.add("yes");
     1015    stringList.add("no");
     1016    selected = xTandemParameterSet.getOutputPerformance();
     1017    Select<VString> performance = new Select<VString>(validStringParam, stringList, selected);
     1018    outputFS.add(performance);
     1019    // Output, spectra
     1020    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SPECTRA;
     1021    stringList = new ArrayList<String>();
     1022    stringList.add("yes");
     1023    stringList.add("no");
     1024    selected = xTandemParameterSet.getOutputSpectra();
     1025    Select<VString> spectra = new Select<VString>(validStringParam, stringList, selected);
     1026    outputFS.add(spectra);
     1027    // Output, histograms
     1028    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_HISTOGRAMS;
     1029    stringList = new ArrayList<String>();
     1030    stringList.add("yes");
     1031    stringList.add("no");
     1032    selected = xTandemParameterSet.getOutputHistograms();
     1033    Select<VString> histograms = new Select<VString>(validStringParam,  stringList, selected);
     1034    outputFS.add(histograms);
     1035    // Output, proteins
     1036    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PROTEINS;
     1037    stringList = new ArrayList<String>();
     1038    stringList.add("yes");
     1039    stringList.add("no");
     1040    selected = xTandemParameterSet.getOutputProteins();
     1041    Select<VString> proteins = new Select<VString>(validStringParam,  stringList, selected);
     1042    outputFS.add(proteins);
     1043    // Output, sequences
     1044    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SEQUENCES;
     1045    stringList = new ArrayList<String>();
     1046    stringList.add("yes");
     1047    stringList.add("no");
     1048    selected = xTandemParameterSet.getOutputSequences();
     1049    Select<VString> sequences = new Select<VString>(validStringParam, stringList, selected);
     1050    outputFS.add(sequences);
     1051    // Output, one sequence copy
     1052    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_ONE_SEQUENCE_COPY;
     1053    stringList = new ArrayList<String>();
     1054    stringList.add("yes");
     1055    stringList.add("no");
     1056    selected = xTandemParameterSet.getOutputOneSequenceCopy();
     1057    Select<VString> oneSequenceCopy = new Select<VString>(validStringParam, stringList, selected);
     1058    outputFS.add(oneSequenceCopy);
     1059    // Output, results
     1060    validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_RESULTS;
     1061    stringList = new ArrayList<String>();
     1062    stringList.add("all");
     1063    stringList.add("valid");
     1064    stringList.add("stochastic");
     1065    selected = xTandemParameterSet.getOutputResults();
     1066    Select<VString> results = new Select<VString>(validStringParam, stringList, selected);
     1067    outputFS.add(results);
     1068    // Output, maximum valid expectation value
     1069    TextField<String> outputMaxValidExpectationValue = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_MAX_VALID_EXPECTATION_VALUE);
     1070    outputMaxValidExpectationValue.setValue(xTandemParameterSet
     1071      .getOutputMaximumValidExpectationValue());
     1072    outputFS.add(outputMaxValidExpectationValue);
     1073    // Output, histogram column width
     1074    TextField<String> histogramColumnWidth = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_HISTOGRAM_COLUMN_WIDTH);
     1075    histogramColumnWidth.setValue(xTandemParameterSet
     1076      .getOutputHistogramColumnWidth());
     1077    outputFS.add(histogramColumnWidth);
     1078    //
     1079    return form;
     1080  }
     1081
     1082
     1083  /**
     1084   * Convenience method for adding XTandemParameterSet fields to a Fieldset.
     1085   *
     1086   * @param xTandemParameterSet XTandemParameterSet object (need not be stored
     1087   *        in database) with default field values.
     1088   * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
     1089   * @param fieldsHidden boolean Flag indicating that added fields should be
     1090   *        hidden.
     1091   * @param fieldsDisabled boolean Flag indicating that added fields should be
     1092   *        disabled.
     1093   * @return Fieldset The input fieldset with added XTandemParameterSet
     1094   *         fields.
     1095   */
     1096  public Fieldset addXTandemParameterSetToFieldset(
     1097      XTandemParameterSet xTandemParameterSet, Fieldset fs,
     1098      boolean fieldsHidden, boolean fieldsDisabled)
     1099  {
     1100    // List path fields
     1101    fs = addXTandemParameterSetListPathFieldsToFieldset(
     1102      xTandemParameterSet, fs, fieldsHidden, fieldsDisabled);
     1103    // Spectrum fields
     1104    fs = addXTandemParameterSetSpectrumFieldsToFieldset(
     1105      xTandemParameterSet, fs, fieldsHidden, fieldsDisabled);
     1106    // Residue fields
     1107    fs = addXTandemParameterSetResidueFieldsToFieldset(xTandemParameterSet,
     1108      fs, fieldsHidden, fieldsDisabled);
     1109    // Protein fields
     1110    fs = addXTandemParameterSetProteinFieldsToFieldset(xTandemParameterSet,
     1111      fs, fieldsHidden, fieldsDisabled);
     1112    // Refine fields
     1113    fs = addXTandemParameterSetRefineFieldsToFieldset(xTandemParameterSet,
     1114      fs, fieldsHidden, fieldsDisabled);
     1115    // Scoring fields
     1116    fs = addXTandemParameterSetScoringFieldsToFieldset(xTandemParameterSet,
     1117      fs, fieldsHidden, fieldsDisabled);
     1118    // Output fields
     1119    fs = addXTandemParameterSetOutputFieldsToFieldset(xTandemParameterSet,
     1120      fs, fieldsHidden, fieldsDisabled);
     1121    // Return Fieldset with added fields
     1122    return fs;
     1123  }
     1124
     1125
     1126  /**
     1127   * Convenience method for adding XTandemParameterSet list path fields to a
     1128   * Fieldset.
     1129   *
     1130   * @param xTandemParameterSet XTandemParameterSet object (need not be stored
     1131   *        in database) with default field values.
     1132   * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
     1133   * @param fieldsHidden boolean Flag indicating that added fields should be
     1134   *        hidden.
     1135   * @param fieldsDisabled boolean Flag indicating that added fields should be
     1136   *        disabled.
     1137   * @return Fieldset The input fieldset with added XTandemParameterSet
     1138   *         fields.
     1139   */
     1140  public Fieldset addXTandemParameterSetListPathFieldsToFieldset(
     1141      XTandemParameterSet xTandemParameterSet, Fieldset fs,
     1142      boolean fieldsHidden, boolean fieldsDisabled)
     1143  {
     1144    // List path, default parameters
     1145    TextField<String> defaultParametersListPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_LIST_PATH_DEFAULT_PARAMETERS);
     1146    defaultParametersListPath.setHidden(fieldsHidden);
     1147    defaultParametersListPath.setDisabled(fieldsDisabled);
     1148    defaultParametersListPath.setValue(xTandemParameterSet
     1149      .getListPathDefaultParameters());
     1150    fs.add(defaultParametersListPath);
     1151    // List path, taxonomy information
     1152    TextField<String> taxonomyInformationListPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_LIST_PATH_TAXONOMY_INFORMATION);
     1153    taxonomyInformationListPath.setHidden(fieldsHidden);
     1154    taxonomyInformationListPath.setDisabled(fieldsDisabled);
     1155    taxonomyInformationListPath.setValue(xTandemParameterSet
     1156      .getListPathTaxonomyInformation());
     1157    fs.add(taxonomyInformationListPath);
     1158    // Return Fieldset with added fields
     1159    return fs;
     1160  }
     1161
     1162
     1163  /**
     1164   * Convenience method for adding XTandemParameterSet spectrum fields to a
     1165   * Fieldset.
     1166   *
     1167   * @param xTandemParameterSet XTandemParameterSet object (need not be stored
     1168   *        in database) with default field values.
     1169   * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
     1170   * @param fieldsHidden boolean Flag indicating that added fields should be
     1171   *        hidden.
     1172   * @param fieldsDisabled boolean Flag indicating that added fields should be
     1173   *        disabled.
     1174   * @return Fieldset The input fieldset with added XTandemParameterSet
     1175   *         fields.
     1176   */
     1177  public Fieldset addXTandemParameterSetSpectrumFieldsToFieldset(
     1178      XTandemParameterSet xTandemParameterSet, Fieldset fs,
     1179      boolean fieldsHidden, boolean fieldsDisabled)
     1180  {
     1181    // Spectrum, path
     1182    TextField<String> spectrumPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PATH);
     1183    spectrumPath.setHidden(fieldsHidden);
     1184    spectrumPath.setDisabled(fieldsDisabled);
     1185    spectrumPath.setValue(xTandemParameterSet.getSpectrumPath());
     1186    fs.add(spectrumPath);
     1187    // Spectrum, fragment monoisotopic mass error
     1188    TextField<String> fragMiMassError = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MI_MASS_ERROR);
     1189    fragMiMassError.setHidden(fieldsHidden);
     1190    fragMiMassError.setDisabled(fieldsDisabled);
     1191    fragMiMassError.setValue(xTandemParameterSet
     1192      .getSpectrumFragmentMonoisotopicMassError());
     1193    fs.add(fragMiMassError);
     1194    // Spectrum, parent monoisotopic mass error plus
     1195    TextField<String> parentMiMassErrorPlus = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_PLUS);
     1196    parentMiMassErrorPlus.setHidden(fieldsHidden);
     1197    parentMiMassErrorPlus.setDisabled(fieldsDisabled);
     1198    parentMiMassErrorPlus.setValue(xTandemParameterSet
     1199      .getSpectrumParentMonoisotopicMassErrorPlus());
     1200    fs.add(parentMiMassErrorPlus);
     1201    // Spectrum, parent monoisotopic mass error minus
     1202    TextField<String> parentMiMassErrorMinus = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_MINUS);
     1203    parentMiMassErrorMinus.setHidden(fieldsHidden);
     1204    parentMiMassErrorMinus.setDisabled(fieldsDisabled);
     1205    parentMiMassErrorMinus.setValue(xTandemParameterSet
     1206      .getSpectrumParentMonoisotopicMassErrorMinus());
     1207    fs.add(parentMiMassErrorMinus);
     1208    // Spectrum, parent monoisotopic mass isotope error
     1209    TextField<String> parentMiMassIsotopeError = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ISOTOPE_ERROR);
     1210    parentMiMassIsotopeError.setHidden(fieldsHidden);
     1211    parentMiMassIsotopeError.setDisabled(fieldsDisabled);
     1212    parentMiMassIsotopeError.setValue(xTandemParameterSet
     1213      .getSpectrumParentMonoisotopicMassIsotopeError());
     1214    fs.add(parentMiMassIsotopeError);
     1215    // Spectrum, fragment monoisotopic mass error units
     1216    TextField<String> fragMiMassErrorUnits = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MI_MASS_ERROR_UNITS);
     1217    fragMiMassErrorUnits.setHidden(fieldsHidden);
     1218    fragMiMassErrorUnits.setDisabled(fieldsDisabled);
     1219    fragMiMassErrorUnits.setValue(xTandemParameterSet
     1220      .getSpectrumFragmentMonoisotopicMassErrorUnits());
     1221    fs.add(fragMiMassErrorUnits);
     1222    // Spectrum, parent monoisotopic mass error units
     1223    TextField<String> parentMiMassErrorUnits = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_UNITS);
     1224    parentMiMassErrorUnits.setHidden(fieldsHidden);
     1225    parentMiMassErrorUnits.setDisabled(fieldsDisabled);
     1226    parentMiMassErrorUnits.setValue(xTandemParameterSet
     1227      .getSpectrumParentMonoisotopicMassErrorUnits());
     1228    fs.add(parentMiMassErrorUnits);
     1229    // Spectrum, fragment mass type
     1230    TextField<String> fragMassType = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MASS_TYPE);
     1231    fragMassType.setHidden(fieldsHidden);
     1232    fragMassType.setDisabled(fieldsDisabled);
     1233    fragMassType
     1234      .setValue(xTandemParameterSet.getSpectrumFragmentMassType());
     1235    fs.add(fragMassType);
     1236    // Spectrum, dynamic range
     1237    TextField<String> dynamicRange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_DYNAMIC_RANGE);
     1238    dynamicRange.setHidden(fieldsHidden);
     1239    dynamicRange.setDisabled(fieldsDisabled);
     1240    dynamicRange.setValue(xTandemParameterSet.getSpectrumDynamicRange());
     1241    fs.add(dynamicRange);
     1242    // Spectrum, total peaks
     1243    TextField<String> totalPeaks = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_TOTAL_PEAKS);
     1244    totalPeaks.setHidden(fieldsHidden);
     1245    totalPeaks.setDisabled(fieldsDisabled);
     1246    totalPeaks.setValue(xTandemParameterSet.getSpectrumTotalPeaks());
     1247    fs.add(totalPeaks);
     1248    // Spectrum, maximum parent charge
     1249    TextField<String> maxParentCharge = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MAX_PARENT_CHARGE);
     1250    maxParentCharge.setHidden(fieldsHidden);
     1251    maxParentCharge.setDisabled(fieldsDisabled);
     1252    maxParentCharge.setValue(xTandemParameterSet
     1253      .getSpectrumMaximumParentCharge());
     1254    fs.add(maxParentCharge);
     1255    // Spectrum, use noise suppression
     1256    TextField<String> useNoiseSuppression = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_USE_NOISE_SUPPRESSION);
     1257    useNoiseSuppression.setHidden(fieldsHidden);
     1258    useNoiseSuppression.setDisabled(fieldsDisabled);
     1259    useNoiseSuppression.setValue(xTandemParameterSet
     1260      .getSpectrumUseNoiseSuppression());
     1261    fs.add(useNoiseSuppression);
     1262    // Spectrum, minimum parent m+h
     1263    TextField<String> minParentMPlusH = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_PARENT_M_PLUS_H);
     1264    minParentMPlusH.setHidden(fieldsHidden);
     1265    minParentMPlusH.setDisabled(fieldsDisabled);
     1266    minParentMPlusH.setValue(xTandemParameterSet
     1267      .getSpectrumMinimumParentMPlusH());
     1268    fs.add(minParentMPlusH);
     1269    // Spectrum, maximum parent m+h
     1270    TextField<String> maxParentMPlusH = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MAX_PARENT_M_PLUS_H);
     1271    maxParentMPlusH.setHidden(fieldsHidden);
     1272    maxParentMPlusH.setDisabled(fieldsDisabled);
     1273    maxParentMPlusH.setValue(xTandemParameterSet
     1274      .getSpectrumMaximumParentMPlusH());
     1275    fs.add(maxParentMPlusH);
     1276    // Spectrum, minimum fragment mz
     1277    TextField<String> minFragmentMz = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_FRAG_MZ);
     1278    minFragmentMz.setHidden(fieldsHidden);
     1279    minFragmentMz.setDisabled(fieldsDisabled);
     1280    minFragmentMz.setValue(xTandemParameterSet
     1281      .getSpectrumMinimumFragmentMz());
     1282    fs.add(minFragmentMz);
     1283    // Spectrum, minimum peaks
     1284    TextField<String> minPeaks = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_PEAKS);
     1285    minPeaks.setHidden(fieldsHidden);
     1286    minPeaks.setDisabled(fieldsDisabled);
     1287    minPeaks.setValue(xTandemParameterSet.getSpectrumMinimumPeaks());
     1288    fs.add(minPeaks);
     1289    // Spectrum, threads
     1290    TextField<String> threads = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_THREADS);
     1291    threads.setHidden(fieldsHidden);
     1292    threads.setDisabled(fieldsDisabled);
     1293    threads.setValue(xTandemParameterSet.getSpectrumThreads());
     1294    fs.add(threads);
     1295    // Spectrum, sequence batch size
     1296    TextField<String> spectrumSequenceBatchSize = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_SEQUENCE_BATCH_SIZE);
     1297    spectrumSequenceBatchSize.setHidden(fieldsHidden);
     1298    spectrumSequenceBatchSize.setDisabled(fieldsDisabled);
     1299    spectrumSequenceBatchSize.setValue(xTandemParameterSet
     1300      .getSpectrumSequenceBatchSize());
     1301    fs.add(spectrumSequenceBatchSize);
     1302    // Return Fieldset with added fields
     1303    return fs;
     1304  }
     1305
     1306
     1307  /**
     1308   * Convenience method for adding XTandemParameterSet residue fields to a
     1309   * Fieldset.
     1310   *
     1311   * @param xTandemParameterSet XTandemParameterSet object (need not be stored
     1312   *        in database) with default field values.
     1313   * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
     1314   * @param fieldsHidden boolean Flag indicating that added fields should be
     1315   *        hidden.
     1316   * @param fieldsDisabled boolean Flag indicating that added fields should be
     1317   *        disabled.
     1318   * @return Fieldset The input fieldset with added XTandemParameterSet
     1319   *         fields.
     1320   */
     1321  public Fieldset addXTandemParameterSetResidueFieldsToFieldset(
     1322      XTandemParameterSet xTandemParameterSet, Fieldset fs,
     1323      boolean fieldsHidden, boolean fieldsDisabled)
     1324  {
     1325    // Residue, modification mass
     1326    TextField<String> modificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_MODIFICATION_MASS);
     1327    modificationMass.setHidden(fieldsHidden);
     1328    modificationMass.setDisabled(fieldsDisabled);
     1329    modificationMass.setValue(xTandemParameterSet
     1330      .getResidueModificationMass());
     1331    fs.add(modificationMass);
     1332    // Residue, potential modification mass
     1333    TextField<String> potentialModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MASS);
     1334    potentialModificationMass.setHidden(fieldsHidden);
     1335    potentialModificationMass.setDisabled(fieldsDisabled);
     1336    potentialModificationMass.setValue(xTandemParameterSet
     1337      .getResiduePotentialModificationMass());
     1338    fs.add(potentialModificationMass);
     1339    // Residue, potential modification motif
     1340    TextField<String> potentialModificationMotif = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MOTIF);
     1341    potentialModificationMotif.setHidden(fieldsHidden);
     1342    potentialModificationMotif.setDisabled(fieldsDisabled);
     1343    potentialModificationMotif.setValue(xTandemParameterSet
     1344      .getResiduePotentialModificationMotif());
     1345    fs.add(potentialModificationMotif);
     1346    // Return Fieldset with added fields
     1347    return fs;
     1348  }
     1349
     1350
     1351  /**
     1352   * Convenience method for adding XTandemParameterSet protein fields to a
     1353   * Fieldset.
     1354   *
     1355   * @param xTandemParameterSet XTandemParameterSet object (need not be stored
     1356   *        in database) with default field values.
     1357   * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
     1358   * @param fieldsHidden boolean Flag indicating that added fields should be
     1359   *        hidden.
     1360   * @param fieldsDisabled boolean Flag indicating that added fields should be
     1361   *        disabled.
     1362   * @return Fieldset The input fieldset with added XTandemParameterSet
     1363   *         fields.
     1364   */
     1365  public Fieldset addXTandemParameterSetProteinFieldsToFieldset(
     1366      XTandemParameterSet xTandemParameterSet, Fieldset fs,
     1367      boolean fieldsHidden, boolean fieldsDisabled)
     1368  {
     1369    // Protein, taxon
     1370    TextField<String> taxon = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_TAXON);
     1371    taxon.setHidden(fieldsHidden);
     1372    taxon.setDisabled(fieldsDisabled);
     1373    taxon.setValue(xTandemParameterSet.getProteinTaxon());
     1374    fs.add(taxon);
     1375    // Protein, cleavage site
     1376    TextField<String> cleavageSite = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_SITE);
     1377    cleavageSite.setHidden(fieldsHidden);
     1378    cleavageSite.setDisabled(fieldsDisabled);
     1379    cleavageSite.setValue(xTandemParameterSet.getProteinCleavageSite());
     1380    fs.add(cleavageSite);
     1381    // Protein, modified residue mass file
     1382    TextField<String> proteinModifiedResidueMassFile = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_MODIFIED_RESIDUE_MASS_FILE);
     1383    proteinModifiedResidueMassFile.setHidden(fieldsHidden);
     1384    proteinModifiedResidueMassFile.setDisabled(fieldsDisabled);
     1385    proteinModifiedResidueMassFile.setValue(xTandemParameterSet
     1386      .getProteinModifiedResidueMassFile());
     1387    fs.add(proteinModifiedResidueMassFile);
     1388    // Protein, cleavage N-terminal mass change
     1389    TextField<String> proteinCleavageNTerminalMassChange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_N_TERMINAL_MASS_CHANGE);
     1390    proteinCleavageNTerminalMassChange.setHidden(fieldsHidden);
     1391    proteinCleavageNTerminalMassChange.setDisabled(fieldsDisabled);
     1392    proteinCleavageNTerminalMassChange.setValue(xTandemParameterSet
     1393      .getProteinCleavageNTerminalMassChange());
     1394    fs.add(proteinCleavageNTerminalMassChange);
     1395    // Protein, cleavage C-terminal mass change
     1396    TextField<String> proteinCleavageCTerminalMassChange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_C_TERMINAL_MASS_CHANGE);
     1397    proteinCleavageCTerminalMassChange.setHidden(fieldsHidden);
     1398    proteinCleavageCTerminalMassChange.setDisabled(fieldsDisabled);
     1399    proteinCleavageCTerminalMassChange.setValue(xTandemParameterSet
     1400      .getProteinCleavageCTerminalMassChange());
     1401    fs.add(proteinCleavageCTerminalMassChange);
     1402    // Protein, N-terminal residue modification mass
     1403    TextField<String> nTerminalResidueModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_N_TERMINAL_RESIDUE_MODIFICATION_MASS);
     1404    nTerminalResidueModificationMass.setHidden(fieldsHidden);
     1405    nTerminalResidueModificationMass.setDisabled(fieldsDisabled);
     1406    nTerminalResidueModificationMass.setValue(xTandemParameterSet
     1407      .getProteinNTerminalResidueModificationMass());
     1408    fs.add(nTerminalResidueModificationMass);
     1409    // Protein, C-terminal residue modification mass
     1410    TextField<String> cTerminalResidueModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_C_TERMINAL_RESIDUE_MODIFICATION_MASS);
     1411    cTerminalResidueModificationMass.setHidden(fieldsHidden);
     1412    cTerminalResidueModificationMass.setDisabled(fieldsDisabled);
     1413    cTerminalResidueModificationMass.setValue(xTandemParameterSet
     1414      .getProteinCTerminalResidueModificationMass());
     1415    fs.add(cTerminalResidueModificationMass);
     1416    // Protein, homolog management
     1417    TextField<String> homologManagement = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_HOMOLOG_MANAGEMENT);
     1418    homologManagement.setHidden(fieldsHidden);
     1419    homologManagement.setDisabled(fieldsDisabled);
     1420    homologManagement.setValue(xTandemParameterSet
     1421      .getProteinHomologManagement());
     1422    fs.add(homologManagement);
     1423    // Return Fieldset with added fields
     1424    return fs;
     1425  }
     1426
     1427
     1428  /**
     1429   * Convenience method for adding XTandemParameterSet refine fields to a
     1430   * Fieldset.
     1431   *
     1432   * @param xTandemParameterSet XTandemParameterSet object (need not be stored
     1433   *        in database) with default field values.
     1434   * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
     1435   * @param fieldsHidden boolean Flag indicating that added fields should be
     1436   *        hidden.
     1437   * @param fieldsDisabled boolean Flag indicating that added fields should be
     1438   *        disabled.
     1439   * @return Fieldset The input fieldset with added XTandemParameterSet
     1440   *         fields.
     1441   */
     1442  public Fieldset addXTandemParameterSetRefineFieldsToFieldset(
     1443      XTandemParameterSet xTandemParameterSet, Fieldset fs,
     1444      boolean fieldsHidden, boolean fieldsDisabled)
     1445  {
     1446    // Refine
     1447    TextField<String> refine = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE);
     1448    refine.setHidden(fieldsHidden);
     1449    refine.setDisabled(fieldsDisabled);
     1450    refine.setValue(xTandemParameterSet.getRefine());
     1451    fs.add(refine);
     1452    // Refine, modification mass
     1453    TextField<String> refineModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_MODIFICATION_MASS);
     1454    refineModificationMass.setHidden(fieldsHidden);
     1455    refineModificationMass.setDisabled(fieldsDisabled);
     1456    refineModificationMass.setValue(xTandemParameterSet
     1457      .getRefineModificationMass());
     1458    fs.add(refineModificationMass);
     1459    // Refine, sequence path
     1460    TextField<String> refineSequencePath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_SEQUENCE_PATH);
     1461    refineSequencePath.setHidden(fieldsHidden);
     1462    refineSequencePath.setDisabled(fieldsDisabled);
     1463    refineSequencePath
     1464      .setValue(xTandemParameterSet.getRefineSequencePath());
     1465    fs.add(refineSequencePath);
     1466    // Refine, tic percent
     1467    TextField<String> refineTicPercent = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_TIC_PERCENT);
     1468    refineTicPercent.setHidden(fieldsHidden);
     1469    refineTicPercent.setDisabled(fieldsDisabled);
     1470    refineTicPercent.setValue(xTandemParameterSet.getRefineTicPercent());
     1471    fs.add(refineTicPercent);
     1472    // Refine, spectrum synthesis
     1473    TextField<String> spectrumSynthesis = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_SPECTRUM_SYNTHESIS);
     1474    spectrumSynthesis.setHidden(fieldsHidden);
     1475    spectrumSynthesis.setDisabled(fieldsDisabled);
     1476    spectrumSynthesis.setValue(xTandemParameterSet
     1477      .getRefineSpectrumSynthesis());
     1478    fs.add(spectrumSynthesis);
     1479    // Refine, maximum valid expectation value
     1480    TextField<String> maxValidExpectationValue = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_MAX_VALID_EXPECTATION_VALUE);
     1481    maxValidExpectationValue.setHidden(fieldsHidden);
     1482    maxValidExpectationValue.setDisabled(fieldsDisabled);
     1483    maxValidExpectationValue.setValue(xTandemParameterSet
     1484      .getRefineMaximumValidExpectationValue());
     1485    fs.add(maxValidExpectationValue);
     1486    // Refine, potential N-terminus modifications
     1487    TextField<String> potentialNTerminusModifications = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_N_TERMINUS_MODIFICATIONS);
     1488    potentialNTerminusModifications.setHidden(fieldsHidden);
     1489    potentialNTerminusModifications.setDisabled(fieldsDisabled);
     1490    potentialNTerminusModifications.setValue(xTandemParameterSet
     1491      .getRefinePotentialNTerminusModifications());
     1492    fs.add(potentialNTerminusModifications);
     1493    // Refine, potential C-terminus modifications
     1494    TextField<String> potentialCTerminusModifications = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_C_TERMINUS_MODIFICATIONS);
     1495    potentialCTerminusModifications.setHidden(fieldsHidden);
     1496    potentialCTerminusModifications.setDisabled(fieldsDisabled);
     1497    potentialCTerminusModifications.setValue(xTandemParameterSet
     1498      .getRefinePotentialCTerminusModifications());
     1499    fs.add(potentialCTerminusModifications);
     1500    // Refine, unanticipated cleavage
     1501    TextField<String> unanticipatedCleavage = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_UNANTICIPATED_CLEAVAGE);
     1502    unanticipatedCleavage.setHidden(fieldsHidden);
     1503    unanticipatedCleavage.setDisabled(fieldsDisabled);
     1504    unanticipatedCleavage.setValue(xTandemParameterSet
     1505      .getRefineUnanticipatedCleavage());
     1506    fs.add(unanticipatedCleavage);
     1507    // Refine, potential modification mass
     1508    TextField<String> refinePotentialModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MASS);
     1509    refinePotentialModificationMass.setHidden(fieldsHidden);
     1510    refinePotentialModificationMass.setDisabled(fieldsDisabled);
     1511    refinePotentialModificationMass.setValue(xTandemParameterSet
     1512      .getRefinePotentialModificationMass());
     1513    fs.add(refinePotentialModificationMass);
     1514    // Refine, point mutations
     1515    TextField<String> pointMutations = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POINT_MUTATIONS);
     1516    pointMutations.setHidden(fieldsHidden);
     1517    pointMutations.setDisabled(fieldsDisabled);
     1518    pointMutations.setValue(xTandemParameterSet.getRefinePointMutations());
     1519    fs.add(pointMutations);
     1520    // Refine, use potential modifications for full refinement
     1521    TextField<String> usePotentialModificationsForFullRefinement = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_USE_POTENTIAL_MODIFICATIONS_FOR_FULL_REFINEMENT);
     1522    usePotentialModificationsForFullRefinement.setHidden(fieldsHidden);
     1523    usePotentialModificationsForFullRefinement.setDisabled(fieldsDisabled);
     1524    usePotentialModificationsForFullRefinement.setValue(xTandemParameterSet
     1525      .getRefineUsePotentialModificationsForFullRefinement());
     1526    fs.add(usePotentialModificationsForFullRefinement);
     1527    // Refine, potential modification motif
     1528    TextField<String> potentialModificationMotifRefine = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MOTIF);
     1529    potentialModificationMotifRefine.setHidden(fieldsHidden);
     1530    potentialModificationMotifRefine.setDisabled(fieldsDisabled);
     1531    potentialModificationMotifRefine.setValue(xTandemParameterSet
     1532      .getRefinePotentialModificationMotif());
     1533    fs.add(potentialModificationMotifRefine);
     1534    // Return Fieldset with added fields
     1535    return fs;
     1536  }
     1537
     1538
     1539  /**
     1540   * Convenience method for adding XTandemParameterSet scoring fields to a
     1541   * Fieldset.
     1542   *
     1543   * @param xTandemParameterSet XTandemParameterSet object (need not be stored
     1544   *        in database) with default field values.
     1545   * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
     1546   * @param fieldsHidden boolean Flag indicating that added fields should be
     1547   *        hidden.
     1548   * @param fieldsDisabled boolean Flag indicating that added fields should be
     1549   *        disabled.
     1550   * @return Fieldset The input fieldset with added XTandemParameterSet
     1551   *         fields.
     1552   */
     1553  public Fieldset addXTandemParameterSetScoringFieldsToFieldset(
     1554      XTandemParameterSet xTandemParameterSet, Fieldset fs,
     1555      boolean fieldsHidden, boolean fieldsDisabled)
     1556  {
     1557    // Scoring, minimum ion count
     1558    TextField<String> minIonCount = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_MIN_ION_COUNT);
     1559    minIonCount.setHidden(fieldsHidden);
     1560    minIonCount.setDisabled(fieldsDisabled);
     1561    minIonCount.setValue(xTandemParameterSet.getScoringMinimumIonCount());
     1562    fs.add(minIonCount);
     1563    // Scoring, maximum missed cleavage sites
     1564    TextField<String> maxMissedCleavageSites = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_MAX_MISSED_CLEAVAGE_SITES);
     1565    maxMissedCleavageSites.setHidden(fieldsHidden);
     1566    maxMissedCleavageSites.setDisabled(fieldsDisabled);
     1567    maxMissedCleavageSites.setValue(xTandemParameterSet
     1568      .getScoringMaximumMissedCleavageSites());
     1569    fs.add(maxMissedCleavageSites);
     1570    // Scoring, x ions
     1571    TextField<String> xIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_X_IONS);
     1572    xIons.setHidden(fieldsHidden);
     1573    xIons.setDisabled(fieldsDisabled);
     1574    xIons.setValue(xTandemParameterSet.getScoringXIons());
     1575    fs.add(xIons);
     1576    // Scoring, y ions
     1577    TextField<String> yIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_Y_IONS);
     1578    yIons.setHidden(fieldsHidden);
     1579    yIons.setDisabled(fieldsDisabled);
     1580    yIons.setValue(xTandemParameterSet.getScoringYIons());
     1581    fs.add(yIons);
     1582    // Scoring, z ions
     1583    TextField<String> zIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_Z_IONS);
     1584    zIons.setHidden(fieldsHidden);
     1585    zIons.setDisabled(fieldsDisabled);
     1586    zIons.setValue(xTandemParameterSet.getScoringZIons());
     1587    fs.add(zIons);
     1588    // Scoring, a ions
     1589    TextField<String> aIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_A_IONS);
     1590    aIons.setHidden(fieldsHidden);
     1591    aIons.setDisabled(fieldsDisabled);
     1592    aIons.setValue(xTandemParameterSet.getScoringAIons());
     1593    fs.add(aIons);
     1594    // Scoring, b ions
     1595    TextField<String> bIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_B_IONS);
     1596    bIons.setHidden(fieldsHidden);
     1597    bIons.setDisabled(fieldsDisabled);
     1598    bIons.setValue(xTandemParameterSet.getScoringBIons());
     1599    fs.add(bIons);
     1600    // Scoring, c ions
     1601    TextField<String> cIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_C_IONS);
     1602    cIons.setHidden(fieldsHidden);
     1603    cIons.setDisabled(fieldsDisabled);
     1604    cIons.setValue(xTandemParameterSet.getScoringCIons());
     1605    fs.add(cIons);
     1606    // Scoring, cyclic permutation
     1607    TextField<String> cyclicPermutation = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_CYCLIC_PERMUTATION);
     1608    cyclicPermutation.setHidden(fieldsHidden);
     1609    cyclicPermutation.setDisabled(fieldsDisabled);
     1610    cyclicPermutation.setValue(xTandemParameterSet
     1611      .getScoringCyclicPermutation());
     1612    fs.add(cyclicPermutation);
     1613    // Scoring, include reverse
     1614    TextField<String> includeReverse = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_INCLUDE_REVERSE);
     1615    includeReverse.setHidden(fieldsHidden);
     1616    includeReverse.setDisabled(fieldsDisabled);
     1617    includeReverse.setValue(xTandemParameterSet.getScoringIncludeReverse());
     1618    fs.add(includeReverse);
     1619    // Scoring, algorithm
     1620    TextField<String> algorithm = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_ALGORITHM);
     1621    algorithm.setHidden(fieldsHidden);
     1622    algorithm.setDisabled(fieldsDisabled);
     1623    algorithm.setValue(xTandemParameterSet.getScoringAlgorithm());
     1624    fs.add(algorithm);
     1625    // Return Fieldset with added fields
     1626    return fs;
     1627  }
     1628
     1629
     1630  /**
     1631   * Convenience method for adding XTandemParameterSet output fields to a
     1632   * Fieldset.
     1633   *
     1634   * @param xTandemParameterSet XTandemParameterSet object (need not be stored
     1635   *        in database) with default field values.
     1636   * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
     1637   * @param fieldsHidden boolean Flag indicating that added fields should be
     1638   *        hidden.
     1639   * @param fieldsDisabled boolean Flag indicating that added fields should be
     1640   *        disabled.
     1641   * @return Fieldset The input fieldset with added XTandemParameterSet
     1642   *         fields.
     1643   */
     1644  public Fieldset addXTandemParameterSetOutputFieldsToFieldset(
     1645      XTandemParameterSet xTandemParameterSet, Fieldset fs,
     1646      boolean fieldsHidden, boolean fieldsDisabled)
     1647  {
     1648    // Output, path
     1649    TextField<String> outputPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PATH);
     1650    outputPath.setHidden(fieldsHidden);
     1651    outputPath.setDisabled(fieldsDisabled);
     1652    outputPath.setValue(xTandemParameterSet.getOutputPath());
     1653    fs.add(outputPath);
     1654    // Output, log path
     1655    TextField<String> outputLogPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_LOG_PATH);
     1656    outputLogPath.setHidden(fieldsHidden);
     1657    outputLogPath.setDisabled(fieldsDisabled);
     1658    outputLogPath.setValue(xTandemParameterSet.getOutputLogPath());
     1659    fs.add(outputLogPath);
     1660    // Output, message
     1661    TextField<String> outputMessage = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_MESSAGE);
     1662    outputMessage.setHidden(fieldsHidden);
     1663    outputMessage.setDisabled(fieldsDisabled);
     1664    outputMessage.setValue(xTandemParameterSet.getOutputMessage());
     1665    fs.add(outputMessage);
     1666    // Output, sequence path
     1667    TextField<String> outputSequencePath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SEQUENCE_PATH);
     1668    outputSequencePath.setHidden(fieldsHidden);
     1669    outputSequencePath.setDisabled(fieldsDisabled);
     1670    outputSequencePath
     1671      .setValue(xTandemParameterSet.getOutputSequencePath());
     1672    fs.add(outputSequencePath);
     1673    // Output, sort results by
     1674    TextField<String> outputSortResultsBy = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SORT_RESULTS_BY);
     1675    outputSortResultsBy.setHidden(fieldsHidden);
     1676    outputSortResultsBy.setDisabled(fieldsDisabled);
     1677    outputSortResultsBy.setValue(xTandemParameterSet
     1678      .getOutputSortResultsBy());
     1679    fs.add(outputSortResultsBy);
     1680    // Output, path hashing
     1681    TextField<String> pathHashing = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PATH_HASHING);
     1682    pathHashing.setHidden(fieldsHidden);
     1683    pathHashing.setDisabled(fieldsDisabled);
     1684    pathHashing.setValue(xTandemParameterSet.getOutputPathHashing());
     1685    fs.add(pathHashing);
     1686    // Output, xsl path
     1687    TextField<String> xslPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_XSL_PATH);
     1688    xslPath.setHidden(fieldsHidden);
     1689    xslPath.setDisabled(fieldsDisabled);
     1690    xslPath.setValue(xTandemParameterSet.getOutputXslPath());
     1691    fs.add(xslPath);
     1692    // Output, parameters
     1693    TextField<String> parameters = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PARAMETERS);
     1694    parameters.setHidden(fieldsHidden);
     1695    parameters.setDisabled(fieldsDisabled);
     1696    parameters.setValue(xTandemParameterSet.getOutputParameters());
     1697    fs.add(parameters);
     1698    // Output, performance
     1699    TextField<String> performance = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PERFORMANCE);
     1700    performance.setHidden(fieldsHidden);
     1701    performance.setDisabled(fieldsDisabled);
     1702    performance.setValue(xTandemParameterSet.getOutputPerformance());
     1703    fs.add(performance);
     1704    // Output, spectra
     1705    TextField<String> spectra = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SPECTRA);
     1706    spectra.setValue(xTandemParameterSet.getOutputSpectra());
     1707    spectra.setHidden(fieldsHidden);
     1708    spectra.setDisabled(fieldsDisabled);
     1709    fs.add(spectra);
     1710    // Output, histograms
     1711    TextField<String> histograms = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_HISTOGRAMS);
     1712    histograms.setHidden(fieldsHidden);
     1713    histograms.setDisabled(fieldsDisabled);
     1714    histograms.setValue(xTandemParameterSet.getOutputHistograms());
     1715    fs.add(histograms);
     1716    // Output, proteins
     1717    TextField<String> proteins = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PROTEINS);
     1718    proteins.setHidden(fieldsHidden);
     1719    proteins.setDisabled(fieldsDisabled);
     1720    proteins.setValue(xTandemParameterSet.getOutputProteins());
     1721    fs.add(proteins);
     1722    // Output, sequences
     1723    TextField<String> sequences = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SEQUENCES);
     1724    sequences.setHidden(fieldsHidden);
     1725    sequences.setDisabled(fieldsDisabled);
     1726    sequences.setValue(xTandemParameterSet.getOutputSequences());
     1727    fs.add(sequences);
     1728    // Output, one sequence copy
     1729    TextField<String> oneSequenceCopy = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_ONE_SEQUENCE_COPY);
     1730    oneSequenceCopy.setHidden(fieldsHidden);
     1731    oneSequenceCopy.setDisabled(fieldsDisabled);
     1732    oneSequenceCopy
     1733      .setValue(xTandemParameterSet.getOutputOneSequenceCopy());
     1734    fs.add(oneSequenceCopy);
     1735    // Output, results
     1736    TextField<String> results = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_RESULTS);
     1737    results.setHidden(fieldsHidden);
     1738    results.setDisabled(fieldsDisabled);
     1739    results.setValue(xTandemParameterSet.getOutputResults());
     1740    fs.add(results);
     1741    // Output, maximum valid expectation value
     1742    TextField<String> outputMaxValidExpectationValue = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_MAX_VALID_EXPECTATION_VALUE);
     1743    outputMaxValidExpectationValue.setHidden(fieldsHidden);
     1744    outputMaxValidExpectationValue.setDisabled(fieldsDisabled);
     1745    outputMaxValidExpectationValue.setValue(xTandemParameterSet
     1746      .getOutputMaximumValidExpectationValue());
     1747    fs.add(outputMaxValidExpectationValue);
     1748    // Output, histogram column width
     1749    TextField<String> histogramColumnWidth = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_HISTOGRAM_COLUMN_WIDTH);
     1750    histogramColumnWidth.setHidden(fieldsHidden);
     1751    histogramColumnWidth.setDisabled(fieldsDisabled);
     1752    histogramColumnWidth.setValue(xTandemParameterSet
     1753      .getOutputHistogramColumnWidth());
     1754    fs.add(histogramColumnWidth);
     1755    // Return Fieldset with added fields
     1756    return fs;
     1757  }
     1758
     1759
     1760  /**
     1761   * Checks if a string is found as option value in an option list.
     1762   *
     1763   * @param optionList List<Option> Option list of options.
     1764   * @param item String String to look for in option values.
     1765   * @return boolean True if item found as option value, else false.
     1766   */
     1767  private boolean itemInOptionList(List<Option> optionList, String item)
     1768  {
     1769    boolean isFound = false;
     1770    // Check if item if found as option value in option list
     1771    if (optionList != null)
     1772    {
     1773      for (int i = 0; i < optionList.size(); i++)
     1774      {
     1775        if (optionList.get(i) != null)
     1776        {
     1777          if (optionList.get(i).getValue().equals(item))
     1778          {
     1779            isFound = true;
     1780            break;
     1781          }
     1782        }
     1783      }
     1784    }
     1785    return isFound;
     1786  }
     1787
     1788
     1789  /**
     1790   * Checks if all strings in input list are found as option values in an
     1791   * option list.
     1792   *
     1793   * @param optionList List<Option> Option list of options.
     1794   * @param itemList List<String> List with strings to look for in option
     1795   *        values.
     1796   * @return boolean True if all items found as option values, else false.
     1797   */
     1798  private boolean allItemsInOptionList(List<Option> optionList,
     1799      List<String> itemList)
     1800  {
     1801    // Check if all items are found among option values
     1802    if (itemList != null)
     1803    {
     1804      for (int j = 0; j < itemList.size(); j++)
     1805      {
     1806        if (itemList.get(j) != null)
     1807        {
     1808          String item = itemList.get(j);
     1809          // Check if item is found among option values
     1810          boolean isFound = false;
     1811          if (optionList != null)
     1812          {
     1813            for (int i = 0; i < optionList.size(); i++)
     1814            {
     1815              if (optionList.get(i) != null)
     1816              {
     1817                if (optionList.get(i).getValue().equals(item))
     1818                {
     1819                  isFound = true;
     1820                }
     1821              }
     1822            }
     1823          }
     1824          // Return if item was not found among option values
     1825          if (!isFound)
     1826          {
     1827            log
     1828              .debug("j = " + j + " item = \"" + item + "\" isFound = " + isFound + " - return false");
     1829            return false;
     1830          }
     1831        }
     1832      }
     1833    }
     1834    return true;
     1835  }
     1836
     1837
     1838  /**
     1839   * Converts a list String to a list with String elements. If the list string
     1840   * contains two delimiter strings directly after each other, an empty string
     1841   * element will be added to the list in the corresponding place. Example:
     1842   * List string "one, two, three" will be converted to a list with the three
     1843   * String elements "one", "two", and "three" using delimiter regular
     1844   * expression ",\\ ".
     1845   *
     1846   * @param listString String A string with a list
     1847   * @param delimiterRegex String A regular expression for the delimiter
     1848   *        between list elements
     1849   * @return List<String> A list of String elements
     1850   */
     1851  private List<String> listStringToStringList(String listString,
     1852      String delimiterRegex)
     1853  {
     1854    List<String> stringList = null;
     1855    if (listString != null)
     1856    {
     1857      stringList = new ArrayList<String>(0);
     1858      for (String part : listString.split(delimiterRegex, -1))
     1859      {
     1860        // Add list part if not already in list
     1861        if (part != null && !stringList.contains(part))
     1862        {
     1863          stringList.add(part);
     1864        }
     1865      }
     1866    }
     1867    return stringList;
     1868  }
     1869
    2481870}

  • trunk/client/servlet/src/org/proteios/gui/form/FormFactory.java

    r3870 r3872  
    22092209
    22102210
    2211   /**
    2212    * Checks if a string is found as option value in an option list.
    2213    *
    2214    * @param optionList List<Option> Option list of options.
    2215    * @param item String String to look for in option values.
    2216    * @return boolean True if item found as option value, else false.
    2217    */
    2218   private boolean itemInOptionList(List<Option> optionList, String item)
    2219   {
    2220     boolean isFound = false;
    2221     // Check if item if found as option value in option list
    2222     if (optionList != null)
    2223     {
    2224       for (int i = 0; i < optionList.size(); i++)
    2225       {
    2226         if (optionList.get(i) != null)
    2227         {
    2228           if (optionList.get(i).getValue().equals(item))
    2229           {
    2230             isFound = true;
    2231             break;
    2232           }
    2233         }
    2234       }
    2235     }
    2236     return isFound;
    2237   }
    2238 
    2239 
    2240   /**
    2241    * Checks if all strings in input list are found as option values in an
    2242    * option list.
    2243    *
    2244    * @param optionList List<Option> Option list of options.
    2245    * @param itemList List<String> List with strings to look for in option
    2246    *        values.
    2247    * @return boolean True if all items found as option values, else false.
    2248    */
    2249   private boolean allItemsInOptionList(List<Option> optionList,
    2250       List<String> itemList)
    2251   {
    2252     // Check if all items are found among option values
    2253     if (itemList != null)
    2254     {
    2255       for (int j = 0; j < itemList.size(); j++)
    2256       {
    2257         if (itemList.get(j) != null)
    2258         {
    2259           String item = itemList.get(j);
    2260           // Check if item is found among option values
    2261           boolean isFound = false;
    2262           if (optionList != null)
    2263           {
    2264             for (int i = 0; i < optionList.size(); i++)
    2265             {
    2266               if (optionList.get(i) != null)
    2267               {
    2268                 if (optionList.get(i).getValue().equals(item))
    2269                 {
    2270                   isFound = true;
    2271                 }
    2272               }
    2273             }
    2274           }
    2275           // Return if item was not found among option values
    2276           if (!isFound)
    2277           {
    2278             log
    2279               .debug("j = " + j + " item = \"" + item + "\" isFound = " + isFound + " - return false");
    2280             return false;
    2281           }
    2282         }
    2283       }
    2284     }
    2285     return true;
    2286   }
    2287 
    22882211
    22892212 //Cleaning up from here
    2290 
    2291   /**
    2292    * Convenience method for adding XTandemParameterSet fields to a Fieldset.
    2293    *
    2294    * @param xTandemParameterSet XTandemParameterSet object (need not be stored
    2295    *        in database) with default field values.
    2296    * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
    2297    * @param fieldsHidden boolean Flag indicating that added fields should be
    2298    *        hidden.
    2299    * @param fieldsDisabled boolean Flag indicating that added fields should be
    2300    *        disabled.
    2301    * @return Fieldset The input fieldset with added XTandemParameterSet
    2302    *         fields.
    2303    */
    2304   public Fieldset addXTandemParameterSetToFieldset(
    2305       XTandemParameterSet xTandemParameterSet, Fieldset fs,
    2306       boolean fieldsHidden, boolean fieldsDisabled)
    2307   {
    2308     // List path fields
    2309     fs = addXTandemParameterSetListPathFieldsToFieldset(
    2310       xTandemParameterSet, fs, fieldsHidden, fieldsDisabled);
    2311     // Spectrum fields
    2312     fs = addXTandemParameterSetSpectrumFieldsToFieldset(
    2313       xTandemParameterSet, fs, fieldsHidden, fieldsDisabled);
    2314     // Residue fields
    2315     fs = addXTandemParameterSetResidueFieldsToFieldset(xTandemParameterSet,
    2316       fs, fieldsHidden, fieldsDisabled);
    2317     // Protein fields
    2318     fs = addXTandemParameterSetProteinFieldsToFieldset(xTandemParameterSet,
    2319       fs, fieldsHidden, fieldsDisabled);
    2320     // Refine fields
    2321     fs = addXTandemParameterSetRefineFieldsToFieldset(xTandemParameterSet,
    2322       fs, fieldsHidden, fieldsDisabled);
    2323     // Scoring fields
    2324     fs = addXTandemParameterSetScoringFieldsToFieldset(xTandemParameterSet,
    2325       fs, fieldsHidden, fieldsDisabled);
    2326     // Output fields
    2327     fs = addXTandemParameterSetOutputFieldsToFieldset(xTandemParameterSet,
    2328       fs, fieldsHidden, fieldsDisabled);
    2329     // Return Fieldset with added fields
    2330     return fs;
    2331   }
    2332 
    2333 
    2334   /**
    2335    * Convenience method for adding XTandemParameterSet list path fields to a
    2336    * Fieldset.
    2337    *
    2338    * @param xTandemParameterSet XTandemParameterSet object (need not be stored
    2339    *        in database) with default field values.
    2340    * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
    2341    * @param fieldsHidden boolean Flag indicating that added fields should be
    2342    *        hidden.
    2343    * @param fieldsDisabled boolean Flag indicating that added fields should be
    2344    *        disabled.
    2345    * @return Fieldset The input fieldset with added XTandemParameterSet
    2346    *         fields.
    2347    */
    2348   public Fieldset addXTandemParameterSetListPathFieldsToFieldset(
    2349       XTandemParameterSet xTandemParameterSet, Fieldset fs,
    2350       boolean fieldsHidden, boolean fieldsDisabled)
    2351   {
    2352     // List path, default parameters
    2353     TextField<String> defaultParametersListPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_LIST_PATH_DEFAULT_PARAMETERS);
    2354     defaultParametersListPath.setHidden(fieldsHidden);
    2355     defaultParametersListPath.setDisabled(fieldsDisabled);
    2356     defaultParametersListPath.setValue(xTandemParameterSet
    2357       .getListPathDefaultParameters());
    2358     fs.add(defaultParametersListPath);
    2359     // List path, taxonomy information
    2360     TextField<String> taxonomyInformationListPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_LIST_PATH_TAXONOMY_INFORMATION);
    2361     taxonomyInformationListPath.setHidden(fieldsHidden);
    2362     taxonomyInformationListPath.setDisabled(fieldsDisabled);
    2363     taxonomyInformationListPath.setValue(xTandemParameterSet
    2364       .getListPathTaxonomyInformation());
    2365     fs.add(taxonomyInformationListPath);
    2366     // Return Fieldset with added fields
    2367     return fs;
    2368   }
    2369 
    2370 
    2371   /**
    2372    * Convenience method for adding XTandemParameterSet spectrum fields to a
    2373    * Fieldset.
    2374    *
    2375    * @param xTandemParameterSet XTandemParameterSet object (need not be stored
    2376    *        in database) with default field values.
    2377    * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
    2378    * @param fieldsHidden boolean Flag indicating that added fields should be
    2379    *        hidden.
    2380    * @param fieldsDisabled boolean Flag indicating that added fields should be
    2381    *        disabled.
    2382    * @return Fieldset The input fieldset with added XTandemParameterSet
    2383    *         fields.
    2384    */
    2385   public Fieldset addXTandemParameterSetSpectrumFieldsToFieldset(
    2386       XTandemParameterSet xTandemParameterSet, Fieldset fs,
    2387       boolean fieldsHidden, boolean fieldsDisabled)
    2388   {
    2389     // Spectrum, path
    2390     TextField<String> spectrumPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PATH);
    2391     spectrumPath.setHidden(fieldsHidden);
    2392     spectrumPath.setDisabled(fieldsDisabled);
    2393     spectrumPath.setValue(xTandemParameterSet.getSpectrumPath());
    2394     fs.add(spectrumPath);
    2395     // Spectrum, fragment monoisotopic mass error
    2396     TextField<String> fragMiMassError = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MI_MASS_ERROR);
    2397     fragMiMassError.setHidden(fieldsHidden);
    2398     fragMiMassError.setDisabled(fieldsDisabled);
    2399     fragMiMassError.setValue(xTandemParameterSet
    2400       .getSpectrumFragmentMonoisotopicMassError());
    2401     fs.add(fragMiMassError);
    2402     // Spectrum, parent monoisotopic mass error plus
    2403     TextField<String> parentMiMassErrorPlus = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_PLUS);
    2404     parentMiMassErrorPlus.setHidden(fieldsHidden);
    2405     parentMiMassErrorPlus.setDisabled(fieldsDisabled);
    2406     parentMiMassErrorPlus.setValue(xTandemParameterSet
    2407       .getSpectrumParentMonoisotopicMassErrorPlus());
    2408     fs.add(parentMiMassErrorPlus);
    2409     // Spectrum, parent monoisotopic mass error minus
    2410     TextField<String> parentMiMassErrorMinus = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_MINUS);
    2411     parentMiMassErrorMinus.setHidden(fieldsHidden);
    2412     parentMiMassErrorMinus.setDisabled(fieldsDisabled);
    2413     parentMiMassErrorMinus.setValue(xTandemParameterSet
    2414       .getSpectrumParentMonoisotopicMassErrorMinus());
    2415     fs.add(parentMiMassErrorMinus);
    2416     // Spectrum, parent monoisotopic mass isotope error
    2417     TextField<String> parentMiMassIsotopeError = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ISOTOPE_ERROR);
    2418     parentMiMassIsotopeError.setHidden(fieldsHidden);
    2419     parentMiMassIsotopeError.setDisabled(fieldsDisabled);
    2420     parentMiMassIsotopeError.setValue(xTandemParameterSet
    2421       .getSpectrumParentMonoisotopicMassIsotopeError());
    2422     fs.add(parentMiMassIsotopeError);
    2423     // Spectrum, fragment monoisotopic mass error units
    2424     TextField<String> fragMiMassErrorUnits = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MI_MASS_ERROR_UNITS);
    2425     fragMiMassErrorUnits.setHidden(fieldsHidden);
    2426     fragMiMassErrorUnits.setDisabled(fieldsDisabled);
    2427     fragMiMassErrorUnits.setValue(xTandemParameterSet
    2428       .getSpectrumFragmentMonoisotopicMassErrorUnits());
    2429     fs.add(fragMiMassErrorUnits);
    2430     // Spectrum, parent monoisotopic mass error units
    2431     TextField<String> parentMiMassErrorUnits = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_UNITS);
    2432     parentMiMassErrorUnits.setHidden(fieldsHidden);
    2433     parentMiMassErrorUnits.setDisabled(fieldsDisabled);
    2434     parentMiMassErrorUnits.setValue(xTandemParameterSet
    2435       .getSpectrumParentMonoisotopicMassErrorUnits());
    2436     fs.add(parentMiMassErrorUnits);
    2437     // Spectrum, fragment mass type
    2438     TextField<String> fragMassType = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MASS_TYPE);
    2439     fragMassType.setHidden(fieldsHidden);
    2440     fragMassType.setDisabled(fieldsDisabled);
    2441     fragMassType
    2442       .setValue(xTandemParameterSet.getSpectrumFragmentMassType());
    2443     fs.add(fragMassType);
    2444     // Spectrum, dynamic range
    2445     TextField<String> dynamicRange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_DYNAMIC_RANGE);
    2446     dynamicRange.setHidden(fieldsHidden);
    2447     dynamicRange.setDisabled(fieldsDisabled);
    2448     dynamicRange.setValue(xTandemParameterSet.getSpectrumDynamicRange());
    2449     fs.add(dynamicRange);
    2450     // Spectrum, total peaks
    2451     TextField<String> totalPeaks = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_TOTAL_PEAKS);
    2452     totalPeaks.setHidden(fieldsHidden);
    2453     totalPeaks.setDisabled(fieldsDisabled);
    2454     totalPeaks.setValue(xTandemParameterSet.getSpectrumTotalPeaks());
    2455     fs.add(totalPeaks);
    2456     // Spectrum, maximum parent charge
    2457     TextField<String> maxParentCharge = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MAX_PARENT_CHARGE);
    2458     maxParentCharge.setHidden(fieldsHidden);
    2459     maxParentCharge.setDisabled(fieldsDisabled);
    2460     maxParentCharge.setValue(xTandemParameterSet
    2461       .getSpectrumMaximumParentCharge());
    2462     fs.add(maxParentCharge);
    2463     // Spectrum, use noise suppression
    2464     TextField<String> useNoiseSuppression = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_USE_NOISE_SUPPRESSION);
    2465     useNoiseSuppression.setHidden(fieldsHidden);
    2466     useNoiseSuppression.setDisabled(fieldsDisabled);
    2467     useNoiseSuppression.setValue(xTandemParameterSet
    2468       .getSpectrumUseNoiseSuppression());
    2469     fs.add(useNoiseSuppression);
    2470     // Spectrum, minimum parent m+h
    2471     TextField<String> minParentMPlusH = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_PARENT_M_PLUS_H);
    2472     minParentMPlusH.setHidden(fieldsHidden);
    2473     minParentMPlusH.setDisabled(fieldsDisabled);
    2474     minParentMPlusH.setValue(xTandemParameterSet
    2475       .getSpectrumMinimumParentMPlusH());
    2476     fs.add(minParentMPlusH);
    2477     // Spectrum, maximum parent m+h
    2478     TextField<String> maxParentMPlusH = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MAX_PARENT_M_PLUS_H);
    2479     maxParentMPlusH.setHidden(fieldsHidden);
    2480     maxParentMPlusH.setDisabled(fieldsDisabled);
    2481     maxParentMPlusH.setValue(xTandemParameterSet
    2482       .getSpectrumMaximumParentMPlusH());
    2483     fs.add(maxParentMPlusH);
    2484     // Spectrum, minimum fragment mz
    2485     TextField<String> minFragmentMz = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_FRAG_MZ);
    2486     minFragmentMz.setHidden(fieldsHidden);
    2487     minFragmentMz.setDisabled(fieldsDisabled);
    2488     minFragmentMz.setValue(xTandemParameterSet
    2489       .getSpectrumMinimumFragmentMz());
    2490     fs.add(minFragmentMz);
    2491     // Spectrum, minimum peaks
    2492     TextField<String> minPeaks = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_PEAKS);
    2493     minPeaks.setHidden(fieldsHidden);
    2494     minPeaks.setDisabled(fieldsDisabled);
    2495     minPeaks.setValue(xTandemParameterSet.getSpectrumMinimumPeaks());
    2496     fs.add(minPeaks);
    2497     // Spectrum, threads
    2498     TextField<String> threads = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_THREADS);
    2499     threads.setHidden(fieldsHidden);
    2500     threads.setDisabled(fieldsDisabled);
    2501     threads.setValue(xTandemParameterSet.getSpectrumThreads());
    2502     fs.add(threads);
    2503     // Spectrum, sequence batch size
    2504     TextField<String> spectrumSequenceBatchSize = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_SEQUENCE_BATCH_SIZE);
    2505     spectrumSequenceBatchSize.setHidden(fieldsHidden);
    2506     spectrumSequenceBatchSize.setDisabled(fieldsDisabled);
    2507     spectrumSequenceBatchSize.setValue(xTandemParameterSet
    2508       .getSpectrumSequenceBatchSize());
    2509     fs.add(spectrumSequenceBatchSize);
    2510     // Return Fieldset with added fields
    2511     return fs;
    2512   }
    2513 
    2514 
    2515   /**
    2516    * Convenience method for adding XTandemParameterSet residue fields to a
    2517    * Fieldset.
    2518    *
    2519    * @param xTandemParameterSet XTandemParameterSet object (need not be stored
    2520    *        in database) with default field values.
    2521    * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
    2522    * @param fieldsHidden boolean Flag indicating that added fields should be
    2523    *        hidden.
    2524    * @param fieldsDisabled boolean Flag indicating that added fields should be
    2525    *        disabled.
    2526    * @return Fieldset The input fieldset with added XTandemParameterSet
    2527    *         fields.
    2528    */
    2529   public Fieldset addXTandemParameterSetResidueFieldsToFieldset(
    2530       XTandemParameterSet xTandemParameterSet, Fieldset fs,
    2531       boolean fieldsHidden, boolean fieldsDisabled)
    2532   {
    2533     // Residue, modification mass
    2534     TextField<String> modificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_MODIFICATION_MASS);
    2535     modificationMass.setHidden(fieldsHidden);
    2536     modificationMass.setDisabled(fieldsDisabled);
    2537     modificationMass.setValue(xTandemParameterSet
    2538       .getResidueModificationMass());
    2539     fs.add(modificationMass);
    2540     // Residue, potential modification mass
    2541     TextField<String> potentialModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MASS);
    2542     potentialModificationMass.setHidden(fieldsHidden);
    2543     potentialModificationMass.setDisabled(fieldsDisabled);
    2544     potentialModificationMass.setValue(xTandemParameterSet
    2545       .getResiduePotentialModificationMass());
    2546     fs.add(potentialModificationMass);
    2547     // Residue, potential modification motif
    2548     TextField<String> potentialModificationMotif = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MOTIF);
    2549     potentialModificationMotif.setHidden(fieldsHidden);
    2550     potentialModificationMotif.setDisabled(fieldsDisabled);
    2551     potentialModificationMotif.setValue(xTandemParameterSet
    2552       .getResiduePotentialModificationMotif());
    2553     fs.add(potentialModificationMotif);
    2554     // Return Fieldset with added fields
    2555     return fs;
    2556   }
    2557 
    2558 
    2559   /**
    2560    * Convenience method for adding XTandemParameterSet protein fields to a
    2561    * Fieldset.
    2562    *
    2563    * @param xTandemParameterSet XTandemParameterSet object (need not be stored
    2564    *        in database) with default field values.
    2565    * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
    2566    * @param fieldsHidden boolean Flag indicating that added fields should be
    2567    *        hidden.
    2568    * @param fieldsDisabled boolean Flag indicating that added fields should be
    2569    *        disabled.
    2570    * @return Fieldset The input fieldset with added XTandemParameterSet
    2571    *         fields.
    2572    */
    2573   public Fieldset addXTandemParameterSetProteinFieldsToFieldset(
    2574       XTandemParameterSet xTandemParameterSet, Fieldset fs,
    2575       boolean fieldsHidden, boolean fieldsDisabled)
    2576   {
    2577     // Protein, taxon
    2578     TextField<String> taxon = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_TAXON);
    2579     taxon.setHidden(fieldsHidden);
    2580     taxon.setDisabled(fieldsDisabled);
    2581     taxon.setValue(xTandemParameterSet.getProteinTaxon());
    2582     fs.add(taxon);
    2583     // Protein, cleavage site
    2584     TextField<String> cleavageSite = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_SITE);
    2585     cleavageSite.setHidden(fieldsHidden);
    2586     cleavageSite.setDisabled(fieldsDisabled);
    2587     cleavageSite.setValue(xTandemParameterSet.getProteinCleavageSite());
    2588     fs.add(cleavageSite);
    2589     // Protein, modified residue mass file
    2590     TextField<String> proteinModifiedResidueMassFile = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_MODIFIED_RESIDUE_MASS_FILE);
    2591     proteinModifiedResidueMassFile.setHidden(fieldsHidden);
    2592     proteinModifiedResidueMassFile.setDisabled(fieldsDisabled);
    2593     proteinModifiedResidueMassFile.setValue(xTandemParameterSet
    2594       .getProteinModifiedResidueMassFile());
    2595     fs.add(proteinModifiedResidueMassFile);
    2596     // Protein, cleavage N-terminal mass change
    2597     TextField<String> proteinCleavageNTerminalMassChange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_N_TERMINAL_MASS_CHANGE);
    2598     proteinCleavageNTerminalMassChange.setHidden(fieldsHidden);
    2599     proteinCleavageNTerminalMassChange.setDisabled(fieldsDisabled);
    2600     proteinCleavageNTerminalMassChange.setValue(xTandemParameterSet
    2601       .getProteinCleavageNTerminalMassChange());
    2602     fs.add(proteinCleavageNTerminalMassChange);
    2603     // Protein, cleavage C-terminal mass change
    2604     TextField<String> proteinCleavageCTerminalMassChange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_C_TERMINAL_MASS_CHANGE);
    2605     proteinCleavageCTerminalMassChange.setHidden(fieldsHidden);
    2606     proteinCleavageCTerminalMassChange.setDisabled(fieldsDisabled);
    2607     proteinCleavageCTerminalMassChange.setValue(xTandemParameterSet
    2608       .getProteinCleavageCTerminalMassChange());
    2609     fs.add(proteinCleavageCTerminalMassChange);
    2610     // Protein, N-terminal residue modification mass
    2611     TextField<String> nTerminalResidueModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_N_TERMINAL_RESIDUE_MODIFICATION_MASS);
    2612     nTerminalResidueModificationMass.setHidden(fieldsHidden);
    2613     nTerminalResidueModificationMass.setDisabled(fieldsDisabled);
    2614     nTerminalResidueModificationMass.setValue(xTandemParameterSet
    2615       .getProteinNTerminalResidueModificationMass());
    2616     fs.add(nTerminalResidueModificationMass);
    2617     // Protein, C-terminal residue modification mass
    2618     TextField<String> cTerminalResidueModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_C_TERMINAL_RESIDUE_MODIFICATION_MASS);
    2619     cTerminalResidueModificationMass.setHidden(fieldsHidden);
    2620     cTerminalResidueModificationMass.setDisabled(fieldsDisabled);
    2621     cTerminalResidueModificationMass.setValue(xTandemParameterSet
    2622       .getProteinCTerminalResidueModificationMass());
    2623     fs.add(cTerminalResidueModificationMass);
    2624     // Protein, homolog management
    2625     TextField<String> homologManagement = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_HOMOLOG_MANAGEMENT);
    2626     homologManagement.setHidden(fieldsHidden);
    2627     homologManagement.setDisabled(fieldsDisabled);
    2628     homologManagement.setValue(xTandemParameterSet
    2629       .getProteinHomologManagement());
    2630     fs.add(homologManagement);
    2631     // Return Fieldset with added fields
    2632     return fs;
    2633   }
    2634 
    2635 
    2636   /**
    2637    * Convenience method for adding XTandemParameterSet refine fields to a
    2638    * Fieldset.
    2639    *
    2640    * @param xTandemParameterSet XTandemParameterSet object (need not be stored
    2641    *        in database) with default field values.
    2642    * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
    2643    * @param fieldsHidden boolean Flag indicating that added fields should be
    2644    *        hidden.
    2645    * @param fieldsDisabled boolean Flag indicating that added fields should be
    2646    *        disabled.
    2647    * @return Fieldset The input fieldset with added XTandemParameterSet
    2648    *         fields.
    2649    */
    2650   public Fieldset addXTandemParameterSetRefineFieldsToFieldset(
    2651       XTandemParameterSet xTandemParameterSet, Fieldset fs,
    2652       boolean fieldsHidden, boolean fieldsDisabled)
    2653   {
    2654     // Refine
    2655     TextField<String> refine = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE);
    2656     refine.setHidden(fieldsHidden);
    2657     refine.setDisabled(fieldsDisabled);
    2658     refine.setValue(xTandemParameterSet.getRefine());
    2659     fs.add(refine);
    2660     // Refine, modification mass
    2661     TextField<String> refineModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_MODIFICATION_MASS);
    2662     refineModificationMass.setHidden(fieldsHidden);
    2663     refineModificationMass.setDisabled(fieldsDisabled);
    2664     refineModificationMass.setValue(xTandemParameterSet
    2665       .getRefineModificationMass());
    2666     fs.add(refineModificationMass);
    2667     // Refine, sequence path
    2668     TextField<String> refineSequencePath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_SEQUENCE_PATH);
    2669     refineSequencePath.setHidden(fieldsHidden);
    2670     refineSequencePath.setDisabled(fieldsDisabled);
    2671     refineSequencePath
    2672       .setValue(xTandemParameterSet.getRefineSequencePath());
    2673     fs.add(refineSequencePath);
    2674     // Refine, tic percent
    2675     TextField<String> refineTicPercent = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_TIC_PERCENT);
    2676     refineTicPercent.setHidden(fieldsHidden);
    2677     refineTicPercent.setDisabled(fieldsDisabled);
    2678     refineTicPercent.setValue(xTandemParameterSet.getRefineTicPercent());
    2679     fs.add(refineTicPercent);
    2680     // Refine, spectrum synthesis
    2681     TextField<String> spectrumSynthesis = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_SPECTRUM_SYNTHESIS);
    2682     spectrumSynthesis.setHidden(fieldsHidden);
    2683     spectrumSynthesis.setDisabled(fieldsDisabled);
    2684     spectrumSynthesis.setValue(xTandemParameterSet
    2685       .getRefineSpectrumSynthesis());
    2686     fs.add(spectrumSynthesis);
    2687     // Refine, maximum valid expectation value
    2688     TextField<String> maxValidExpectationValue = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_MAX_VALID_EXPECTATION_VALUE);
    2689     maxValidExpectationValue.setHidden(fieldsHidden);
    2690     maxValidExpectationValue.setDisabled(fieldsDisabled);
    2691     maxValidExpectationValue.setValue(xTandemParameterSet
    2692       .getRefineMaximumValidExpectationValue());
    2693     fs.add(maxValidExpectationValue);
    2694     // Refine, potential N-terminus modifications
    2695     TextField<String> potentialNTerminusModifications = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_N_TERMINUS_MODIFICATIONS);
    2696     potentialNTerminusModifications.setHidden(fieldsHidden);
    2697     potentialNTerminusModifications.setDisabled(fieldsDisabled);
    2698     potentialNTerminusModifications.setValue(xTandemParameterSet
    2699       .getRefinePotentialNTerminusModifications());
    2700     fs.add(potentialNTerminusModifications);
    2701     // Refine, potential C-terminus modifications
    2702     TextField<String> potentialCTerminusModifications = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_C_TERMINUS_MODIFICATIONS);
    2703     potentialCTerminusModifications.setHidden(fieldsHidden);
    2704     potentialCTerminusModifications.setDisabled(fieldsDisabled);
    2705     potentialCTerminusModifications.setValue(xTandemParameterSet
    2706       .getRefinePotentialCTerminusModifications());
    2707     fs.add(potentialCTerminusModifications);
    2708     // Refine, unanticipated cleavage
    2709     TextField<String> unanticipatedCleavage = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_UNANTICIPATED_CLEAVAGE);
    2710     unanticipatedCleavage.setHidden(fieldsHidden);
    2711     unanticipatedCleavage.setDisabled(fieldsDisabled);
    2712     unanticipatedCleavage.setValue(xTandemParameterSet
    2713       .getRefineUnanticipatedCleavage());
    2714     fs.add(unanticipatedCleavage);
    2715     // Refine, potential modification mass
    2716     TextField<String> refinePotentialModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MASS);
    2717     refinePotentialModificationMass.setHidden(fieldsHidden);
    2718     refinePotentialModificationMass.setDisabled(fieldsDisabled);
    2719     refinePotentialModificationMass.setValue(xTandemParameterSet
    2720       .getRefinePotentialModificationMass());
    2721     fs.add(refinePotentialModificationMass);
    2722     // Refine, point mutations
    2723     TextField<String> pointMutations = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POINT_MUTATIONS);
    2724     pointMutations.setHidden(fieldsHidden);
    2725     pointMutations.setDisabled(fieldsDisabled);
    2726     pointMutations.setValue(xTandemParameterSet.getRefinePointMutations());
    2727     fs.add(pointMutations);
    2728     // Refine, use potential modifications for full refinement
    2729     TextField<String> usePotentialModificationsForFullRefinement = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_USE_POTENTIAL_MODIFICATIONS_FOR_FULL_REFINEMENT);
    2730     usePotentialModificationsForFullRefinement.setHidden(fieldsHidden);
    2731     usePotentialModificationsForFullRefinement.setDisabled(fieldsDisabled);
    2732     usePotentialModificationsForFullRefinement.setValue(xTandemParameterSet
    2733       .getRefineUsePotentialModificationsForFullRefinement());
    2734     fs.add(usePotentialModificationsForFullRefinement);
    2735     // Refine, potential modification motif
    2736     TextField<String> potentialModificationMotifRefine = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MOTIF);
    2737     potentialModificationMotifRefine.setHidden(fieldsHidden);
    2738     potentialModificationMotifRefine.setDisabled(fieldsDisabled);
    2739     potentialModificationMotifRefine.setValue(xTandemParameterSet
    2740       .getRefinePotentialModificationMotif());
    2741     fs.add(potentialModificationMotifRefine);
    2742     // Return Fieldset with added fields
    2743     return fs;
    2744   }
    2745 
    2746 
    2747   /**
    2748    * Convenience method for adding XTandemParameterSet scoring fields to a
    2749    * Fieldset.
    2750    *
    2751    * @param xTandemParameterSet XTandemParameterSet object (need not be stored
    2752    *        in database) with default field values.
    2753    * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
    2754    * @param fieldsHidden boolean Flag indicating that added fields should be
    2755    *        hidden.
    2756    * @param fieldsDisabled boolean Flag indicating that added fields should be
    2757    *        disabled.
    2758    * @return Fieldset The input fieldset with added XTandemParameterSet
    2759    *         fields.
    2760    */
    2761   public Fieldset addXTandemParameterSetScoringFieldsToFieldset(
    2762       XTandemParameterSet xTandemParameterSet, Fieldset fs,
    2763       boolean fieldsHidden, boolean fieldsDisabled)
    2764   {
    2765     // Scoring, minimum ion count
    2766     TextField<String> minIonCount = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_MIN_ION_COUNT);
    2767     minIonCount.setHidden(fieldsHidden);
    2768     minIonCount.setDisabled(fieldsDisabled);
    2769     minIonCount.setValue(xTandemParameterSet.getScoringMinimumIonCount());
    2770     fs.add(minIonCount);
    2771     // Scoring, maximum missed cleavage sites
    2772     TextField<String> maxMissedCleavageSites = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_MAX_MISSED_CLEAVAGE_SITES);
    2773     maxMissedCleavageSites.setHidden(fieldsHidden);
    2774     maxMissedCleavageSites.setDisabled(fieldsDisabled);
    2775     maxMissedCleavageSites.setValue(xTandemParameterSet
    2776       .getScoringMaximumMissedCleavageSites());
    2777     fs.add(maxMissedCleavageSites);
    2778     // Scoring, x ions
    2779     TextField<String> xIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_X_IONS);
    2780     xIons.setHidden(fieldsHidden);
    2781     xIons.setDisabled(fieldsDisabled);
    2782     xIons.setValue(xTandemParameterSet.getScoringXIons());
    2783     fs.add(xIons);
    2784     // Scoring, y ions
    2785     TextField<String> yIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_Y_IONS);
    2786     yIons.setHidden(fieldsHidden);
    2787     yIons.setDisabled(fieldsDisabled);
    2788     yIons.setValue(xTandemParameterSet.getScoringYIons());
    2789     fs.add(yIons);
    2790     // Scoring, z ions
    2791     TextField<String> zIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_Z_IONS);
    2792     zIons.setHidden(fieldsHidden);
    2793     zIons.setDisabled(fieldsDisabled);
    2794     zIons.setValue(xTandemParameterSet.getScoringZIons());
    2795     fs.add(zIons);
    2796     // Scoring, a ions
    2797     TextField<String> aIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_A_IONS);
    2798     aIons.setHidden(fieldsHidden);
    2799     aIons.setDisabled(fieldsDisabled);
    2800     aIons.setValue(xTandemParameterSet.getScoringAIons());
    2801     fs.add(aIons);
    2802     // Scoring, b ions
    2803     TextField<String> bIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_B_IONS);
    2804     bIons.setHidden(fieldsHidden);
    2805     bIons.setDisabled(fieldsDisabled);
    2806     bIons.setValue(xTandemParameterSet.getScoringBIons());
    2807     fs.add(bIons);
    2808     // Scoring, c ions
    2809     TextField<String> cIons = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_C_IONS);
    2810     cIons.setHidden(fieldsHidden);
    2811     cIons.setDisabled(fieldsDisabled);
    2812     cIons.setValue(xTandemParameterSet.getScoringCIons());
    2813     fs.add(cIons);
    2814     // Scoring, cyclic permutation
    2815     TextField<String> cyclicPermutation = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_CYCLIC_PERMUTATION);
    2816     cyclicPermutation.setHidden(fieldsHidden);
    2817     cyclicPermutation.setDisabled(fieldsDisabled);
    2818     cyclicPermutation.setValue(xTandemParameterSet
    2819       .getScoringCyclicPermutation());
    2820     fs.add(cyclicPermutation);
    2821     // Scoring, include reverse
    2822     TextField<String> includeReverse = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_INCLUDE_REVERSE);
    2823     includeReverse.setHidden(fieldsHidden);
    2824     includeReverse.setDisabled(fieldsDisabled);
    2825     includeReverse.setValue(xTandemParameterSet.getScoringIncludeReverse());
    2826     fs.add(includeReverse);
    2827     // Scoring, algorithm
    2828     TextField<String> algorithm = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_ALGORITHM);
    2829     algorithm.setHidden(fieldsHidden);
    2830     algorithm.setDisabled(fieldsDisabled);
    2831     algorithm.setValue(xTandemParameterSet.getScoringAlgorithm());
    2832     fs.add(algorithm);
    2833     // Return Fieldset with added fields
    2834     return fs;
    2835   }
    2836 
    2837 
    2838   /**
    2839    * Convenience method for adding XTandemParameterSet output fields to a
    2840    * Fieldset.
    2841    *
    2842    * @param xTandemParameterSet XTandemParameterSet object (need not be stored
    2843    *        in database) with default field values.
    2844    * @param fs Fieldset The Fieldset to add the XTandemParameterSet fields to.
    2845    * @param fieldsHidden boolean Flag indicating that added fields should be
    2846    *        hidden.
    2847    * @param fieldsDisabled boolean Flag indicating that added fields should be
    2848    *        disabled.
    2849    * @return Fieldset The input fieldset with added XTandemParameterSet
    2850    *         fields.
    2851    */
    2852   public Fieldset addXTandemParameterSetOutputFieldsToFieldset(
    2853       XTandemParameterSet xTandemParameterSet, Fieldset fs,
    2854       boolean fieldsHidden, boolean fieldsDisabled)
    2855   {
    2856     // Output, path
    2857     TextField<String> outputPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PATH);
    2858     outputPath.setHidden(fieldsHidden);
    2859     outputPath.setDisabled(fieldsDisabled);
    2860     outputPath.setValue(xTandemParameterSet.getOutputPath());
    2861     fs.add(outputPath);
    2862     // Output, log path
    2863     TextField<String> outputLogPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_LOG_PATH);
    2864     outputLogPath.setHidden(fieldsHidden);
    2865     outputLogPath.setDisabled(fieldsDisabled);
    2866     outputLogPath.setValue(xTandemParameterSet.getOutputLogPath());
    2867     fs.add(outputLogPath);
    2868     // Output, message
    2869     TextField<String> outputMessage = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_MESSAGE);
    2870     outputMessage.setHidden(fieldsHidden);
    2871     outputMessage.setDisabled(fieldsDisabled);
    2872     outputMessage.setValue(xTandemParameterSet.getOutputMessage());
    2873     fs.add(outputMessage);
    2874     // Output, sequence path
    2875     TextField<String> outputSequencePath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SEQUENCE_PATH);
    2876     outputSequencePath.setHidden(fieldsHidden);
    2877     outputSequencePath.setDisabled(fieldsDisabled);
    2878     outputSequencePath
    2879       .setValue(xTandemParameterSet.getOutputSequencePath());
    2880     fs.add(outputSequencePath);
    2881     // Output, sort results by
    2882     TextField<String> outputSortResultsBy = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SORT_RESULTS_BY);
    2883     outputSortResultsBy.setHidden(fieldsHidden);
    2884     outputSortResultsBy.setDisabled(fieldsDisabled);
    2885     outputSortResultsBy.setValue(xTandemParameterSet
    2886       .getOutputSortResultsBy());
    2887     fs.add(outputSortResultsBy);
    2888     // Output, path hashing
    2889     TextField<String> pathHashing = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PATH_HASHING);
    2890     pathHashing.setHidden(fieldsHidden);
    2891     pathHashing.setDisabled(fieldsDisabled);
    2892     pathHashing.setValue(xTandemParameterSet.getOutputPathHashing());
    2893     fs.add(pathHashing);
    2894     // Output, xsl path
    2895     TextField<String> xslPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_XSL_PATH);
    2896     xslPath.setHidden(fieldsHidden);
    2897     xslPath.setDisabled(fieldsDisabled);
    2898     xslPath.setValue(xTandemParameterSet.getOutputXslPath());
    2899     fs.add(xslPath);
    2900     // Output, parameters
    2901     TextField<String> parameters = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PARAMETERS);
    2902     parameters.setHidden(fieldsHidden);
    2903     parameters.setDisabled(fieldsDisabled);
    2904     parameters.setValue(xTandemParameterSet.getOutputParameters());
    2905     fs.add(parameters);
    2906     // Output, performance
    2907     TextField<String> performance = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PERFORMANCE);
    2908     performance.setHidden(fieldsHidden);
    2909     performance.setDisabled(fieldsDisabled);
    2910     performance.setValue(xTandemParameterSet.getOutputPerformance());
    2911     fs.add(performance);
    2912     // Output, spectra
    2913     TextField<String> spectra = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SPECTRA);
    2914     spectra.setValue(xTandemParameterSet.getOutputSpectra());
    2915     spectra.setHidden(fieldsHidden);
    2916     spectra.setDisabled(fieldsDisabled);
    2917     fs.add(spectra);
    2918     // Output, histograms
    2919     TextField<String> histograms = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_HISTOGRAMS);
    2920     histograms.setHidden(fieldsHidden);
    2921     histograms.setDisabled(fieldsDisabled);
    2922     histograms.setValue(xTandemParameterSet.getOutputHistograms());
    2923     fs.add(histograms);
    2924     // Output, proteins
    2925     TextField<String> proteins = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PROTEINS);
    2926     proteins.setHidden(fieldsHidden);
    2927     proteins.setDisabled(fieldsDisabled);
    2928     proteins.setValue(xTandemParameterSet.getOutputProteins());
    2929     fs.add(proteins);
    2930     // Output, sequences
    2931     TextField<String> sequences = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SEQUENCES);
    2932     sequences.setHidden(fieldsHidden);
    2933     sequences.setDisabled(fieldsDisabled);
    2934     sequences.setValue(xTandemParameterSet.getOutputSequences());
    2935     fs.add(sequences);
    2936     // Output, one sequence copy
    2937     TextField<String> oneSequenceCopy = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_ONE_SEQUENCE_COPY);
    2938     oneSequenceCopy.setHidden(fieldsHidden);
    2939     oneSequenceCopy.setDisabled(fieldsDisabled);
    2940     oneSequenceCopy
    2941       .setValue(xTandemParameterSet.getOutputOneSequenceCopy());
    2942     fs.add(oneSequenceCopy);
    2943     // Output, results
    2944     TextField<String> results = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_RESULTS);
    2945     results.setHidden(fieldsHidden);
    2946     results.setDisabled(fieldsDisabled);
    2947     results.setValue(xTandemParameterSet.getOutputResults());
    2948     fs.add(results);
    2949     // Output, maximum valid expectation value
    2950     TextField<String> outputMaxValidExpectationValue = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_MAX_VALID_EXPECTATION_VALUE);
    2951     outputMaxValidExpectationValue.setHidden(fieldsHidden);
    2952     outputMaxValidExpectationValue.setDisabled(fieldsDisabled);
    2953     outputMaxValidExpectationValue.setValue(xTandemParameterSet
    2954       .getOutputMaximumValidExpectationValue());
    2955     fs.add(outputMaxValidExpectationValue);
    2956     // Output, histogram column width
    2957     TextField<String> histogramColumnWidth = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_HISTOGRAM_COLUMN_WIDTH);
    2958     histogramColumnWidth.setHidden(fieldsHidden);
    2959     histogramColumnWidth.setDisabled(fieldsDisabled);
    2960     histogramColumnWidth.setValue(xTandemParameterSet
    2961       .getOutputHistogramColumnWidth());
    2962     fs.add(histogramColumnWidth);
    2963     // Return Fieldset with added fields
    2964     return fs;
    2965   }
    2966 
    2967 
    2968   public Form getXTandemParameterSetForm(
    2969       XTandemParameterSet xTandemParameterSet,
    2970       List<Option> listPathDefaultParametersOptionList,
    2971       List<Option> speciesOptionList, List<Option> proSpeciesOptionList,
    2972       List<Option> residueModificationMassOptionList,
    2973       List<Option> residuePotentialModificationMassOptionList,
    2974       List<Option> proteinCleavageSiteOptionList,
    2975       List<Option> refinePotentialModificationMassOptionList)
    2976   {
    2977     // DbControl dc = project.getDbControl();
    2978     Form form = new Form("XTandemParameterSetForm");
    2979     /*
    2980      * String select box variables
    2981      */
    2982     VString validStringParam = null;
    2983     List<String> stringList = null;
    2984     List<Option> optionList = null;
    2985     String selected = null;
    2986     List<String> selectedList = null;
    2987     /*
    2988      * List path field set
    2989      */
    2990     Fieldset listPathFS = new Fieldset();
    2991     listPathFS.setTitle("XTandemParameterSetListPath");
    2992     form.addFieldset(listPathFS);
    2993     // List path, default parameters
    2994     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_LIST_PATH_DEFAULT_PARAMETERS;
    2995     optionList = new ArrayList<Option>();
    2996     optionList.add(new Option("/tandem/methods/fticr.xml", "FTICR (10 ppm)"));
    2997     optionList.add(new Option("/tandem/methods/qstar.xml",  "Quad-TOF (100 ppm)"));
    2998     optionList.add(new Option("/tandem/methods/qstar_l.xml",  "Quad-TOF (0.5 Da)"));
    2999     optionList.add(new Option("/tandem/methods/iontrap.xml",  "Ion Trap (4 Da)"));
    3000     // Use input list path default parameters option list if present
    3001     if (listPathDefaultParametersOptionList != null && listPathDefaultParametersOptionList.size() > 0)
    3002     {
    3003       optionList = listPathDefaultParametersOptionList;
    3004     }
    3005     selected = xTandemParameterSet.getListPathDefaultParameters();
    3006     Select<VString> listPathDefaultParametersSelectBox = new Select<VString>(validStringParam, optionList);
    3007   listPathDefaultParametersSelectBox.selectOption( selected);
    3008     listPathDefaultParametersSelectBox.setLabel("XTandemListPathDefaultParameters");
    3009     listPathDefaultParametersSelectBox.setMultiple(false);
    3010     int selectBoxSize = 4;
    3011     if (optionList.size() < selectBoxSize)
    3012     {
    3013       selectBoxSize = optionList.size();
    3014     }
    3015     listPathDefaultParametersSelectBox.setSize(selectBoxSize);
    3016     listPathFS.add(listPathDefaultParametersSelectBox);
    3017     // List path, taxonomy information
    3018     TextField<String> taxonomyInformationListPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_LIST_PATH_TAXONOMY_INFORMATION);
    3019     taxonomyInformationListPath.setValue(xTandemParameterSet
    3020       .getListPathTaxonomyInformation());
    3021     listPathFS.add(taxonomyInformationListPath);
    3022     /*
    3023      * Spectrum field set
    3024      */
    3025     Fieldset spectrumFS = new Fieldset();
    3026     spectrumFS.setTitle("XTandemParameterSetSpectrum");
    3027     form.addFieldset(spectrumFS);
    3028     // Spectrum, path
    3029     TextField<String> spectrumPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PATH);
    3030     spectrumPath.setValue(xTandemParameterSet.getSpectrumPath());
    3031     spectrumFS.add(spectrumPath);
    3032     // Spectrum, fragment monoisotopic mass error
    3033     TextField<String> fragMiMassError = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MI_MASS_ERROR);
    3034     fragMiMassError.setValue(xTandemParameterSet
    3035       .getSpectrumFragmentMonoisotopicMassError());
    3036     spectrumFS.add(fragMiMassError);
    3037     // Spectrum, parent monoisotopic mass error plus
    3038     TextField<String> parentMiMassErrorPlus = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_PLUS);
    3039     parentMiMassErrorPlus.setValue(xTandemParameterSet
    3040       .getSpectrumParentMonoisotopicMassErrorPlus());
    3041     spectrumFS.add(parentMiMassErrorPlus);
    3042     // Spectrum, parent monoisotopic mass error minus
    3043     TextField<String> parentMiMassErrorMinus = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_MINUS);
    3044     parentMiMassErrorMinus.setValue(xTandemParameterSet
    3045       .getSpectrumParentMonoisotopicMassErrorMinus());
    3046     spectrumFS.add(parentMiMassErrorMinus);
    3047     // Spectrum, parent monoisotopic mass isotope error
    3048     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ISOTOPE_ERROR;
    3049     stringList = new ArrayList<String>();
    3050     stringList.add("yes");
    3051     stringList.add("no");
    3052     selected = xTandemParameterSet
    3053       .getSpectrumParentMonoisotopicMassIsotopeError();
    3054     Select<VString> parentMiMassIsotopeError = new Select<VString>(validStringParam, stringList, selected);
    3055     spectrumFS.add(parentMiMassIsotopeError);
    3056     // Spectrum, fragment monoisotopic mass error units
    3057     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MI_MASS_ERROR_UNITS;
    3058     stringList = new ArrayList<String>();
    3059     stringList.add("Daltons");
    3060     stringList.add("ppm");
    3061     selected = xTandemParameterSet
    3062       .getSpectrumFragmentMonoisotopicMassErrorUnits();
    3063     Select<VString> fragMiMassErrorUnits = new Select<VString>(validStringParam, stringList, selected);
    3064     spectrumFS.add(fragMiMassErrorUnits);
    3065     // Spectrum, parent monoisotopic mass error units
    3066     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_PARENT_MI_MASS_ERROR_UNITS;
    3067     stringList = new ArrayList<String>();
    3068     stringList.add("Daltons");
    3069     stringList.add("ppm");
    3070     selected = xTandemParameterSet
    3071       .getSpectrumParentMonoisotopicMassErrorUnits();
    3072     Select<VString> parentMiMassErrorUnits = new Select<VString>(validStringParam, stringList, selected);
    3073     spectrumFS.add(parentMiMassErrorUnits);
    3074     // Spectrum, fragment mass type
    3075     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_FRAG_MASS_TYPE;
    3076     stringList = new ArrayList<String>();
    3077     stringList.add("monoisotopic");
    3078     stringList.add("average");
    3079     selected = xTandemParameterSet.getSpectrumFragmentMassType();
    3080     Select<VString> fragMassType = new Select<VString>(validStringParam,  stringList, selected);
    3081     spectrumFS.add(fragMassType);
    3082     // Spectrum, dynamic range
    3083     TextField<String> dynamicRange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_DYNAMIC_RANGE);
    3084     dynamicRange.setValue(xTandemParameterSet.getSpectrumDynamicRange());
    3085     spectrumFS.add(dynamicRange);
    3086     // Spectrum, total peaks
    3087     TextField<String> totalPeaks = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_TOTAL_PEAKS);
    3088     totalPeaks.setValue(xTandemParameterSet.getSpectrumTotalPeaks());
    3089     spectrumFS.add(totalPeaks);
    3090     // Spectrum, maximum parent charge
    3091     TextField<String> maxParentCharge = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MAX_PARENT_CHARGE);
    3092     maxParentCharge.setValue(xTandemParameterSet
    3093       .getSpectrumMaximumParentCharge());
    3094     spectrumFS.add(maxParentCharge);
    3095     // Spectrum, use noise suppression
    3096     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_USE_NOISE_SUPPRESSION;
    3097     stringList = new ArrayList<String>();
    3098     stringList.add("yes");
    3099     stringList.add("no");
    3100     selected = xTandemParameterSet.getSpectrumUseNoiseSuppression();
    3101     Select<VString> useNoiseSuppression = new Select<VString>(validStringParam, stringList, selected);
    3102     spectrumFS.add(useNoiseSuppression);
    3103     // Spectrum, minimum parent m+h
    3104     TextField<String> minParentMPlusH = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_PARENT_M_PLUS_H);
    3105     minParentMPlusH.setValue(xTandemParameterSet
    3106       .getSpectrumMinimumParentMPlusH());
    3107     spectrumFS.add(minParentMPlusH);
    3108     // Spectrum, maximum parent m+h
    3109     TextField<String> maxParentMPlusH = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MAX_PARENT_M_PLUS_H);
    3110     maxParentMPlusH.setValue(xTandemParameterSet
    3111       .getSpectrumMaximumParentMPlusH());
    3112     spectrumFS.add(maxParentMPlusH);
    3113     // Spectrum, minimum fragment mz
    3114     TextField<String> minFragmentMz = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_FRAG_MZ);
    3115     minFragmentMz.setValue(xTandemParameterSet
    3116       .getSpectrumMinimumFragmentMz());
    3117     spectrumFS.add(minFragmentMz);
    3118     // Spectrum, minimum peaks
    3119     TextField<String> minPeaks = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_MIN_PEAKS);
    3120     minPeaks.setValue(xTandemParameterSet.getSpectrumMinimumPeaks());
    3121     spectrumFS.add(minPeaks);
    3122     // Spectrum, threads
    3123     TextField<String> threads = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_THREADS);
    3124     threads.setValue(xTandemParameterSet.getSpectrumThreads());
    3125     spectrumFS.add(threads);
    3126     // Spectrum, sequence batch size
    3127     TextField<String> spectrumSequenceBatchSize = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SPECTRUM_SEQUENCE_BATCH_SIZE);
    3128     spectrumSequenceBatchSize.setValue(xTandemParameterSet
    3129       .getSpectrumSequenceBatchSize());
    3130     spectrumFS.add(spectrumSequenceBatchSize);
    3131     /*
    3132      * Residue field set
    3133      */
    3134     Fieldset residueFS = new Fieldset();
    3135     residueFS.setTitle("XTandemParameterSetResidue");
    3136     form.addFieldset(residueFS);
    3137     // Residue, modification mass select
    3138     /*
    3139      * Residue modification mass selection has one peculiarity: 1. The GUI
    3140      * selection is divided into one selection box and an entry field. A
    3141      * selection in the selection box will only be used if the entry field
    3142      * is empty.
    3143      */
    3144     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_MODIFICATION_MASS_SELECT;
    3145     optionList = new ArrayList<Option>();
    3146     optionList.add(new Option("", "none"));
    3147     optionList.add(new Option("57.021464@C", "Carbamidomethyl (C)"));
    3148     optionList.add(new Option("442.224991@C", "ICAT-D (C)"));
    3149     optionList.add(new Option("227.126991@C", "ICAT-C (C)"));
    3150     optionList.add(new Option("58.005479@C", "Carboxymethyl (C)"));
    3151     optionList.add(new Option("105.057849@C", "Pyridylethyl (C)"));
    3152     optionList.add(new Option("71.037114@C", "Propionamide (C)"));
    3153     optionList.add(new Option("144.102063@[,144.102063@K",
    3154       "iTRAQ (N-term,K)"));
    3155     // Use input residue modification mass option list if present
    3156     if (residueModificationMassOptionList != null && residueModificationMassOptionList
    3157       .size() > 0)
    3158     {
    3159       optionList = residueModificationMassOptionList;
    3160     }
    3161     selected = xTandemParameterSet.getResidueModificationMass();
    3162     Select<VString> residueModificationMassSelectBox = new Select<VString>(
    3163       validStringParam, optionList);
    3164   residueModificationMassSelectBox.selectOption( selected);
    3165     residueModificationMassSelectBox
    3166       .setLabel("XTandemResidueModificationMassSelect");
    3167     residueFS.add(residueModificationMassSelectBox);
    3168     // Residue, modification mass (own entered value)
    3169     TextField<String> modificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_MODIFICATION_MASS);
    3170     modificationMass.setLabel("XTandemResidueModificationMassEnter");
    3171     // Only insert selected value if not found in select box
    3172     if (!itemInOptionList(optionList, selected))
    3173     {
    3174       log
    3175         .debug("residue modification mass, inserted value = \"" + xTandemParameterSet
    3176           .getResidueModificationMass() + "\"");
    3177       modificationMass.setValue(xTandemParameterSet
    3178         .getResidueModificationMass());
    3179     }
    3180     else
    3181     {
    3182 
    3183       modificationMass.setValue("");
    3184     }
    3185     log
    3186       .debug("residue modification mass, modificationMass.getValue() = \"" + modificationMass
    3187         .getValue() + "\"");
    3188     residueFS.add(modificationMass);
    3189     // Residue, potential modification mass select
    3190     /*
    3191      * Residue potential modification mass selection has two peculiarities:
    3192      * 1. It supports selection of multiple items. 2. The GUI selection is
    3193      * divided into one multiple selection box and an entry field.
    3194      * Selections in the selection box will only be used if the entry field
    3195      * is empty. The multiple selection items are stored in XML as a string
    3196      * with items separated by ", ".
    3197      */
    3198     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MASS_SELECT;
    3199     optionList = new ArrayList<Option>();
    3200     optionList.add(new Option("", "none"));
    3201     optionList.add(new Option("15.994915@M", "Oxidation (M)"));
    3202     optionList.add(new Option("15.994915@W", "Oxidation (W)"));
    3203     optionList.add(new Option("0.984016@N", "Deamidation (N)"));
    3204     optionList.add(new Option("0.984016@Q", "Deamidation (Q)"));
    3205     optionList.add(new Option("8.0502@C", "ICAT-D:2H(8) (C)"));
    3206     optionList.add(new Option("9.0302@C", "ICAT-C:13C(9) (C)"));
    3207     optionList.add(new Option("144.102063@[", "iTRAQ (N-term)"));
    3208     optionList.add(new Option("144.102063@K", "iTRAQ (K)"));
    3209     optionList.add(new Option("79.966331@S", "Phospho (S)"));
    3210     optionList.add(new Option("79.966331@T", "Phospho (T)"));
    3211     optionList.add(new Option("79.966331@Y", "Phospho (Y)"));
    3212     optionList.add(new Option("79.956815@Y", "Sulfo (Y)"));
    3213     optionList.add(new Option("42.010565@K", "Acetyl (K)"));
    3214     // Use input residue potential modification mass option list if present
    3215     if (residuePotentialModificationMassOptionList != null && residuePotentialModificationMassOptionList
    3216       .size() > 0)
    3217     {
    3218       optionList = residuePotentialModificationMassOptionList;
    3219       log
    3220         .debug("Input residue potential modification mass option list used");
    3221     }
    3222     else
    3223     {
    3224       log
    3225         .debug("Default residue potential modification mass option list used");
    3226     }
    3227     selected = xTandemParameterSet.getResiduePotentialModificationMass();
    3228     log
    3229       .debug("residue potential modification mass selected = \"" + selected + "\"");
    3230     selectedList = listStringToStringList(selected, ",");
    3231     log
    3232       .debug("residue potential modification mass selectedList = " + selectedList);
    3233     Select<VString> residuePotentialModificationMassSelectBox = new Select<VString>(
    3234       validStringParam, optionList, selectedList);
    3235     residuePotentialModificationMassSelectBox
    3236       .setLabel("XTandemResiduePotentialModificationMassSelect");
    3237     residuePotentialModificationMassSelectBox.setMultiple(true);
    3238     residuePotentialModificationMassSelectBox.setSize(4);
    3239     residueFS.add(residuePotentialModificationMassSelectBox);
    3240     // Residue, potential modification mass
    3241     TextField<String> potentialModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MASS);
    3242     potentialModificationMass
    3243       .setLabel("XTandemResiduePotentialModificationMassEnter");
    3244     potentialModificationMass.setValue(xTandemParameterSet
    3245       .getResiduePotentialModificationMass());
    3246     // Only insert selected values if not all found in select box
    3247     if (!allItemsInOptionList(optionList, selectedList))
    3248     {
    3249       log
    3250         .debug("residue potential modification mass, inserted value = \"" + xTandemParameterSet
    3251           .getResiduePotentialModificationMass() + "\"");
    3252       potentialModificationMass.setValue(xTandemParameterSet
    3253         .getResiduePotentialModificationMass());
    3254     }
    3255     else
    3256     {
    3257       potentialModificationMass.setValue("");
    3258     }
    3259     residueFS.add(potentialModificationMass);
    3260     // Residue, potential modification motif
    3261     TextField<String> potentialModificationMotif = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_RESIDUE_POTENTIAL_MODIFICATION_MOTIF);
    3262     potentialModificationMotif.setValue(xTandemParameterSet
    3263       .getResiduePotentialModificationMotif());
    3264     residueFS.add(potentialModificationMotif);
    3265     /*
    3266      * Protein field set
    3267      */
    3268     Fieldset proteinFS = new Fieldset();
    3269     proteinFS.setTitle("XTandemParameterSetProtein");
    3270     form.addFieldset(proteinFS);
    3271     // Protein, taxon
    3272     /*
    3273      * Taxonomy selection has two peculiarities: 1. It supports selection of
    3274      * multiple items. 2. The GUI selection is divided into two multiple
    3275      * selection boxes. The multiple selection items are stored in XML as a
    3276      * string with items separated by ", ".
    3277      */
    3278     // Taxon - Eukaryotes
    3279     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_TAXON;
    3280     optionList = new ArrayList<Option>();
    3281     optionList.add(new Option("", "none"));
    3282     optionList.add(new Option("human", "H. sapiens (human)"));
    3283     optionList.add(new Option("mouse", "M. musculus (mouse)"));
    3284     optionList.add(new Option("rat", "R. norvegicus (rat)"));
    3285     optionList.add(new Option("yeast", "S. cerevisiae (budding yeast)"));
    3286     optionList.add(new Option("", "------------------"));
    3287     optionList.add(new Option("mosquito", "A. gambiae (mosquito)"));
    3288     optionList.add(new Option("aspergillus_fumigatus",
    3289       "A. fumigatus (mould)"));
    3290     optionList.add(new Option("bee", "A. mellifera (honey bee)"));
    3291     optionList.add(new Option("thalecress", "A. thaliana (thale cress)"));
    3292     optionList.add(new Option("cow", "B. taurus (cow)"));
    3293     optionList.add(new Option("dog", "C. familiaris (dog)"));
    3294     optionList.add(new Option("worm", "C. elegans (round worm)"));
    3295     optionList.add(new Option("zebrafish", "D. rerio (zebra fish)"));
    3296     optionList.add(new Option("fly", "D. melanogaster (fruit fly)"));
    3297     optionList.add(new Option("chicken", "G. gallus (hen)"));
    3298     optionList.add(new Option("human", "H. sapiens (human)"));
    3299     optionList.add(new Option("mouse", "M. musculus (mouse)"));
    3300     optionList.add(new Option("rice", "O.sativa (rice)"));
    3301     optionList.add(new Option("rat", "R. norvegicus (rat)"));
    3302     optionList.add(new Option("spombe", "S. pombe (fission yeast)"));
    3303     optionList.add(new Option("yeast", "S. cerevisiae (budding yeast)"));
    3304     optionList.add(new Option("frog", "S. tropicalis (toad)"));
    3305     // Use input species option list if present
    3306     if (speciesOptionList != null && speciesOptionList.size() > 0)
    3307     {
    3308       optionList = speciesOptionList;
    3309     }
    3310     selected = xTandemParameterSet.getProteinTaxon();
    3311     selectedList = listStringToStringList(selected, ",\\ ");
    3312     Select<VString> taxon = new Select<VString>(validStringParam,
    3313       optionList, selectedList);
    3314     taxon.setLabel("XTandemProteinTaxonEukaryotes");
    3315     taxon.setMultiple(true);
    3316     taxon.setSize(5);
    3317     proteinFS.add(taxon);
    3318     // Taxon - Prokaryotes
    3319     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_TAXON1;
    3320     optionList = new ArrayList<Option>();
    3321     optionList.add(new Option("", "none"));
    3322     optionList.add(new Option("Bacillus_subtilis", "Bacillus subtilis"));
    3323     optionList.add(new Option("Clostridium_perfringens",
    3324       "Clostridium perfringens"));
    3325     optionList.add(new Option("Deinococcus_radiodurans",
    3326       "Deinococcus radiodurans"));
    3327     optionList.add(new Option("Escherichia_coli_K12",
    3328       "Escherichia coli K12"));
    3329     optionList.add(new Option("Francisella_tularensis_tularensis",
    3330       "Francisella tularensis tularensis"));
    3331     optionList.add(new Option("Geobacter_sulfurreducens",
    3332       "Geobacter sulfurreducens"));
    3333     optionList.add(new Option("Haemophilus_influenzae",
    3334       "Haemophilus influenzae"));
    3335     optionList.add(new Option("Listeria_innocua", "Listeria innocua"));
    3336     optionList.add(new Option("Mycobacterium_leprae",
    3337       "Mycobacterium leprae"));
    3338     optionList.add(new Option("Mycobacterium_tuberculosis_CDC1551",
    3339       "Mycobacterium tuberculosis CDC1551"));
    3340     optionList
    3341       .add(new Option("Mycoplasma_pulmonis", "Mycoplasma pulmonis"));
    3342     optionList.add(new Option("Staphylococcus_aureus_MW2",
    3343       "Staphylococcus aureus MW2"));
    3344     optionList.add(new Option("Streptococcus_pneumoniae_TIGR4",
    3345       "Streptococcus pneumoniae TIGR4"));
    3346     optionList.add(new Option("Streptococcus_pyogenes_M1_GAS",
    3347       "Streptococcus pyogenes M1 GAS"));
    3348     optionList.add(new Option("Yersinia_pestis_CO92",
    3349       "Yersinia pestis CO92"));
    3350     // Use input species option list if present
    3351     if (proSpeciesOptionList != null && proSpeciesOptionList.size() > 0)
    3352     {
    3353       optionList = proSpeciesOptionList;
    3354     }
    3355     // Same selection list as for Eukaryotes taxon is used for Prokaryotes
    3356     Select<VString> taxon1 = new Select<VString>(validStringParam,
    3357       optionList, selectedList);
    3358     taxon1.setLabel("XTandemProteinTaxonProkaryotes");
    3359     taxon1.setMultiple(true);
    3360     taxon1.setSize(5);
    3361     proteinFS.add(taxon1);
    3362     // Protein, cleavage site
    3363     /*
    3364      * Protein cleavage site selection has one peculiarity: 1. The GUI
    3365      * selection is divided into one selection box and an entry field. A
    3366      * selection in the selection box will only be used if the entry field
    3367      * is empty.
    3368      */
    3369     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_SITE_SELECT;
    3370     optionList = new ArrayList<Option>();
    3371     optionList.add(new Option("[RK]|{P}", "trypsin, [RK]|{P}"));
    3372     optionList.add(new Option("[R]|[X]", "endo-arg-C, [R]|[X]"));
    3373     optionList.add(new Option("[K]|[X]", "endo-lys-C, [K]|[X]"));
    3374     optionList.add(new Option("[E]|[X]", "endo-glu-C, [E]|[X]"));
    3375     optionList.add(new Option("[X]|[D]", "endo-asp-N, [X]|[D]"));
    3376     optionList.add(new Option("[ED]|[X]", "V8, [ED]|[X]"));
    3377     // Use input protein cleavage site option list if present
    3378     if (proteinCleavageSiteOptionList != null && proteinCleavageSiteOptionList
    3379       .size() > 0)
    3380     {
    3381       optionList = proteinCleavageSiteOptionList;
    3382     }
    3383     selected = xTandemParameterSet.getProteinCleavageSite();
    3384     Select<VString> proteinCleavageSiteSelectBox = new Select<VString>(
    3385       validStringParam, optionList);
    3386   proteinCleavageSiteSelectBox.selectOption( selected);
    3387     proteinCleavageSiteSelectBox
    3388       .setLabel("XTandemProteinCleavageSiteSelect");
    3389     proteinFS.add(proteinCleavageSiteSelectBox);
    3390     // Protein, cleavage site (own entered value)
    3391     TextField<String> cleavageSite = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_SITE);
    3392     cleavageSite.setLabel("XTandemProteinCleavageSiteEnter");
    3393     // Only insert selected value if not found in select box
    3394     if (!itemInOptionList(optionList, selected))
    3395     {
    3396       cleavageSite.setValue(xTandemParameterSet.getProteinCleavageSite());
    3397     }
    3398     else
    3399     {
    3400       cleavageSite.setValue("");
    3401     }
    3402     proteinFS.add(cleavageSite);
    3403     // Protein, modified residue mass file
    3404     TextField<String> proteinModifiedResidueMassFile = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_MODIFIED_RESIDUE_MASS_FILE);
    3405     proteinModifiedResidueMassFile.setValue(xTandemParameterSet
    3406       .getProteinModifiedResidueMassFile());
    3407     proteinFS.add(proteinModifiedResidueMassFile);
    3408     // Protein, cleavage N-terminal mass change
    3409     TextField<String> proteinCleavageNTerminalMassChange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_N_TERMINAL_MASS_CHANGE);
    3410     proteinCleavageNTerminalMassChange.setValue(xTandemParameterSet
    3411       .getProteinCleavageNTerminalMassChange());
    3412     proteinFS.add(proteinCleavageNTerminalMassChange);
    3413     // Protein, cleavage C-terminal mass change
    3414     TextField<String> proteinCleavageCTerminalMassChange = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_CLEAVAGE_C_TERMINAL_MASS_CHANGE);
    3415     proteinCleavageCTerminalMassChange.setValue(xTandemParameterSet
    3416       .getProteinCleavageCTerminalMassChange());
    3417     proteinFS.add(proteinCleavageCTerminalMassChange);
    3418     // Protein, N-terminal residue modification mass
    3419     TextField<String> nTerminalResidueModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_N_TERMINAL_RESIDUE_MODIFICATION_MASS);
    3420     nTerminalResidueModificationMass.setValue(xTandemParameterSet
    3421       .getProteinNTerminalResidueModificationMass());
    3422     proteinFS.add(nTerminalResidueModificationMass);
    3423     // Protein, C-terminal residue modification mass
    3424     TextField<String> cTerminalResidueModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_C_TERMINAL_RESIDUE_MODIFICATION_MASS);
    3425     cTerminalResidueModificationMass.setValue(xTandemParameterSet
    3426       .getProteinCTerminalResidueModificationMass());
    3427     proteinFS.add(cTerminalResidueModificationMass);
    3428     // Protein, homolog management
    3429     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_PROTEIN_HOMOLOG_MANAGEMENT;
    3430     stringList = new ArrayList<String>();
    3431     stringList.add("yes");
    3432     stringList.add("no");
    3433     selected = xTandemParameterSet.getProteinHomologManagement();
    3434     Select<VString> homologManagement = new Select<VString>(validStringParam, stringList, selected);
    3435     proteinFS.add(homologManagement);
    3436     /*
    3437      * Refine field set
    3438      */
    3439     Fieldset refineFS = new Fieldset();
    3440     refineFS.setTitle("XTandemParameterSetRefine");
    3441     form.addFieldset(refineFS);
    3442     // Refine
    3443     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE;
    3444     stringList = new ArrayList<String>();
    3445     stringList.add("yes");
    3446     stringList.add("no");
    3447     selected = xTandemParameterSet.getRefine();
    3448     Select<VString> refine = new Select<VString>(validStringParam,  stringList, selected);
    3449     refineFS.add(refine);
    3450     // Refine, modification mass
    3451     TextField<String> refineModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_MODIFICATION_MASS);
    3452     refineModificationMass.setValue(xTandemParameterSet
    3453       .getRefineModificationMass());
    3454     refineFS.add(refineModificationMass);
    3455     // Refine, sequence path
    3456     TextField<String> refineSequencePath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_SEQUENCE_PATH);
    3457     refineSequencePath
    3458       .setValue(xTandemParameterSet.getRefineSequencePath());
    3459     refineFS.add(refineSequencePath);
    3460     // Refine, tic percent
    3461     TextField<String> refineTicPercent = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_TIC_PERCENT);
    3462     refineTicPercent.setValue(xTandemParameterSet.getRefineTicPercent());
    3463     refineFS.add(refineTicPercent);
    3464     // Refine, spectrum synthesis
    3465     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_SPECTRUM_SYNTHESIS;
    3466     stringList = new ArrayList<String>();
    3467     stringList.add("yes");
    3468     stringList.add("no");
    3469     selected = xTandemParameterSet.getRefineSpectrumSynthesis();
    3470     Select<VString> spectrumSynthesis = new Select<VString>(validStringParam, stringList, selected);
    3471     refineFS.add(spectrumSynthesis);
    3472     // Refine, maximum valid expectation value
    3473     TextField<String> maxValidExpectationValue = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_MAX_VALID_EXPECTATION_VALUE);
    3474     maxValidExpectationValue.setValue(xTandemParameterSet
    3475       .getRefineMaximumValidExpectationValue());
    3476     refineFS.add(maxValidExpectationValue);
    3477     // Refine, potential N-terminus modifications
    3478     TextField<String> potentialNTerminusModifications = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_N_TERMINUS_MODIFICATIONS);
    3479     potentialNTerminusModifications.setValue(xTandemParameterSet
    3480       .getRefinePotentialNTerminusModifications());
    3481     refineFS.add(potentialNTerminusModifications);
    3482     // Refine, potential C-terminus modifications
    3483     TextField<String> potentialCTerminusModifications = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_C_TERMINUS_MODIFICATIONS);
    3484     potentialCTerminusModifications.setValue(xTandemParameterSet
    3485       .getRefinePotentialCTerminusModifications());
    3486     refineFS.add(potentialCTerminusModifications);
    3487     // Refine, unanticipated cleavage
    3488     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_UNANTICIPATED_CLEAVAGE;
    3489     stringList = new ArrayList<String>();
    3490     stringList.add("yes");
    3491     stringList.add("no");
    3492     selected = xTandemParameterSet.getRefineUnanticipatedCleavage();
    3493     Select<VString> unanticipatedCleavage = new Select<VString>(validStringParam, stringList, selected);
    3494     refineFS.add(unanticipatedCleavage);
    3495     // Refine, potential modification mass select
    3496     /*
    3497      * Refine potential modification mass selection has two peculiarities:
    3498      * 1. It supports selection of multiple items. 2. The GUI selection is
    3499      * divided into one multiple selection box and an entry field.
    3500      * Selections in the selection box will only be used if the entry field
    3501      * is empty. The multiple selection items are stored in XML as a string
    3502      * with items separated by ", ".
    3503      */
    3504     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MASS_SELECT;
    3505     optionList = new ArrayList<Option>();
    3506     optionList.add(new Option("", "none"));
    3507     optionList.add(new Option("15.994915@M", "Oxidation (M)"));
    3508     optionList.add(new Option("15.994915@W", "Oxidation (W)"));
    3509     optionList.add(new Option("0.984016@N", "Deamidation (N)"));
    3510     optionList.add(new Option("0.984016@Q", "Deamidation (Q)"));
    3511     optionList.add(new Option("8.0502@C", "ICAT-D:2H(8) (C)"));
    3512     optionList.add(new Option("9.0302@C", "ICAT-C:13C(9) (C)"));
    3513     optionList.add(new Option("144.102063@[", "iTRAQ (N-term)"));
    3514     optionList.add(new Option("144.102063@K", "iTRAQ (K)"));
    3515     optionList.add(new Option("79.966331@S", "Phospho (S)"));
    3516     optionList.add(new Option("79.966331@T", "Phospho (T)"));
    3517     optionList.add(new Option("79.966331@Y", "Phospho (Y)"));
    3518     optionList.add(new Option("79.956815@Y", "Sulfo (Y)"));
    3519     optionList.add(new Option("42.010565@K", "Acetyl (K)"));
    3520     // Use input refine potential modification mass option list if present
    3521     if (refinePotentialModificationMassOptionList != null && refinePotentialModificationMassOptionList
    3522       .size() > 0)
    3523     {
    3524       optionList = refinePotentialModificationMassOptionList;
    3525       log
    3526         .debug("Input refine potential modification mass option list used");
    3527     }
    3528     else
    3529     {
    3530       log
    3531         .debug("Default refine potential modification mass option list used");
    3532     }
    3533     selected = xTandemParameterSet.getRefinePotentialModificationMass();
    3534     log
    3535       .debug("refine potential modification mass selected = \"" + selected + "\"");
    3536     selectedList = listStringToStringList(selected, ",");
    3537     log
    3538       .debug("refine potential modification mass selectedList = " + selectedList);
    3539     Select<VString> refinePotentialModificationMassSelectBox = new Select<VString>(
    3540       validStringParam, optionList, selectedList);
    3541     refinePotentialModificationMassSelectBox
    3542       .setLabel("XTandemRefinePotentialModificationMassSelect");
    3543     refinePotentialModificationMassSelectBox.setMultiple(true);
    3544     refinePotentialModificationMassSelectBox.setSize(4);
    3545     refineFS.add(refinePotentialModificationMassSelectBox);
    3546     // Refine, potential modification mass
    3547     TextField<String> refinePotentialModificationMass = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MASS);
    3548     refinePotentialModificationMass
    3549       .setLabel("XTandemRefinePotentialModificationMassEnter");
    3550     refinePotentialModificationMass.setValue(xTandemParameterSet
    3551       .getRefinePotentialModificationMass());
    3552     // Only insert selected values if not all found in select box
    3553     if (!allItemsInOptionList(optionList, selectedList))
    3554     {
    3555       log
    3556         .debug("refine potential modification mass, inserted value = \"" + xTandemParameterSet
    3557           .getRefinePotentialModificationMass() + "\"");
    3558       refinePotentialModificationMass.setValue(xTandemParameterSet
    3559         .getRefinePotentialModificationMass());
    3560     }
    3561     else
    3562     {
    3563       refinePotentialModificationMass.setValue("");
    3564     }
    3565     refineFS.add(refinePotentialModificationMass);
    3566     /** **************************************** */
    3567     // Refine, point mutations
    3568     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POINT_MUTATIONS;
    3569     stringList = new ArrayList<String>();
    3570     stringList.add("yes");
    3571     stringList.add("no");
    3572     selected = xTandemParameterSet.getRefinePointMutations();
    3573     Select<VString> pointMutations = new Select<VString>(validStringParam,  stringList, selected);
    3574     refineFS.add(pointMutations);
    3575     // Refine, use potential modifications for full refinement
    3576     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_REFINE_USE_POTENTIAL_MODIFICATIONS_FOR_FULL_REFINEMENT;
    3577     stringList = new ArrayList<String>();
    3578     stringList.add("yes");
    3579     stringList.add("no");
    3580     selected = xTandemParameterSet
    3581       .getRefineUsePotentialModificationsForFullRefinement();
    3582     Select<VString> usePotentialModificationsForFullRefinement = new Select<VString>(validStringParam, stringList, selected);
    3583     refineFS.add(usePotentialModificationsForFullRefinement);
    3584     // Refine, potential modification motif
    3585     TextField<String> potentialModificationMotifRefine = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_REFINE_POTENTIAL_MODIFICATION_MOTIF);
    3586     potentialModificationMotifRefine.setValue(xTandemParameterSet
    3587       .getRefinePotentialModificationMotif());
    3588     refineFS.add(potentialModificationMotifRefine);
    3589     /*
    3590      * Scoring field set
    3591      */
    3592     Fieldset scoringFS = new Fieldset();
    3593     scoringFS.setTitle("XTandemParameterSetScoring");
    3594     form.addFieldset(scoringFS);
    3595     // Scoring, minimum ion count
    3596     TextField<String> minIonCount = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_MIN_ION_COUNT);
    3597     minIonCount.setValue(xTandemParameterSet.getScoringMinimumIonCount());
    3598     scoringFS.add(minIonCount);
    3599     // Scoring, maximum missed cleavage sites
    3600     TextField<String> maxMissedCleavageSites = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_SCORING_MAX_MISSED_CLEAVAGE_SITES);
    3601     maxMissedCleavageSites.setValue(xTandemParameterSet
    3602       .getScoringMaximumMissedCleavageSites());
    3603     scoringFS.add(maxMissedCleavageSites);
    3604     // Scoring, x ions
    3605     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_X_IONS;
    3606     stringList = new ArrayList<String>();
    3607     stringList.add("yes");
    3608     stringList.add("no");
    3609     selected = xTandemParameterSet.getScoringXIons();
    3610     Select<VString> xIons = new Select<VString>(validStringParam, stringList, selected);
    3611     scoringFS.add(xIons);
    3612     // Scoring, y ions
    3613     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_Y_IONS;
    3614     stringList = new ArrayList<String>();
    3615     stringList.add("yes");
    3616     stringList.add("no");
    3617     selected = xTandemParameterSet.getScoringYIons();
    3618     Select<VString> yIons = new Select<VString>(validStringParam, stringList, selected);
    3619     scoringFS.add(yIons);
    3620     // Scoring, z ions
    3621     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_Z_IONS;
    3622     stringList = new ArrayList<String>();
    3623     stringList.add("yes");
    3624     stringList.add("no");
    3625     selected = xTandemParameterSet.getScoringZIons();
    3626     Select<VString> zIons = new Select<VString>(validStringParam, stringList, selected);
    3627     scoringFS.add(zIons);
    3628     // Scoring, a ions
    3629     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_A_IONS;
    3630     stringList = new ArrayList<String>();
    3631     stringList.add("yes");
    3632     stringList.add("no");
    3633     selected = xTandemParameterSet.getScoringAIons();
    3634     Select<VString> aIons = new Select<VString>(validStringParam, stringList, selected);
    3635     scoringFS.add(aIons);
    3636     // Scoring, b ions
    3637     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_B_IONS;
    3638     stringList = new ArrayList<String>();
    3639     stringList.add("yes");
    3640     stringList.add("no");
    3641     selected = xTandemParameterSet.getScoringBIons();
    3642     Select<VString> bIons = new Select<VString>(validStringParam, stringList, selected);
    3643     scoringFS.add(bIons);
    3644     // Scoring, c ions
    3645     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_C_IONS;
    3646     stringList = new ArrayList<String>();
    3647     stringList.add("yes");
    3648     stringList.add("no");
    3649     selected = xTandemParameterSet.getScoringCIons();
    3650     Select<VString> cIons = new Select<VString>(validStringParam, stringList, selected);
    3651     scoringFS.add(cIons);
    3652     // Scoring, cyclic permutation
    3653     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_CYCLIC_PERMUTATION;
    3654     stringList = new ArrayList<String>();
    3655     stringList.add("yes");
    3656     stringList.add("no");
    3657     selected = xTandemParameterSet.getScoringCyclicPermutation();
    3658     Select<VString> cyclicPermutation = new Select<VString>(validStringParam, stringList, selected);
    3659     scoringFS.add(cyclicPermutation);
    3660     // Scoring, include reverse
    3661     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_INCLUDE_REVERSE;
    3662     stringList = new ArrayList<String>();
    3663     stringList.add("yes");
    3664     stringList.add("no");
    3665     selected = xTandemParameterSet.getScoringIncludeReverse();
    3666     Select<VString> includeReverse = new Select<VString>(validStringParam, stringList, selected);
    3667     scoringFS.add(includeReverse);
    3668     // Scoring, algorithm
    3669     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_SCORING_ALGORITHM;
    3670     optionList = new ArrayList<Option>();
    3671     optionList.add(new Option("", "native"));
    3672     optionList.add(new Option("k-score", "k-score"));
    3673     selected = xTandemParameterSet.getScoringAlgorithm();
    3674     Select<VString> algorithmSelectBox = new Select<VString>(
    3675       validStringParam, optionList);
    3676   algorithmSelectBox.selectOption( selected);
    3677     scoringFS.add(algorithmSelectBox);
    3678     /*
    3679      * Output field set
    3680      */
    3681     Fieldset outputFS = new Fieldset();
    3682     outputFS.setTitle("XTandemParameterSetOutput");
    3683     form.addFieldset(outputFS);
    3684     // Output, path
    3685     TextField<String> outputPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PATH);
    3686     outputPath.setValue(xTandemParameterSet.getOutputPath());
    3687     outputFS.add(outputPath);
    3688     // Output, log path
    3689     TextField<String> outputLogPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_LOG_PATH);
    3690     outputLogPath.setValue(xTandemParameterSet.getOutputLogPath());
    3691     outputFS.add(outputLogPath);
    3692     // Output, message
    3693     TextField<String> outputMessage = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_MESSAGE);
    3694     outputMessage.setValue(xTandemParameterSet.getOutputMessage());
    3695     outputFS.add(outputMessage);
    3696     // Output, sequence path
    3697     TextField<String> outputSequencePath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SEQUENCE_PATH);
    3698     outputSequencePath
    3699       .setValue(xTandemParameterSet.getOutputSequencePath());
    3700     outputFS.add(outputSequencePath);
    3701     // Output, sort results by
    3702     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SORT_RESULTS_BY;
    3703     stringList = new ArrayList<String>();
    3704     stringList.add("protein");
    3705     stringList.add("spectrum");
    3706     selected = xTandemParameterSet.getOutputSortResultsBy();
    3707     Select<VString> outputSortResultsBy = new Select<VString>(validStringParam, stringList, selected);
    3708     outputFS.add(outputSortResultsBy);
    3709     // Output, path hashing
    3710     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PATH_HASHING;
    3711     stringList = new ArrayList<String>();
    3712     stringList.add("yes");
    3713     stringList.add("no");
    3714     selected = xTandemParameterSet.getOutputPathHashing();
    3715     Select<VString> pathHashing = new Select<VString>(validStringParam, stringList, selected);
    3716     outputFS.add(pathHashing);
    3717     // Output, xsl path
    3718     TextField<String> xslPath = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_XSL_PATH);
    3719     xslPath.setValue(xTandemParameterSet.getOutputXslPath());
    3720     outputFS.add(xslPath);
    3721     // Output, parameters
    3722     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PARAMETERS;
    3723     stringList = new ArrayList<String>();
    3724     stringList.add("yes");
    3725     stringList.add("no");
    3726     selected = xTandemParameterSet.getOutputParameters();
    3727     Select<VString> parameters = new Select<VString>(validStringParam, stringList, selected);
    3728     outputFS.add(parameters);
    3729     // Output, performance
    3730     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PERFORMANCE;
    3731     stringList = new ArrayList<String>();
    3732     stringList.add("yes");
    3733     stringList.add("no");
    3734     selected = xTandemParameterSet.getOutputPerformance();
    3735     Select<VString> performance = new Select<VString>(validStringParam, stringList, selected);
    3736     outputFS.add(performance);
    3737     // Output, spectra
    3738     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SPECTRA;
    3739     stringList = new ArrayList<String>();
    3740     stringList.add("yes");
    3741     stringList.add("no");
    3742     selected = xTandemParameterSet.getOutputSpectra();
    3743     Select<VString> spectra = new Select<VString>(validStringParam, stringList, selected);
    3744     outputFS.add(spectra);
    3745     // Output, histograms
    3746     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_HISTOGRAMS;
    3747     stringList = new ArrayList<String>();
    3748     stringList.add("yes");
    3749     stringList.add("no");
    3750     selected = xTandemParameterSet.getOutputHistograms();
    3751     Select<VString> histograms = new Select<VString>(validStringParam,  stringList, selected);
    3752     outputFS.add(histograms);
    3753     // Output, proteins
    3754     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_PROTEINS;
    3755     stringList = new ArrayList<String>();
    3756     stringList.add("yes");
    3757     stringList.add("no");
    3758     selected = xTandemParameterSet.getOutputProteins();
    3759     Select<VString> proteins = new Select<VString>(validStringParam,  stringList, selected);
    3760     outputFS.add(proteins);
    3761     // Output, sequences
    3762     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_SEQUENCES;
    3763     stringList = new ArrayList<String>();
    3764     stringList.add("yes");
    3765     stringList.add("no");
    3766     selected = xTandemParameterSet.getOutputSequences();
    3767     Select<VString> sequences = new Select<VString>(validStringParam, stringList, selected);
    3768     outputFS.add(sequences);
    3769     // Output, one sequence copy
    3770     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_ONE_SEQUENCE_COPY;
    3771     stringList = new ArrayList<String>();
    3772     stringList.add("yes");
    3773     stringList.add("no");
    3774     selected = xTandemParameterSet.getOutputOneSequenceCopy();
    3775     Select<VString> oneSequenceCopy = new Select<VString>(validStringParam, stringList, selected);
    3776     outputFS.add(oneSequenceCopy);
    3777     // Output, results
    3778     validStringParam = SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_RESULTS;
    3779     stringList = new ArrayList<String>();
    3780     stringList.add("all");
    3781     stringList.add("valid");
    3782     stringList.add("stochastic");
    3783     selected = xTandemParameterSet.getOutputResults();
    3784     Select<VString> results = new Select<VString>(validStringParam, stringList, selected);
    3785     outputFS.add(results);
    3786     // Output, maximum valid expectation value
    3787     TextField<String> outputMaxValidExpectationValue = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_MAX_VALID_EXPECTATION_VALUE);
    3788     outputMaxValidExpectationValue.setValue(xTandemParameterSet
    3789       .getOutputMaximumValidExpectationValue());
    3790     outputFS.add(outputMaxValidExpectationValue);
    3791     // Output, histogram column width
    3792     TextField<String> histogramColumnWidth = new TextField<String>(SaveXTandemParameterSetStorage.VXTANDEM_OUTPUT_HISTOGRAM_COLUMN_WIDTH);
    3793     histogramColumnWidth.setValue(xTandemParameterSet
    3794       .getOutputHistogramColumnWidth());
    3795     outputFS.add(histogramColumnWidth);
    3796     //
    3797     return form;
    3798   }
    37992213
    38002214
Note: See TracChangeset for help on using the changeset viewer.