gt:         qualifiers.add(new Qualifier("note", "plus"));
context: /*
   * Copyright (C) 2009  Genome Research Limited
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License
   * as published by the Free Software Foundation; either version 2
   * of the License, or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
   *
   */
  package uk.ac.sanger.artemis.circular.digest;
  
  import uk.ac.sanger.artemis.Entry;
  import uk.ac.sanger.artemis.EntryGroup;
  import uk.ac.sanger.artemis.circular.DNADraw;
  import uk.ac.sanger.artemis.circular.Track;
  import uk.ac.sanger.artemis.circular.TrackManager;
  import uk.ac.sanger.artemis.circular.Wizard;
  import uk.ac.sanger.artemis.io.Key;
  import uk.ac.sanger.artemis.io.Qualifier;
  import uk.ac.sanger.artemis.io.QualifierVector;
  import uk.ac.sanger.artemis.sequence.MarkerRange;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.Reader;
  import java.util.ArrayList;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Vector;
  
  import javax.swing.JOptionPane;
  
  public class Utils
  {
  	//private static final Logger logger = Logger.getLogger(Utils.class);
  
    protected static ReportDetails findCutSitesFromEmbossReport(Reader reader)
    {
      EmbossTableParser etp = new EmbossTableParser();
      ReportDetails ret = new ReportDetails();
      try
      {
        BufferedReader br = new BufferedReader(reader);
        ret.cutSites = etp.parse(br);
        ret.length = etp.getLength();
      }
      catch (IOException exp)
      {
        throw new RuntimeException("Couldn't read, or parse results");
      }
      return ret;
    }
  	
    protected static List<FragmentBand> findCutSitesFromExperiment(Reader reader) 
              throws IOException
    {
      BufferedReader br = new BufferedReader(reader);
      String line;
      
      List<FragmentBand> list = new ArrayList<FragmentBand>();
      while ((line = br.readLine()) != null)
      { 
        FragmentBand band = new FragmentBand();
        band.genomeFragmentLength = Integer.parseInt(line.trim());
        
        list.add(band);
      }
      return list;
    }
  
    /**
     * Creates the DNAPlotter components and adds a forward and reverse track for
     * the restriction enzyme results.
     * 
     * @param rd
     * @param entryGroup
     * @return
     */
    protected static DNADraw createDNADrawFromReportDetails(
        final ReportDetails rd, final EntryGroup entryGroup)
    {
      DNADraw dna = new DNADraw();
      dna.setArtemisEntryGroup(entryGroup);
  
      int sequenceLength = rd.length;
      Hashtable<String, Object> lineAttr = new Hashtable<String, Object>();
      lineAttr.put("lsize", new Integer(1));
      lineAttr.put("circular", new Boolean(true));
      lineAttr.put("start", new Integer(0));
      lineAttr.put("end", new Integer(sequenceLength));
      dna.setLineAttributes(lineAttr);
  
      // set ticks
      int div;
      if (sequenceLength < 1000)
        div = 100;
      else if (sequenceLength < 10000)
        div = 1000;
      else if (sequenceLength < 100000)
        div = 10000;
      else
        div = 100000;
      int tickNum = sequenceLength / div;
      int tick = tickNum * (div / 10);
      
      if(tick < 1)
        tick = 2;
      while ((sequenceLength % tick) < (div / 10))
      {
        tickNum++;
        tick = tickNum * (div / 10);
      }
      dna.setMinorTickInterval(tick);
      dna.setTickInterval(tick);
      dna.setOpaque(true);
  
      final Entry newEntry = dna.getArtemisEntryGroup().createEntry("RE");
      newEntry.getEMBLEntry().setName("Restriction Sites");
      Track forward = new Track(0.9, "misc_feature", true, false, newEntry);
      forward.setQualifier("note");
      forward.setQualifierValue("plus");
      Track reverse = new Track(0.85, "misc_feature", true, false, newEntry);
      reverse.setQualifier("note");
      reverse.setQualifierValue("minus");
      Track fileTrack = new Track(0.8, "CDS", true, true, entryGroup
          .getSequenceEntry());
  
      Wizard.tracks = new Track[3];
      Wizard.tracks[0] = forward;
      Wizard.tracks[1] = reverse;
      Wizard.tracks[2] = fileTrack;
  
      int counter = 0;
      /*if (rd.cutSites.size() == 1)
      {
        CutSite cutSite = rd.cutSites.get(0);
        // dna.addFeatureToTrack(createFeature(cutSite.getEnd(), rd.length
        // + cutSite.getStart(), 1, sequenceLength), forward, false);
        addFeature(cutSite.getFivePrime(), rd.length, counter, newEntry, dna,
            cutSite.isForward());
        
        dna.setGeneticMarker(new Vector());
        TrackManager trackManager = dna.getTrackManager();
        if (trackManager == null)
        {
          trackManager = new TrackManager(dna);
          dna.setTrackManager(trackManager);
        }
        trackManager.update(Wizard.tracks);
  
        return dna;
      }*/
  
      Iterator<CutSite> it = rd.cutSites.iterator();
      CutSite firstCutSite = null;
      int lastCutPos = 1;
  
      while (it.hasNext())
      {
        CutSite cutSite = it.next();
  
        if (counter == 0)
        {
          firstCutSite = cutSite;
          lastCutPos = cutSite.getThreePrime();
          counter++;
          continue;
        }
  
        addFeature(lastCutPos, cutSite.getFivePrime(), counter, newEntry, dna,
            cutSite.isForward());
        lastCutPos = cutSite.getFivePrime();
        counter++;
      }
  
      if (firstCutSite != null)
      {
        addFeature(lastCutPos, rd.length, -1, newEntry, dna, firstCutSite
            .isForward());
        addFeature(1, firstCutSite.getFivePrime(), -1, newEntry, dna,
            firstCutSite.isForward());
      }
  
      dna.setGeneticMarker(new Vector());
      TrackManager trackManager = dna.getTrackManager();
      if (trackManager == null)
      {
        trackManager = new TrackManager(dna);
        dna.setTrackManager(trackManager);
      }
      trackManager.update(Wizard.tracks);
  
      return dna;
    }
  
    /**
     * Add a new feature to the entry with the given coordinates
     * 
     * @param coord1
     * @param coord2
     * @param counter
     * @param newEntry
     * @param dna
     * @param isForward
     */
    private static void addFeature(int coord1, int coord2, int counter,
        Entry entry, DNADraw dna, boolean isForward)
    {
      String colour;
      if (counter < 0)
        colour = "7";
      else if (counter % 2 == 0)
        colour = "2";
      else
        colour = "5";
  
      try
      {
        QualifierVector qualifiers = new QualifierVector();
        qualifiers.add(new Qualifier("colour", colour));
        final MarkerRange r;
  
        if (isForward)
  