From: amwaterhouse <Andrew Waterhouse>
Date: Fri, 9 Jun 2006 16:14:17 +0000 (+0000)
Subject: Annotation/feature exporter
X-Git-Tag: Release_2_1~372
X-Git-Url: http://source.jalview.org/gitweb/?a=commitdiff_plain;h=9922c9eec14599f6b141a8db8a3859cab7227ce0;p=jalview.git

Annotation/feature exporter
---

diff --git a/src/jalview/gui/AnnotationExporter.java b/src/jalview/gui/AnnotationExporter.java
new file mode 100755
index 0000000..d4975a6
--- /dev/null
+++ b/src/jalview/gui/AnnotationExporter.java
@@ -0,0 +1,227 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2006 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+package jalview.gui;
+
+import javax.swing.*;
+import java.awt.event.ActionListener;
+import java.awt.event.ActionEvent;
+
+import jalview.io.*;
+import jalview.datamodel.AlignmentAnnotation;
+
+import java.awt.Color;
+import java.awt.FlowLayout;
+import javax.swing.BorderFactory;
+
+
+public class AnnotationExporter
+    extends JPanel
+{
+  JInternalFrame frame;
+  AlignmentPanel ap;
+  boolean features = true;
+  AlignmentAnnotation [] annotations;
+
+  public AnnotationExporter()
+  {
+    try
+    {
+      jbInit();
+    }
+    catch (Exception ex)
+    {
+      ex.printStackTrace();
+    }
+
+    frame = new JInternalFrame();
+    frame.setContentPane(this);
+    frame.setLayer(JLayeredPane.PALETTE_LAYER);
+    Desktop.addInternalFrame(frame,
+                             "",
+                             260, 125);
+  }
+
+  public void exportFeatures(AlignmentPanel ap)
+  {
+    this.ap = ap;
+    features = true;
+    frame.setTitle("Export Features");
+  }
+
+  public void exportAnnotations(AlignmentPanel ap,
+                                AlignmentAnnotation [] annotations)
+  {
+    this.ap = ap;
+    features = false;
+    GFFFormat.setVisible(false);
+    this.annotations = annotations;
+    frame.setTitle("Export Annotations");
+  }
+
+  public void toFile_actionPerformed(ActionEvent e)
+  {
+      JalviewFileChooser chooser = new JalviewFileChooser(
+      jalview.bin.Cache.getProperty( "LAST_DIRECTORY"));
+
+      chooser.setFileView(new JalviewFileView());
+      chooser.setDialogTitle(
+          features ? "Save Features to File" : "Save Annotation to File");
+      chooser.setToolTipText("Save");
+
+      int value = chooser.showSaveDialog(this);
+
+      if (value == JalviewFileChooser.APPROVE_OPTION)
+      {
+        String text = "No features found on alignment";
+        if (features)
+        {
+          if (GFFFormat.isSelected())
+            text = new FeaturesFile().printGFFFormat(
+                ap.av.alignment.getDataset().getSequencesArray(),
+                ap.av.featuresDisplayed);
+          else
+            text = new FeaturesFile().printJalviewFormat(
+                ap.av.alignment.getDataset().getSequencesArray(),
+                ap.av.featuresDisplayed);
+        }
+        else
+        {
+           text = new AnnotationFile().printAnnotations( annotations );
+        }
+
+        try
+        {
+          java.io.PrintWriter out = new java.io.PrintWriter(
+              new java.io.FileWriter(chooser.getSelectedFile()));
+
+          out.print(text);
+          out.close();
+        }
+        catch (Exception ex)
+        {
+          ex.printStackTrace();
+        }
+      }
+  }
+
+  public void toTextbox_actionPerformed(ActionEvent e)
+  {
+    String text = "No features found on alignment";
+    if(features)
+    {
+      if (GFFFormat.isSelected())
+        text = new FeaturesFile().printGFFFormat(
+            ap.av.alignment.getDataset().getSequencesArray(),
+            ap.av.featuresDisplayed);
+      else
+        text = new FeaturesFile().printJalviewFormat(
+            ap.av.alignment.getDataset().getSequencesArray(),
+                ap.av.featuresDisplayed);
+    }
+    else if(!features)
+    {
+      text = new AnnotationFile().printAnnotations( annotations );
+    }
+
+
+    CutAndPasteTransfer cap = new CutAndPasteTransfer();
+    cap.setText(text);
+    Desktop.addInternalFrame(cap,
+                             (features ?  "Features for - " : "Annotations for - ")
+                             + ap.alignFrame.getTitle(),
+                             600,
+                             500);
+
+
+  }
+
+  public void close_actionPerformed(ActionEvent e)
+  {
+    try{
+      frame.setClosed(true);
+    }catch(java.beans.PropertyVetoException ex)
+    {}
+  }
+
+
+
+  private void jbInit()
+      throws Exception
+  {
+    this.setLayout(flowLayout1);
+    toFile.setText("to File");
+    toFile.addActionListener(new ActionListener()
+    {
+      public void actionPerformed(ActionEvent e)
+      {
+        toFile_actionPerformed(e);
+      }
+    });
+    toTextbox.setText("to Textbox");
+    toTextbox.addActionListener(new ActionListener()
+    {
+      public void actionPerformed(ActionEvent e)
+      {
+        toTextbox_actionPerformed(e);
+      }
+    });
+    close.setText("Close");
+    close.addActionListener(new ActionListener()
+    {
+      public void actionPerformed(ActionEvent e)
+      {
+        close_actionPerformed(e);
+      }
+    });
+    jalviewFormat.setOpaque(false);
+    jalviewFormat.setSelected(true);
+    jalviewFormat.setText("Jalview");
+    GFFFormat.setOpaque(false);
+    GFFFormat.setText("GFF");
+    jLabel1.setHorizontalAlignment(SwingConstants.TRAILING);
+    jLabel1.setText("Format: ");
+    this.setBackground(Color.white);
+    jPanel3.setBorder(BorderFactory.createEtchedBorder());
+    jPanel3.setOpaque(false);
+    jPanel1.setOpaque(false);
+    jPanel1.add(toFile);
+    jPanel1.add(toTextbox);
+    jPanel1.add(close);
+    jPanel3.add(jLabel1);
+    jPanel3.add(jalviewFormat);
+    jPanel3.add(GFFFormat);
+    buttonGroup.add(jalviewFormat);
+    buttonGroup.add(GFFFormat);
+    this.add(jPanel3, null);
+    this.add(jPanel1, null);
+  }
+
+  JPanel jPanel1 = new JPanel();
+  JButton toFile = new JButton();
+  JButton toTextbox = new JButton();
+  JButton close = new JButton();
+  ButtonGroup buttonGroup = new ButtonGroup();
+  JRadioButton jalviewFormat = new JRadioButton();
+  JRadioButton GFFFormat = new JRadioButton();
+  JLabel jLabel1 = new JLabel();
+  JPanel jPanel3 = new JPanel();
+  FlowLayout flowLayout1 = new FlowLayout();
+
+}
diff --git a/src/jalview/io/AnnotationFile.java b/src/jalview/io/AnnotationFile.java
new file mode 100755
index 0000000..e427605
--- /dev/null
+++ b/src/jalview/io/AnnotationFile.java
@@ -0,0 +1,420 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2006 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+package jalview.io;
+
+import java.io.*;
+import jalview.datamodel.*;
+import java.util.*;
+import jalview.schemes.UserColourScheme;
+import java.net.URL;
+
+
+public class AnnotationFile
+{
+
+  public String printAnnotations(AlignmentAnnotation [] annotations)
+  {
+    StringBuffer text = new StringBuffer(
+      "JALVIEW_ANNOTATION\n"
+      +"# Created: "
+      +new java.util.Date()+"\n\n");
+
+    AlignmentAnnotation row;
+    String comma;
+    String seqref = null;
+
+    StringBuffer colours = new StringBuffer();
+    StringBuffer graphLine = new StringBuffer();
+
+    Hashtable graphGroup = new Hashtable();
+
+    java.awt.Color color;
+
+    for(int i=0; i<annotations.length; i++)
+    {
+      row = annotations[i];
+      color = null;
+
+      if( row.sequenceRef == null)
+        seqref = null;
+
+      else if (seqref == null
+           || !seqref.equals(row.sequenceRef.getName()))
+      {
+        seqref = row.sequenceRef.getName();
+        text.append("\nSEQUENCE_REF\t" + seqref + "\n");
+      }
+
+
+      switch( row.graph )
+      {
+        case AlignmentAnnotation.NO_GRAPH:
+          text.append("NO_GRAPH\t");
+          break;
+        case AlignmentAnnotation.BAR_GRAPH:
+          text.append("BAR_GRAPH\t");
+        case AlignmentAnnotation.LINE_GRAPH:
+          text.append("LINE_GRAPH\t");
+
+          if(row.getThreshold()!=null)
+            graphLine.append("GRAPHLINE\t"
+                             + row.label + "\t"
+                             + row.getThreshold().value + "\t"
+                             + row.getThreshold().label + "\t"
+                             + jalview.util.Format.getHexString(
+                                 row.getThreshold().colour)+"\n"
+                );
+
+          if(row.graphGroup>-1)
+          {
+            String key = String.valueOf(row.graphGroup);
+            if(graphGroup.containsKey(key))
+              graphGroup.put(key, graphGroup.get(key)
+                             +"\t"+row.label);
+            else
+              graphGroup.put(key, row.label);
+          }
+      }
+
+      text.append(row.label+"\t");
+
+      for(int j=0; j<row.annotations.length; j++)
+      {
+        if(row.annotations[j]!=null)
+        {
+          comma = "";
+          if (row.annotations[j].displayCharacter.length() > 0
+              && !row.annotations[j].displayCharacter.equals(" "))
+          {
+            text.append(row.annotations[j].displayCharacter);
+            comma = ",";
+          }
+          if (row.annotations[j].secondaryStructure!=' ')
+          {
+            text.append(comma + row.annotations[j].secondaryStructure);
+            comma = ",";
+          }
+          if (row.annotations[j].value!=0f)
+          {
+            color = row.annotations[j].colour;
+            text.append(comma + row.annotations[j].value);
+          }
+        }
+        text.append("|");
+      }
+
+      text.append("\n");
+
+      if(color!=null && color!=java.awt.Color.black)
+      {
+        colours.append("COLOUR\t"
+                       +row.label+"\t"
+                       +jalview.util.Format.getHexString(color)+"\n");
+      }
+
+    }
+
+    text.append("\n");
+
+    text.append(colours.toString());
+    text.append(graphLine.toString());
+    if(graphGroup.size()>0)
+    {
+      text.append("COMBINE\t");
+      Enumeration en = graphGroup.elements();
+      while(en.hasMoreElements())
+      {
+        text.append(en.nextElement()+"\n");
+      }
+    }
+
+    return text.toString();
+  }
+
+  public boolean readAnnotationFile(AlignmentI al, String file)
+  {
+    try
+    {
+      BufferedReader in = null;
+      java.io.InputStream is = getClass().getResourceAsStream("/" + file);
+      if (is != null)
+      {
+        in = new BufferedReader(new java.io.InputStreamReader(is));
+      }
+      else
+      {
+        try
+        {
+          URL url = new URL(file);
+          in = new BufferedReader(new InputStreamReader(url.openStream()));
+        }
+        catch (java.net.MalformedURLException ex)
+        {
+          in = new BufferedReader(new FileReader(file));
+        }
+      }
+
+      String line, label, description, token;
+      int graphStyle, index;
+      SequenceI refSeq = null;
+      int refSeqIndex = 1;
+      int existingAnnotations = 0;
+      if(al.getAlignmentAnnotation()!=null)
+       existingAnnotations = al.getAlignmentAnnotation().length;
+
+      int alWidth = al.getWidth();
+
+      StringTokenizer st;
+      Annotation[] annotations;
+      AlignmentAnnotation annotation = null;
+
+      // First confirm this is an Annotation file
+      boolean jvAnnotationFile = false;
+      while ( (line = in.readLine()) != null)
+      {
+        if (line.indexOf("#") == 0 )
+          continue;
+
+        if (line.indexOf("JALVIEW_ANNOTATION") > -1)
+        {
+          jvAnnotationFile = true;
+          break;
+        }
+      }
+
+      if(!jvAnnotationFile)
+      {
+        in.close();
+        return false;
+      }
+
+      while ( (line = in.readLine()) != null)
+      {
+        if(line.indexOf("#")==0
+           || line.indexOf("JALVIEW_ANNOTATION")>-1
+           || line.length()==0)
+          continue;
+
+        st = new StringTokenizer(line, "\t");
+        token = st.nextToken();
+        if(token.equalsIgnoreCase("COLOUR"))
+        {
+          colourAnnotations(al, st.nextToken(), st.nextToken());
+          continue;
+        }
+
+        if(token.equalsIgnoreCase("COMBINE") )
+        {
+          combineAnnotations(al, st);
+          continue;
+        }
+
+        if (token.equalsIgnoreCase("GRAPHLINE"))
+        {
+          addLine(al, st);
+          continue;
+        }
+
+
+        if(token.equalsIgnoreCase("SEQUENCE_REF") )
+        {
+          refSeq = al.findName(st.nextToken());
+          try{
+            refSeqIndex = Integer.parseInt(st.nextToken());
+          }
+          catch(Exception ex)
+          {
+            refSeqIndex = 1;
+          }
+
+          continue;
+        }
+
+
+        graphStyle = AlignmentAnnotation.getGraphValueFromString(token);
+        label = description = st.nextToken();
+
+        line = st.nextToken();
+
+        st = new StringTokenizer(line, "|", true);
+        annotations = new Annotation[alWidth];
+
+        index = 0;
+        boolean emptyColumn = true;
+
+
+        while (st.hasMoreElements() && index<alWidth)
+        {
+          token = st.nextToken().trim();
+          if(token.equals("|"))
+          {
+            if(emptyColumn)
+              index++;
+
+            emptyColumn = true;
+          }
+          else
+          {
+            annotations[index++] = parseAnnotation(token);
+            emptyColumn = false;
+          }
+        }
+
+       annotation = new AlignmentAnnotation(label,
+                                          description,
+                                          annotations,
+                                          0,
+                                          0,
+                                          graphStyle);
+
+       if(refSeq!=null)
+       {
+         annotation.createSequenceMapping(refSeq, refSeqIndex);
+         refSeq.addAlignmentAnnotation(annotation);
+       }
+
+       al.addAnnotation(annotation);
+
+       al.setAnnotationIndex(annotation,  al.getAlignmentAnnotation().length - existingAnnotations-1);
+      }
+
+    }catch(Exception ex)
+    {
+      ex.printStackTrace();
+      System.out.println("Problem reading annotation file: "+ex);
+      return false;
+    }
+    return true;
+  }
+
+  Annotation parseAnnotation(String string)
+  {
+    String desc = "", displayChar="";
+    char ss = ' '; // secondaryStructure
+    float value = 0;
+    boolean parsedValue = false;
+    StringTokenizer st = new StringTokenizer(string, ",");
+    String token;
+    while(st.hasMoreTokens())
+    {
+      token = st.nextToken().trim();
+      if(token.length()==0)
+        continue;
+
+      if(!parsedValue)
+      {
+        try{
+          value = new Float(token).floatValue();
+          displayChar = token;
+          parsedValue = true;
+        }catch(NumberFormatException ex){}
+      }
+
+      if(token.equals("H") || token.equals("E"))
+      {
+        // Either this character represents a helix or sheet
+        // or an integer which can be displayed
+        ss = token.charAt(0);
+      }
+      else if(desc.length()<1)
+        desc = token;
+
+    }
+
+    return new Annotation(displayChar, desc, ss, value);
+  }
+
+  void colourAnnotations(AlignmentI al, String label, String colour)
+  {
+    UserColourScheme ucs = new UserColourScheme(colour);
+    Annotation[] annotations;
+    for(int i=0; i<al.getAlignmentAnnotation().length; i++)
+    {
+      if(al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(label))
+      {
+        annotations = al.getAlignmentAnnotation()[i].annotations;
+        for(int j=0; j<annotations.length; j++)
+        {
+          if(annotations[j]!=null)
+            annotations[j].colour = ucs.findColour("A");
+        }
+      }
+    }
+  }
+
+  void combineAnnotations(AlignmentI al, StringTokenizer st)
+  {
+    int graphGroup = -1;
+    String group = st.nextToken();
+    //First make sure we are not overwriting the graphIndex
+    for(int i=0; i<al.getAlignmentAnnotation().length; i++)
+    {
+      if(al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
+      {
+        graphGroup = al.getAlignmentAnnotation()[i].graphGroup +1;
+        al.getAlignmentAnnotation()[i].graphGroup = graphGroup;
+        break;
+      }
+    }
+
+    //Now update groups
+    while(st.hasMoreTokens())
+    {
+      group = st.nextToken();
+      for(int i=0; i<al.getAlignmentAnnotation().length; i++)
+      {
+        if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
+        {
+          al.getAlignmentAnnotation()[i].graphGroup = graphGroup;
+          break;
+        }
+      }
+    }
+  }
+
+  void addLine(AlignmentI al, StringTokenizer st)
+  {
+    String group = st.nextToken();
+    AlignmentAnnotation annotation = null;
+
+    for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
+    {
+      if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
+      {
+        annotation = al.getAlignmentAnnotation()[i];
+        break;
+      }
+    }
+
+    if(annotation==null)
+      return;
+    float value = new Float(st.nextToken()).floatValue();
+    String label = st.hasMoreTokens() ?  st.nextToken() : null;
+    java.awt.Color colour = null;
+    if(st.hasMoreTokens())
+    {
+      UserColourScheme ucs = new UserColourScheme(st.nextToken());
+      colour = ucs.findColour("A");
+    }
+
+    annotation.setThreshold(new GraphLine(value, label, colour));
+
+  }
+}
diff --git a/src/jalview/io/FeaturesFile.java b/src/jalview/io/FeaturesFile.java
new file mode 100755
index 0000000..a83dff8
--- /dev/null
+++ b/src/jalview/io/FeaturesFile.java
@@ -0,0 +1,381 @@
+/*
+* Jalview - A Sequence Alignment Editor and Viewer
+* Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+*
+* 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+*/
+package jalview.io;
+
+import jalview.datamodel.*;
+
+import java.io.*;
+import java.util.*;
+import jalview.schemes.UserColourScheme;
+
+
+/**
+ * DOCUMENT ME!
+ *
+ * @author $author$
+ * @version $Revision$
+ */
+public class FeaturesFile extends AlignFile
+{
+    /**
+     * Creates a new FeaturesFile object.
+     */
+    public FeaturesFile()
+    {
+    }
+
+    /**
+     * Creates a new FeaturesFile object.
+     *
+     * @param inStr DOCUMENT ME!
+     */
+    public FeaturesFile(String inStr)
+    {
+        super(inStr);
+    }
+
+    /**
+     * Creates a new FeaturesFile object.
+     *
+     * @param inFile DOCUMENT ME!
+     * @param type DOCUMENT ME!
+     *
+     * @throws IOException DOCUMENT ME!
+     */
+    public FeaturesFile(String inFile, String type)
+       throws IOException
+    {
+        super(inFile, type);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @throws IOException DOCUMENT ME!
+     */
+    public boolean parse(AlignmentI align,  Hashtable colours)
+        throws IOException
+    {
+      String line = null;
+      try
+      {
+        SequenceI seq = null;
+        String type, desc, token=null;
+
+        int index, start, end;
+        float score;
+        StringTokenizer st;
+        SequenceFeature sf;
+        String featureGroup = null;
+
+        boolean GFFFile = true;
+
+        while ( (line = nextLine()) != null)
+        {
+          if(line.startsWith("#"))
+            continue;
+
+          st = new StringTokenizer(line, "\t");
+          if (st.countTokens()>1 && st.countTokens() < 4 )
+          {
+            GFFFile = false;
+            type = st.nextToken();
+            if (type.equalsIgnoreCase("startgroup"))
+            {
+              featureGroup = st.nextToken();
+            }
+            else if (type.equalsIgnoreCase("endgroup"))
+            {
+              //We should check whether this is the current group,
+              //but at present theres no way of showing more than 1 group
+              st.nextToken();
+              featureGroup = null;
+            }
+            else
+            {
+              UserColourScheme ucs = new UserColourScheme(st.nextToken());
+              colours.put(type, ucs.findColour("A"));
+            }
+            continue;
+          }
+
+          while (st.hasMoreElements())
+          {
+
+            if(GFFFile)
+            {
+              // Still possible this is an old Jalview file,
+              // which does not have type colours at the beginning
+              token = st.nextToken();
+              seq = align.findName(token);
+              if(seq != null)
+              {
+                desc = st.nextToken();
+                type = st.nextToken();
+                start = Integer.parseInt(st.nextToken());
+                end = Integer.parseInt(st.nextToken());
+                try
+                {
+                  score = Float.parseFloat(st.nextToken());
+                }
+                catch (NumberFormatException ex)
+                {
+                  score = 0;
+                }
+
+                sf = new SequenceFeature(type, desc, start, end, score, null);
+
+                try
+                {
+                  sf.setValue("STRAND", st.nextToken());
+                  sf.setValue("FRAME", st.nextToken());
+                }
+                catch (Exception ex)
+                {}
+
+                seq.getDatasetSequence().addSequenceFeature(sf);
+
+                break;
+              }
+            }
+
+            if(GFFFile && seq==null)
+            {
+              desc = token;
+            }
+            else
+              desc = st.nextToken();
+
+
+            token = st.nextToken();
+            if (!token.equals("ID_NOT_SPECIFIED"))
+            {
+              seq = align.findName(token);
+              st.nextToken();
+            }
+            else
+            {
+              try{
+                index = Integer.parseInt(st.nextToken());
+                seq = align.getSequenceAt(index);
+              }
+              catch(NumberFormatException ex)
+              {
+                seq = null;
+              }
+            }
+
+            if(seq==null)
+            {
+              System.out.println("Sequence not found: "+line);
+              break;
+            }
+
+            start = Integer.parseInt(st.nextToken());
+            end = Integer.parseInt(st.nextToken());
+
+            type = st.nextToken();
+
+            if (!colours.containsKey(type))
+            {
+              // Probably the old style groups file
+              UserColourScheme ucs = new UserColourScheme(type);
+              colours.put(type, ucs.findColour("A"));
+            }
+
+            sf = new SequenceFeature(type, desc, "", start, end, featureGroup);
+
+            seq.getDatasetSequence().addSequenceFeature(sf);
+
+            //If we got here, its not a GFFFile
+            GFFFile = false;
+          }
+        }
+      }
+      catch (Exception ex)
+      {
+        System.out.println(line);
+        ex.printStackTrace();
+        System.out.println("Error parsing groups file: " + ex +"\n"+line);
+        return false;
+      }
+
+      return true;
+
+    }
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param s DOCUMENT ME!
+     * @param len DOCUMENT ME!
+     * @param gaps DOCUMENT ME!
+     * @param displayId DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public String printJalviewFormat(SequenceI [] seqs,
+                                     Hashtable visible)
+    {
+        StringBuffer out = new StringBuffer();
+        SequenceFeature [] next;
+
+        if(visible==null || visible.size()<1)
+          return "No Features Visible";
+
+        Enumeration en = visible.keys();
+        String type;
+        int color;
+        while( en.hasMoreElements() )
+        {
+          type = en.nextElement().toString();
+          color = Integer.parseInt( visible.get(type).toString() );
+          out.append(type + "\t"
+                     + jalview.util.Format.getHexString(
+                         new java.awt.Color(color)  )
+                     +"\n");
+        }
+
+        //Work out which groups are both present and visible
+        Vector groups = new Vector();
+        int groupIndex = 0;
+
+        for(int i=0; i<seqs.length; i++)
+        {
+          next = seqs[i].getSequenceFeatures();
+          if(next!=null)
+          {
+            for(int j=0; j<next.length; j++)
+            {
+              if (!visible.containsKey(next[j].type))
+                continue;
+
+              if (    next[j].featureGroup != null
+                  && !groups.contains(next[j].featureGroup))
+                groups.addElement(next[j].featureGroup);
+            }
+          }
+        }
+
+        String group = null;
+
+        do
+        {
+          if (groups.size() > 0)
+          {
+            group = groups.elementAt(groupIndex).toString();
+            out.append("\nSTARTGROUP\t" + group + "\n");
+          }
+
+
+          for (int i = 0; i < seqs.length; i++)
+          {
+            next = seqs[i].getSequenceFeatures();
+            if (next != null)
+            {
+              for (int j = 0; j < next.length; j++)
+              {
+                if (!visible.containsKey(next[j].type))
+                  continue;
+
+                if (group != null && !next[j].featureGroup.equals(group))
+                  continue;
+
+                if(next[j].description==null || next[j].description.equals(""))
+                  out.append(next[j].type+"\t");
+                else
+                  out.append(next[j].description + "\t");
+
+                out.append(  seqs[i].getName() + "\t-1\t"
+                           + next[j].begin + "\t"
+                           + next[j].end + "\t"
+                           + next[j].type + "\n"
+                    );
+              }
+            }
+          }
+
+          if(groups.size()>0)
+          {
+            out.append("ENDGROUP\t"+group+"\n");
+          }
+
+          groupIndex++;
+        }
+        while(groupIndex < groups.size());
+
+
+      return out.toString();
+    }
+
+    public String printGFFFormat(SequenceI [] seqs, Hashtable visible)
+    {
+      StringBuffer out = new StringBuffer();
+      SequenceFeature [] next;
+
+      for(int i=0; i<seqs.length; i++)
+      {
+        if(seqs[i].getSequenceFeatures()!=null)
+        {
+          next = seqs[i].getSequenceFeatures();
+          for(int j=0; j<next.length; j++)
+          {
+            if(!visible.containsKey(next[j].type))
+              continue;
+
+            out.append(seqs[i].getName() + "\t"
+                       + next[j].description + "\t"
+                       + next[j].type  + "\t"
+                       + next[j].begin + "\t"
+                       + next[j].end   + "\t"
+                       + next[j].score + "\t"
+                      );
+
+            if(next[j].getValue("STRAND")!=null)
+              out.append(next[j].getValue("STRAND")+"\t");
+            else
+              out.append(".\t");
+            if(next[j].getValue("FRAME")!=null)
+              out.append(next[j].getValue("FRAME")+"\n");
+            else
+              out.append(".\n");
+
+          }
+        }
+      }
+
+      return out.toString();
+    }
+
+    public void parse()
+    {
+      //IGNORED
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public String print()
+    {
+        return "USE printGFFFormat() or printJalviewFormat()";
+    }
+}