source formatting
authorjprocter <jprocter@compbio.dundee.ac.uk>
Thu, 15 Nov 2012 15:18:29 +0000 (15:18 +0000)
committerjprocter <jprocter@compbio.dundee.ac.uk>
Thu, 15 Nov 2012 15:18:29 +0000 (15:18 +0000)
src/jalview/analysis/StructureFrequency.java
src/jalview/io/FeaturesFile.java
src/jalview/io/IdentifyFile.java
src/jalview/io/JalviewFileChooser.java
src/jalview/renderer/AnnotationRenderer.java
src/jalview/schemes/RNAInteractionColourScheme.java
src/jalview/workers/StrucConsensusThread.java
src/jalview/ws/HttpClientUtils.java
src/jalview/ws/jws1/Annotate3D.java

index d57e1c5..32a4e29 100644 (file)
@@ -254,7 +254,6 @@ public class StructureFrequency
         residueHash.put(PID_GAPS, new Float(percentage));
 
         result[bpEnd] = residueHash;
-        
       }
     }
   }
index abf89d5..afbd223 100755 (executable)
  * 
  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  */
-package jalview.io;\r
-\r
-import java.io.*;\r
-import java.util.*;\r
-\r
-import javax.xml.parsers.ParserConfigurationException;\r
-\r
-import org.xml.sax.SAXException;\r
-\r
-import fr.orsay.lri.varna.exceptions.ExceptionFileFormatOrSyntax;\r
-import fr.orsay.lri.varna.exceptions.ExceptionLoadingFailed;\r
-import fr.orsay.lri.varna.exceptions.ExceptionPermissionDenied;\r
-import fr.orsay.lri.varna.exceptions.ExceptionUnmatchedClosingParentheses;\r
-\r
-import jalview.analysis.SequenceIdMatcher;\r
-import jalview.datamodel.*;\r
-import jalview.schemes.*;\r
-import jalview.util.Format;\r
-\r
-/**\r
- * Parse and create Jalview Features files Detects GFF format features files and\r
- * parses. Does not implement standard print() - call specific printFeatures or\r
- * printGFF. Uses AlignmentI.findSequence(String id) to find the sequence object\r
- * for the features annotation - this normally works on an exact match.\r
- * \r
- * @author AMW\r
- * @version $Revision$\r
- */\r
-public class FeaturesFile extends AlignFile\r
-{\r
-  /**\r
-   * work around for GFF interpretation bug where source string becomes\r
-   * description rather than a group\r
-   */\r
-  private boolean doGffSource = true;\r
-\r
-  /**\r
-   * Creates a new FeaturesFile object.\r
-   */\r
-  public FeaturesFile()\r
-  {\r
-  }\r
-\r
-  /**\r
-   * Creates a new FeaturesFile object.\r
-   * \r
-   * @param inFile\r
-   *          DOCUMENT ME!\r
-   * @param type\r
-   *          DOCUMENT ME!\r
-   * \r
-   * @throws IOException\r
-   *           DOCUMENT ME!\r
- * @throws SAXException \r
- * @throws ParserConfigurationException \r
- * @throws ExceptionFileFormatOrSyntax \r
- * @throws ExceptionLoadingFailed \r
- * @throws ExceptionPermissionDenied \r
- * @throws InterruptedException \r
- * @throws ExceptionUnmatchedClosingParentheses \r
-   */\r
-  public FeaturesFile(String inFile, String type) throws IOException, ExceptionFileFormatOrSyntax, ParserConfigurationException, SAXException, ExceptionPermissionDenied, ExceptionLoadingFailed, InterruptedException, ExceptionUnmatchedClosingParentheses\r
-  {\r
-    super(inFile, type);\r
-  }\r
-\r
-  public FeaturesFile(FileParse source) throws IOException, ExceptionFileFormatOrSyntax, ParserConfigurationException, SAXException, ExceptionPermissionDenied, ExceptionLoadingFailed, InterruptedException, ExceptionUnmatchedClosingParentheses\r
-  {\r
-    super(source);\r
-  }\r
-\r
-  /**\r
-   * Parse GFF or sequence features file using case-independent matching, discarding URLs\r
-   * @param align - alignment/dataset containing sequences that are to be annotated\r
-   * @param colours - hashtable to store feature colour definitions\r
-   * @param removeHTML - process html strings into plain text\r
-   * @return true if features were added\r
-   */\r
-  public boolean parse(AlignmentI align, Hashtable colours,\r
-          boolean removeHTML)\r
-  {\r
-    return parse(align, colours, null, removeHTML, false);\r
-  }\r
-\r
-  /**\r
-   * Parse GFF or sequence features file optionally using case-independent matching, discarding URLs\r
-   * @param align - alignment/dataset containing sequences that are to be annotated\r
-   * @param colours - hashtable to store feature colour definitions\r
-   * @param removeHTML - process html strings into plain text\r
-   * @param relaxedIdmatching - when true, ID matches to compound sequence IDs are allowed\r
-   * @return true if features were added\r
-   */\r
-  public boolean parse(AlignmentI align, \r
-          Map colours, boolean removeHTML, boolean relaxedIdMatching)\r
-  {\r
-    return parse(align, colours, null, removeHTML, relaxedIdMatching);\r
-  }\r
-\r
-  /**\r
-   * Parse GFF or sequence features file optionally using case-independent matching\r
-   * @param align - alignment/dataset containing sequences that are to be annotated\r
-   * @param colours - hashtable to store feature colour definitions\r
-   * @param featureLink - hashtable to store associated URLs \r
-   * @param removeHTML - process html strings into plain text\r
-   * @return true if features were added\r
-   */\r
-  public boolean parse(AlignmentI align, Map colours,\r
-          Map featureLink, boolean removeHTML)\r
-  {\r
-    return parse(align, colours, featureLink, removeHTML, false);\r
-  }\r
-\r
-  /**\r
-  /**\r
-   * Parse GFF or sequence features file \r
-   * @param align - alignment/dataset containing sequences that are to be annotated\r
-   * @param colours - hashtable to store feature colour definitions\r
-   * @param featureLink - hashtable to store associated URLs \r
-   * @param removeHTML - process html strings into plain text\r
-   * @param relaxedIdmatching - when true, ID matches to compound sequence IDs are allowed\r
-   * @return true if features were added\r
-   */\r
-  public boolean parse(AlignmentI align,\r
-          Map colours, Map featureLink, boolean removeHTML, boolean relaxedIdmatching)\r
-  {\r
-\r
-    String line = null;\r
-    try\r
-    {\r
-      SequenceI seq = null;\r
-      String type, desc, token = null;\r
-\r
-      int index, start, end;\r
-      float score;\r
-      StringTokenizer st;\r
-      SequenceFeature sf;\r
-      String featureGroup = null, groupLink = null;\r
-      Map typeLink = new Hashtable();\r
-      /**\r
-       * when true, assume GFF style features rather than Jalview style.\r
-       */\r
-      boolean GFFFile = true;\r
-      while ((line = nextLine()) != null)\r
-      {\r
-        if (line.startsWith("#"))\r
-        {\r
-          continue;\r
-        }\r
-\r
-        st = new StringTokenizer(line, "\t");\r
-        if (st.countTokens() == 1)\r
-        {\r
-          if (line.trim().equalsIgnoreCase("GFF"))\r
-          {\r
-            // Start parsing file as if it might be GFF again.\r
-            GFFFile = true;\r
-            continue;\r
-          }\r
-        }\r
-        if (st.countTokens() > 1 && st.countTokens() < 4)\r
-        {\r
-          GFFFile = false;\r
-          type = st.nextToken();\r
-          if (type.equalsIgnoreCase("startgroup"))\r
-          {\r
-            featureGroup = st.nextToken();\r
-            if (st.hasMoreElements())\r
-            {\r
-              groupLink = st.nextToken();\r
-              featureLink.put(featureGroup, groupLink);\r
-            }\r
-          }\r
-          else if (type.equalsIgnoreCase("endgroup"))\r
-          {\r
-            // We should check whether this is the current group,\r
-            // but at present theres no way of showing more than 1 group\r
-            st.nextToken();\r
-            featureGroup = null;\r
-            groupLink = null;\r
-          }\r
-          else\r
-          {\r
-            Object colour = null;\r
-            String colscheme = st.nextToken();\r
-            if (colscheme.indexOf("|") > -1\r
-                    || colscheme.trim().equalsIgnoreCase("label"))\r
-            {\r
-              // Parse '|' separated graduated colourscheme fields:\r
-              // [label|][mincolour|maxcolour|[absolute|]minvalue|maxvalue|thresholdtype|thresholdvalue]\r
-              // can either provide 'label' only, first is optional, next two\r
-              // colors are required (but may be\r
-              // left blank), next is optional, nxt two min/max are required.\r
-              // first is either 'label'\r
-              // first/second and third are both hexadecimal or word equivalent\r
-              // colour.\r
-              // next two are values parsed as floats.\r
-              // fifth is either 'above','below', or 'none'.\r
-              // sixth is a float value and only required when fifth is either\r
-              // 'above' or 'below'.\r
-              StringTokenizer gcol = new StringTokenizer(colscheme, "|",\r
-                      true);\r
-              // set defaults\r
-              int threshtype = AnnotationColourGradient.NO_THRESHOLD;\r
-              float min = Float.MIN_VALUE, max = Float.MAX_VALUE, threshval = Float.NaN;\r
-              boolean labelCol = false;\r
-              // Parse spec line\r
-              String mincol = gcol.nextToken();\r
-              if (mincol == "|")\r
-              {\r
-                System.err\r
-                        .println("Expected either 'label' or a colour specification in the line: "\r
-                                + line);\r
-                continue;\r
-              }\r
-              String maxcol = null;\r
-              if (mincol.toLowerCase().indexOf("label") == 0)\r
-              {\r
-                labelCol = true;\r
-                mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); // skip\r
-                                                                           // '|'\r
-                mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null);\r
-              }\r
-              String abso = null, minval, maxval;\r
-              if (mincol != null)\r
-              {\r
-                // at least four more tokens\r
-                if (mincol.equals("|"))\r
-                {\r
-                  mincol = "";\r
-                }\r
-                else\r
-                {\r
-                  gcol.nextToken(); // skip next '|'\r
-                }\r
-                // continue parsing rest of line\r
-                maxcol = gcol.nextToken();\r
-                if (maxcol.equals("|"))\r
-                {\r
-                  maxcol = "";\r
-                }\r
-                else\r
-                {\r
-                  gcol.nextToken(); // skip next '|'\r
-                }\r
-                abso = gcol.nextToken();\r
-                gcol.nextToken(); // skip next '|'\r
-                if (abso.toLowerCase().indexOf("abso") != 0)\r
-                {\r
-                  minval = abso;\r
-                  abso = null;\r
-                }\r
-                else\r
-                {\r
-                  minval = gcol.nextToken();\r
-                  gcol.nextToken(); // skip next '|'\r
-                }\r
-                maxval = gcol.nextToken();\r
-                if (gcol.hasMoreTokens())\r
-                {\r
-                  gcol.nextToken(); // skip next '|'\r
-                }\r
-                try\r
-                {\r
-                  if (minval.length() > 0)\r
-                  {\r
-                    min = new Float(minval).floatValue();\r
-                  }\r
-                } catch (Exception e)\r
-                {\r
-                  System.err\r
-                          .println("Couldn't parse the minimum value for graduated colour for type ("\r
-                                  + colscheme\r
-                                  + ") - did you misspell 'auto' for the optional automatic colour switch ?");\r
-                  e.printStackTrace();\r
-                }\r
-                try\r
-                {\r
-                  if (maxval.length() > 0)\r
-                  {\r
-                    max = new Float(maxval).floatValue();\r
-                  }\r
-                } catch (Exception e)\r
-                {\r
-                  System.err\r
-                          .println("Couldn't parse the maximum value for graduated colour for type ("\r
-                                  + colscheme + ")");\r
-                  e.printStackTrace();\r
-                }\r
-              }\r
-              else\r
-              {\r
-                // add in some dummy min/max colours for the label-only\r
-                // colourscheme.\r
-                mincol = "FFFFFF";\r
-                maxcol = "000000";\r
-              }\r
-              try\r
-              {\r
-                colour = new jalview.schemes.GraduatedColor(\r
-                        new UserColourScheme(mincol).findColour('A'),\r
-                        new UserColourScheme(maxcol).findColour('A'), min,\r
-                        max);\r
-              } catch (Exception e)\r
-              {\r
-                System.err\r
-                        .println("Couldn't parse the graduated colour scheme ("\r
-                                + colscheme + ")");\r
-                e.printStackTrace();\r
-              }\r
-              if (colour != null)\r
-              {\r
-                ((jalview.schemes.GraduatedColor) colour)\r
-                        .setColourByLabel(labelCol);\r
-                ((jalview.schemes.GraduatedColor) colour)\r
-                        .setAutoScaled(abso == null);\r
-                // add in any additional parameters\r
-                String ttype = null, tval = null;\r
-                if (gcol.hasMoreTokens())\r
-                {\r
-                  // threshold type and possibly a threshold value\r
-                  ttype = gcol.nextToken();\r
-                  if (ttype.toLowerCase().startsWith("below"))\r
-                  {\r
-                    ((jalview.schemes.GraduatedColor) colour)\r
-                            .setThreshType(AnnotationColourGradient.BELOW_THRESHOLD);\r
-                  }\r
-                  else if (ttype.toLowerCase().startsWith("above"))\r
-                  {\r
-                    ((jalview.schemes.GraduatedColor) colour)\r
-                            .setThreshType(AnnotationColourGradient.ABOVE_THRESHOLD);\r
-                  }\r
-                  else\r
-                  {\r
-                    ((jalview.schemes.GraduatedColor) colour)\r
-                            .setThreshType(AnnotationColourGradient.NO_THRESHOLD);\r
-                    if (!ttype.toLowerCase().startsWith("no"))\r
-                    {\r
-                      System.err\r
-                              .println("Ignoring unrecognised threshold type : "\r
-                                      + ttype);\r
-                    }\r
-                  }\r
-                }\r
-                if (((GraduatedColor) colour).getThreshType() != AnnotationColourGradient.NO_THRESHOLD)\r
-                {\r
-                  try\r
-                  {\r
-                    gcol.nextToken();\r
-                    tval = gcol.nextToken();\r
-                    ((jalview.schemes.GraduatedColor) colour)\r
-                            .setThresh(new Float(tval).floatValue());\r
-                  } catch (Exception e)\r
-                  {\r
-                    System.err\r
-                            .println("Couldn't parse threshold value as a float: ("\r
-                                    + tval + ")");\r
-                    e.printStackTrace();\r
-                  }\r
-                }\r
-                // parse the thresh-is-min token ?\r
-                if (gcol.hasMoreTokens())\r
-                {\r
-                  System.err\r
-                          .println("Ignoring additional tokens in parameters in graduated colour specification\n");\r
-                  while (gcol.hasMoreTokens())\r
-                  {\r
-                    System.err.println("|" + gcol.nextToken());\r
-                  }\r
-                  System.err.println("\n");\r
-                }\r
-              }\r
-            }\r
-            else\r
-            {\r
-              UserColourScheme ucs = new UserColourScheme(colscheme);\r
-              colour = ucs.findColour('A');\r
-            }\r
-            if (colour != null)\r
-            {\r
-              colours.put(type, colour);\r
-            }\r
-            if (st.hasMoreElements())\r
-            {\r
-              String link = st.nextToken();\r
-              typeLink.put(type, link);\r
-              if (featureLink == null)\r
-              {\r
-                featureLink = new Hashtable();\r
-              }\r
-              featureLink.put(type, link);\r
-            }\r
-          }\r
-          continue;\r
-        }\r
-        String seqId = "";\r
-        while (st.hasMoreElements())\r
-        {\r
-\r
-          if (GFFFile)\r
-          {\r
-            // Still possible this is an old Jalview file,\r
-            // which does not have type colours at the beginning\r
-            seqId = token = st.nextToken();\r
-            seq = findName(align, seqId, relaxedIdmatching);\r
-            if (seq != null)\r
-            {\r
-              desc = st.nextToken();\r
-              String group = null;\r
-              if (doGffSource && desc.indexOf(' ') == -1)\r
-              {\r
-                // could also be a source term rather than description line\r
-                group = new String(desc);\r
-              }\r
-              type = st.nextToken();\r
-              try\r
-              {\r
-                String stt = st.nextToken();\r
-                if (stt.length() == 0 || stt.equals("-"))\r
-                {\r
-                  start = 0;\r
-                }\r
-                else\r
-                {\r
-                  start = Integer.parseInt(stt);\r
-                }\r
-              } catch (NumberFormatException ex)\r
-              {\r
-                start = 0;\r
-              }\r
-              try\r
-              {\r
-                String stt = st.nextToken();\r
-                if (stt.length() == 0 || stt.equals("-"))\r
-                {\r
-                  end = 0;\r
-                }\r
-                else\r
-                {\r
-                  end = Integer.parseInt(stt);\r
-                }\r
-              } catch (NumberFormatException ex)\r
-              {\r
-                end = 0;\r
-              }\r
-              // TODO: decide if non positional feature assertion for input data\r
-              // where end==0 is generally valid\r
-              if (end == 0)\r
-              {\r
-                // treat as non-positional feature, regardless.\r
-                start = 0;\r
-              }\r
-              try\r
-              {\r
-                score = new Float(st.nextToken()).floatValue();\r
-              } catch (NumberFormatException ex)\r
-              {\r
-                score = 0;\r
-              }\r
-\r
-              sf = new SequenceFeature(type, desc, start, end, score, group);\r
-\r
-              try\r
-              {\r
-                sf.setValue("STRAND", st.nextToken());\r
-                sf.setValue("FRAME", st.nextToken());\r
-              } catch (Exception ex)\r
-              {\r
-              }\r
-\r
-              if (st.hasMoreTokens())\r
-              {\r
-                StringBuffer attributes = new StringBuffer();\r
-                while (st.hasMoreTokens())\r
-                {\r
-                  attributes.append("\t" + st.nextElement());\r
-                }\r
-                // TODO validate and split GFF2 attributes field ? parse out\r
-                // ([A-Za-z][A-Za-z0-9_]*) <value> ; and add as\r
-                // sf.setValue(attrib, val);\r
-                sf.setValue("ATTRIBUTES", attributes.toString());\r
-              }\r
-\r
-              seq.addSequenceFeature(sf);\r
-              while ((seq = align.findName(seq, seqId, true)) != null)\r
-              {\r
-                seq.addSequenceFeature(new SequenceFeature(sf));\r
-              }\r
-              break;\r
-            }\r
-          }\r
-\r
-          if (GFFFile && seq == null)\r
-          {\r
-            desc = token;\r
-          }\r
-          else\r
-          {\r
-            desc = st.nextToken();\r
-          }\r
-          if (!st.hasMoreTokens())\r
-          {\r
-            System.err\r
-                    .println("DEBUG: Run out of tokens when trying to identify the destination for the feature.. giving up.");\r
-            // in all probability, this isn't a file we understand, so bail\r
-            // quietly.\r
-            return false;\r
-          }\r
-\r
-          token = st.nextToken();\r
-\r
-          if (!token.equals("ID_NOT_SPECIFIED"))\r
-          {\r
-            seq = findName(align, seqId = token, relaxedIdmatching);\r
-            st.nextToken();\r
-          }\r
-          else\r
-          {\r
-            seqId = null;\r
-            try\r
-            {\r
-              index = Integer.parseInt(st.nextToken());\r
-              seq = align.getSequenceAt(index);\r
-            } catch (NumberFormatException ex)\r
-            {\r
-              seq = null;\r
-            }\r
-          }\r
-\r
-          if (seq == null)\r
-          {\r
-            System.out.println("Sequence not found: " + line);\r
-            break;\r
-          }\r
-\r
-          start = Integer.parseInt(st.nextToken());\r
-          end = Integer.parseInt(st.nextToken());\r
-\r
-          type = st.nextToken();\r
-\r
-          if (!colours.containsKey(type))\r
-          {\r
-            // Probably the old style groups file\r
-            UserColourScheme ucs = new UserColourScheme(type);\r
-            colours.put(type, ucs.findColour('A'));\r
-          }\r
-          sf = new SequenceFeature(type, desc, "", start, end, featureGroup);\r
-          if (st.hasMoreTokens())\r
-          {\r
-            try\r
-            {\r
-              score = new Float(st.nextToken()).floatValue();\r
-              // update colourgradient bounds if allowed to\r
-            } catch (NumberFormatException ex)\r
-            {\r
-              score = 0;\r
-            }\r
-            sf.setScore(score);\r
-          }\r
-          if (groupLink != null && removeHTML)\r
-          {\r
-            sf.addLink(groupLink);\r
-            sf.description += "%LINK%";\r
-          }\r
-          if (typeLink.containsKey(type) && removeHTML)\r
-          {\r
-            sf.addLink(typeLink.get(type).toString());\r
-            sf.description += "%LINK%";\r
-          }\r
-\r
-          parseDescriptionHTML(sf, removeHTML);\r
-\r
-          seq.addSequenceFeature(sf);\r
-\r
-          while (seqId != null\r
-                  && (seq = align.findName(seq, seqId, false)) != null)\r
-          {\r
-            seq.addSequenceFeature(new SequenceFeature(sf));\r
-          }\r
-          // If we got here, its not a GFFFile\r
-          GFFFile = false;\r
-        }\r
-      }\r
-      resetMatcher();\r
-    } catch (Exception ex)\r
-    {\r
-      System.out.println(line);\r
-      System.out.println("Error parsing feature file: " + ex + "\n" + line);\r
-      ex.printStackTrace(System.err);\r
-      resetMatcher();\r
-      return false;\r
-    }\r
-\r
-    return true;\r
-  }\r
-\r
-  private AlignmentI lastmatchedAl = null;\r
-\r
-  private SequenceIdMatcher matcher = null;\r
-\r
-  /**\r
-   * clear any temporary handles used to speed up ID matching\r
-   */\r
-  private void resetMatcher()\r
-  {\r
-    lastmatchedAl = null;\r
-    matcher = null;\r
-  }\r
-\r
-  private SequenceI findName(AlignmentI align, String seqId,\r
-          boolean relaxedIdMatching)\r
-  {\r
-    SequenceI match = null;\r
-    if (relaxedIdMatching)\r
-    {\r
-      if (lastmatchedAl != align)\r
-      {\r
-        matcher = new SequenceIdMatcher(\r
-                (lastmatchedAl = align).getSequencesArray());\r
-      }\r
-      match = matcher.findIdMatch(seqId);\r
-    }\r
-    else\r
-    {\r
-      match = align.findName(seqId, true);\r
-    }\r
-    return match;\r
-  }\r
-\r
-  public void parseDescriptionHTML(SequenceFeature sf, boolean removeHTML)\r
-  {\r
-    if (sf.getDescription() == null)\r
-    {\r
-      return;\r
-    }\r
-    jalview.util.ParseHtmlBodyAndLinks parsed = new jalview.util.ParseHtmlBodyAndLinks(sf.getDescription(), removeHTML, newline);\r
-\r
-    sf.description = (removeHTML) ? parsed.getNonHtmlContent() : sf.description;\r
-    for (String link:parsed.getLinks())\r
-    {\r
-      sf.addLink(link);\r
-    }\r
-\r
-  }\r
-\r
-  /**\r
-   * generate a features file for seqs includes non-pos features by default.\r
-   * \r
-   * @param seqs\r
-   *          source of sequence features\r
-   * @param visible\r
-   *          hash of feature types and colours\r
-   * @return features file contents\r
-   */\r
-  public String printJalviewFormat(SequenceI[] seqs, Hashtable visible)\r
-  {\r
-    return printJalviewFormat(seqs, visible, true, true);\r
-  }\r
-\r
-  /**\r
-   * generate a features file for seqs with colours from visible (if any)\r
-   * \r
-   * @param seqs\r
-   *          source of features\r
-   * @param visible\r
-   *          hash of Colours for each feature type\r
-   * @param visOnly\r
-   *          when true only feature types in 'visible' will be output\r
-   * @param nonpos\r
-   *          indicates if non-positional features should be output (regardless\r
-   *          of group or type)\r
-   * @return features file contents\r
-   */\r
-  public String printJalviewFormat(SequenceI[] seqs, Hashtable visible,\r
-          boolean visOnly, boolean nonpos)\r
-  {\r
-    StringBuffer out = new StringBuffer();\r
-    SequenceFeature[] next;\r
-    boolean featuresGen = false;\r
-    if (visOnly && !nonpos && (visible == null || visible.size() < 1))\r
-    {\r
-      // no point continuing.\r
-      return "No Features Visible";\r
-    }\r
-\r
-    if (visible != null && visOnly)\r
-    {\r
-      // write feature colours only if we're given them and we are generating\r
-      // viewed features\r
-      // TODO: decide if feature links should also be written here ?\r
-      Enumeration en = visible.keys();\r
-      String type, color;\r
-      while (en.hasMoreElements())\r
-      {\r
-        type = en.nextElement().toString();\r
-\r
-        if (visible.get(type) instanceof GraduatedColor)\r
-        {\r
-          GraduatedColor gc = (GraduatedColor) visible.get(type);\r
-          color = (gc.isColourByLabel() ? "label|" : "")\r
-                  + Format.getHexString(gc.getMinColor()) + "|"\r
-                  + Format.getHexString(gc.getMaxColor())\r
-                  + (gc.isAutoScale() ? "|" : "|abso|") + gc.getMin() + "|"\r
-                  + gc.getMax() + "|";\r
-          if (gc.getThreshType() != AnnotationColourGradient.NO_THRESHOLD)\r
-          {\r
-            if (gc.getThreshType() == AnnotationColourGradient.BELOW_THRESHOLD)\r
-            {\r
-              color += "below";\r
-            }\r
-            else\r
-            {\r
-              if (gc.getThreshType() != AnnotationColourGradient.ABOVE_THRESHOLD)\r
-              {\r
-                System.err.println("WARNING: Unsupported threshold type ("\r
-                        + gc.getThreshType() + ") : Assuming 'above'");\r
-              }\r
-              color += "above";\r
-            }\r
-            // add the value\r
-            color += "|" + gc.getThresh();\r
-          }\r
-          else\r
-          {\r
-            color += "none";\r
-          }\r
-        }\r
-        else if (visible.get(type) instanceof java.awt.Color)\r
-        {\r
-          color = Format.getHexString((java.awt.Color) visible.get(type));\r
-        }\r
-        else\r
-        {\r
-          // legacy support for integer objects containing colour triplet values\r
-          color = Format.getHexString(new java.awt.Color(Integer\r
-                  .parseInt(visible.get(type).toString())));\r
-        }\r
-        out.append(type);\r
-        out.append("\t");\r
-        out.append(color);\r
-        out.append(newline);\r
-      }\r
-    }\r
-    // Work out which groups are both present and visible\r
-    Vector groups = new Vector();\r
-    int groupIndex = 0;\r
-    boolean isnonpos = false;\r
-\r
-    for (int i = 0; i < seqs.length; i++)\r
-    {\r
-      next = seqs[i].getSequenceFeatures();\r
-      if (next != null)\r
-      {\r
-        for (int j = 0; j < next.length; j++)\r
-        {\r
-          isnonpos = next[j].begin == 0 && next[j].end == 0;\r
-          if ((!nonpos && isnonpos)\r
-                  || (!isnonpos && visOnly && !visible\r
-                          .containsKey(next[j].type)))\r
-          {\r
-            continue;\r
-          }\r
-\r
-          if (next[j].featureGroup != null\r
-                  && !groups.contains(next[j].featureGroup))\r
-          {\r
-            groups.addElement(next[j].featureGroup);\r
-          }\r
-        }\r
-      }\r
-    }\r
-\r
-    String group = null;\r
-    do\r
-    {\r
-\r
-      if (groups.size() > 0 && groupIndex < groups.size())\r
-      {\r
-        group = groups.elementAt(groupIndex).toString();\r
-        out.append(newline);\r
-        out.append("STARTGROUP\t");\r
-        out.append(group);\r
-        out.append(newline);\r
-      }\r
-      else\r
-      {\r
-        group = null;\r
-      }\r
-\r
-      for (int i = 0; i < seqs.length; i++)\r
-      {\r
-        next = seqs[i].getSequenceFeatures();\r
-        if (next != null)\r
-        {\r
-          for (int j = 0; j < next.length; j++)\r
-          {\r
-            isnonpos = next[j].begin == 0 && next[j].end == 0;\r
-            if ((!nonpos && isnonpos)\r
-                    || (!isnonpos && visOnly && !visible\r
-                            .containsKey(next[j].type)))\r
-            {\r
-              // skip if feature is nonpos and we ignore them or if we only\r
-              // output visible and it isn't non-pos and it's not visible\r
-              continue;\r
-            }\r
-\r
-            if (group != null\r
-                    && (next[j].featureGroup == null || !next[j].featureGroup\r
-                            .equals(group)))\r
-            {\r
-              continue;\r
-            }\r
-\r
-            if (group == null && next[j].featureGroup != null)\r
-            {\r
-              continue;\r
-            }\r
-            // we have features to output\r
-            featuresGen = true;\r
-            if (next[j].description == null\r
-                    || next[j].description.equals(""))\r
-            {\r
-              out.append(next[j].type + "\t");\r
-            }\r
-            else\r
-            {\r
-              if (next[j].links != null\r
-                      && next[j].getDescription().indexOf("<html>") == -1)\r
-              {\r
-                out.append("<html>");\r
-              }\r
-\r
-              out.append(next[j].description + " ");\r
-              if (next[j].links != null)\r
-              {\r
-                for (int l = 0; l < next[j].links.size(); l++)\r
-                {\r
-                  String label = next[j].links.elementAt(l).toString();\r
-                  String href = label.substring(label.indexOf("|") + 1);\r
-                  label = label.substring(0, label.indexOf("|"));\r
-\r
-                  if (next[j].description.indexOf(href) == -1)\r
-                  {\r
-                    out.append("<a href=\"" + href + "\">" + label + "</a>");\r
-                  }\r
-                }\r
-\r
-                if (next[j].getDescription().indexOf("</html>") == -1)\r
-                {\r
-                  out.append("</html>");\r
-                }\r
-              }\r
-\r
-              out.append("\t");\r
-            }\r
-            out.append(seqs[i].getName());\r
-            out.append("\t-1\t");\r
-            out.append(next[j].begin);\r
-            out.append("\t");\r
-            out.append(next[j].end);\r
-            out.append("\t");\r
-            out.append(next[j].type);\r
-            if (next[j].score != Float.NaN)\r
-            {\r
-              out.append("\t");\r
-              out.append(next[j].score);\r
-            }\r
-            out.append(newline);\r
-          }\r
-        }\r
-      }\r
-\r
-      if (group != null)\r
-      {\r
-        out.append("ENDGROUP\t");\r
-        out.append(group);\r
-        out.append(newline);\r
-        groupIndex++;\r
-      }\r
-      else\r
-      {\r
-        break;\r
-      }\r
-\r
-    } while (groupIndex < groups.size() + 1);\r
-\r
-    if (!featuresGen)\r
-    {\r
-      return "No Features Visible";\r
-    }\r
-\r
-    return out.toString();\r
-  }\r
-\r
-  /**\r
-   * generate a gff file for sequence features includes non-pos features by\r
-   * default.\r
-   * \r
-   * @param seqs\r
-   * @param visible\r
-   * @return\r
-   */\r
-  public String printGFFFormat(SequenceI[] seqs, Hashtable visible)\r
-  {\r
-    return printGFFFormat(seqs, visible, true, true);\r
-  }\r
-\r
-  public String printGFFFormat(SequenceI[] seqs, Hashtable visible,\r
-          boolean visOnly, boolean nonpos)\r
-  {\r
-    StringBuffer out = new StringBuffer();\r
-    SequenceFeature[] next;\r
-    String source;\r
-    boolean isnonpos;\r
-    for (int i = 0; i < seqs.length; i++)\r
-    {\r
-      if (seqs[i].getSequenceFeatures() != null)\r
-      {\r
-        next = seqs[i].getSequenceFeatures();\r
-        for (int j = 0; j < next.length; j++)\r
-        {\r
-          isnonpos = next[j].begin == 0 && next[j].end == 0;\r
-          if ((!nonpos && isnonpos)\r
-                  || (!isnonpos && visOnly && !visible\r
-                          .containsKey(next[j].type)))\r
-          {\r
-            continue;\r
-          }\r
-\r
-          source = next[j].featureGroup;\r
-          if (source == null)\r
-          {\r
-            source = next[j].getDescription();\r
-          }\r
-\r
-          out.append(seqs[i].getName());\r
-          out.append("\t");\r
-          out.append(source);\r
-          out.append("\t");\r
-          out.append(next[j].type);\r
-          out.append("\t");\r
-          out.append(next[j].begin);\r
-          out.append("\t");\r
-          out.append(next[j].end);\r
-          out.append("\t");\r
-          out.append(next[j].score);\r
-          out.append("\t");\r
-\r
-          if (next[j].getValue("STRAND") != null)\r
-          {\r
-            out.append(next[j].getValue("STRAND"));\r
-            out.append("\t");\r
-          }\r
-          else\r
-          {\r
-            out.append(".\t");\r
-          }\r
-\r
-          if (next[j].getValue("FRAME") != null)\r
-          {\r
-            out.append(next[j].getValue("FRAME"));\r
-          }\r
-          else\r
-          {\r
-            out.append(".");\r
-          }\r
-          // TODO: verify/check GFF - should there be a /t here before attribute\r
-          // output ?\r
-\r
-          if (next[j].getValue("ATTRIBUTES") != null)\r
-          {\r
-            out.append(next[j].getValue("ATTRIBUTES"));\r
-          }\r
-\r
-          out.append(newline);\r
-\r
-        }\r
-      }\r
-    }\r
-\r
-    return out.toString();\r
-  }\r
-\r
-  /**\r
-   * this is only for the benefit of object polymorphism - method does nothing.\r
-   */\r
-  public void parse()\r
-  {\r
-    // IGNORED\r
-  }\r
-\r
-  /**\r
-   * this is only for the benefit of object polymorphism - method does nothing.\r
-   * \r
-   * @return error message\r
-   */\r
-  public String print()\r
-  {\r
-    return "USE printGFFFormat() or printJalviewFormat()";\r
-  }\r
-\r
-}\r
+package jalview.io;
+
+import java.io.*;
+import java.util.*;
+
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.xml.sax.SAXException;
+
+import fr.orsay.lri.varna.exceptions.ExceptionFileFormatOrSyntax;
+import fr.orsay.lri.varna.exceptions.ExceptionLoadingFailed;
+import fr.orsay.lri.varna.exceptions.ExceptionPermissionDenied;
+import fr.orsay.lri.varna.exceptions.ExceptionUnmatchedClosingParentheses;
+
+import jalview.analysis.SequenceIdMatcher;
+import jalview.datamodel.*;
+import jalview.schemes.*;
+import jalview.util.Format;
+
+/**
+ * Parse and create Jalview Features files Detects GFF format features files and
+ * parses. Does not implement standard print() - call specific printFeatures or
+ * printGFF. Uses AlignmentI.findSequence(String id) to find the sequence object
+ * for the features annotation - this normally works on an exact match.
+ * 
+ * @author AMW
+ * @version $Revision$
+ */
+public class FeaturesFile extends AlignFile
+{
+  /**
+   * work around for GFF interpretation bug where source string becomes
+   * description rather than a group
+   */
+  private boolean doGffSource = true;
+
+  /**
+   * Creates a new FeaturesFile object.
+   */
+  public FeaturesFile()
+  {
+  }
+
+  /**
+   * Creates a new FeaturesFile object.
+   * 
+   * @param inFile
+   *          DOCUMENT ME!
+   * @param type
+   *          DOCUMENT ME!
+   * 
+   * @throws IOException
+   *           DOCUMENT ME!
+   * @throws SAXException
+   * @throws ParserConfigurationException
+   * @throws ExceptionFileFormatOrSyntax
+   * @throws ExceptionLoadingFailed
+   * @throws ExceptionPermissionDenied
+   * @throws InterruptedException
+   * @throws ExceptionUnmatchedClosingParentheses
+   */
+  public FeaturesFile(String inFile, String type) throws IOException,
+          ExceptionFileFormatOrSyntax, ParserConfigurationException,
+          SAXException, ExceptionPermissionDenied, ExceptionLoadingFailed,
+          InterruptedException, ExceptionUnmatchedClosingParentheses
+  {
+    super(inFile, type);
+  }
+
+  public FeaturesFile(FileParse source) throws IOException,
+          ExceptionFileFormatOrSyntax, ParserConfigurationException,
+          SAXException, ExceptionPermissionDenied, ExceptionLoadingFailed,
+          InterruptedException, ExceptionUnmatchedClosingParentheses
+  {
+    super(source);
+  }
+
+  /**
+   * Parse GFF or sequence features file using case-independent matching,
+   * discarding URLs
+   * 
+   * @param align
+   *          - alignment/dataset containing sequences that are to be annotated
+   * @param colours
+   *          - hashtable to store feature colour definitions
+   * @param removeHTML
+   *          - process html strings into plain text
+   * @return true if features were added
+   */
+  public boolean parse(AlignmentI align, Hashtable colours,
+          boolean removeHTML)
+  {
+    return parse(align, colours, null, removeHTML, false);
+  }
+
+  /**
+   * Parse GFF or sequence features file optionally using case-independent
+   * matching, discarding URLs
+   * 
+   * @param align
+   *          - alignment/dataset containing sequences that are to be annotated
+   * @param colours
+   *          - hashtable to store feature colour definitions
+   * @param removeHTML
+   *          - process html strings into plain text
+   * @param relaxedIdmatching
+   *          - when true, ID matches to compound sequence IDs are allowed
+   * @return true if features were added
+   */
+  public boolean parse(AlignmentI align, Map colours, boolean removeHTML,
+          boolean relaxedIdMatching)
+  {
+    return parse(align, colours, null, removeHTML, relaxedIdMatching);
+  }
+
+  /**
+   * Parse GFF or sequence features file optionally using case-independent
+   * matching
+   * 
+   * @param align
+   *          - alignment/dataset containing sequences that are to be annotated
+   * @param colours
+   *          - hashtable to store feature colour definitions
+   * @param featureLink
+   *          - hashtable to store associated URLs
+   * @param removeHTML
+   *          - process html strings into plain text
+   * @return true if features were added
+   */
+  public boolean parse(AlignmentI align, Map colours, Map featureLink,
+          boolean removeHTML)
+  {
+    return parse(align, colours, featureLink, removeHTML, false);
+  }
+
+  /**
+   * /** Parse GFF or sequence features file
+   * 
+   * @param align
+   *          - alignment/dataset containing sequences that are to be annotated
+   * @param colours
+   *          - hashtable to store feature colour definitions
+   * @param featureLink
+   *          - hashtable to store associated URLs
+   * @param removeHTML
+   *          - process html strings into plain text
+   * @param relaxedIdmatching
+   *          - when true, ID matches to compound sequence IDs are allowed
+   * @return true if features were added
+   */
+  public boolean parse(AlignmentI align, Map colours, Map featureLink,
+          boolean removeHTML, boolean relaxedIdmatching)
+  {
+
+    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, groupLink = null;
+      Map typeLink = new Hashtable();
+      /**
+       * when true, assume GFF style features rather than Jalview style.
+       */
+      boolean GFFFile = true;
+      while ((line = nextLine()) != null)
+      {
+        if (line.startsWith("#"))
+        {
+          continue;
+        }
+
+        st = new StringTokenizer(line, "\t");
+        if (st.countTokens() == 1)
+        {
+          if (line.trim().equalsIgnoreCase("GFF"))
+          {
+            // Start parsing file as if it might be GFF again.
+            GFFFile = true;
+            continue;
+          }
+        }
+        if (st.countTokens() > 1 && st.countTokens() < 4)
+        {
+          GFFFile = false;
+          type = st.nextToken();
+          if (type.equalsIgnoreCase("startgroup"))
+          {
+            featureGroup = st.nextToken();
+            if (st.hasMoreElements())
+            {
+              groupLink = st.nextToken();
+              featureLink.put(featureGroup, groupLink);
+            }
+          }
+          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;
+            groupLink = null;
+          }
+          else
+          {
+            Object colour = null;
+            String colscheme = st.nextToken();
+            if (colscheme.indexOf("|") > -1
+                    || colscheme.trim().equalsIgnoreCase("label"))
+            {
+              // Parse '|' separated graduated colourscheme fields:
+              // [label|][mincolour|maxcolour|[absolute|]minvalue|maxvalue|thresholdtype|thresholdvalue]
+              // can either provide 'label' only, first is optional, next two
+              // colors are required (but may be
+              // left blank), next is optional, nxt two min/max are required.
+              // first is either 'label'
+              // first/second and third are both hexadecimal or word equivalent
+              // colour.
+              // next two are values parsed as floats.
+              // fifth is either 'above','below', or 'none'.
+              // sixth is a float value and only required when fifth is either
+              // 'above' or 'below'.
+              StringTokenizer gcol = new StringTokenizer(colscheme, "|",
+                      true);
+              // set defaults
+              int threshtype = AnnotationColourGradient.NO_THRESHOLD;
+              float min = Float.MIN_VALUE, max = Float.MAX_VALUE, threshval = Float.NaN;
+              boolean labelCol = false;
+              // Parse spec line
+              String mincol = gcol.nextToken();
+              if (mincol == "|")
+              {
+                System.err
+                        .println("Expected either 'label' or a colour specification in the line: "
+                                + line);
+                continue;
+              }
+              String maxcol = null;
+              if (mincol.toLowerCase().indexOf("label") == 0)
+              {
+                labelCol = true;
+                mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); // skip
+                                                                           // '|'
+                mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null);
+              }
+              String abso = null, minval, maxval;
+              if (mincol != null)
+              {
+                // at least four more tokens
+                if (mincol.equals("|"))
+                {
+                  mincol = "";
+                }
+                else
+                {
+                  gcol.nextToken(); // skip next '|'
+                }
+                // continue parsing rest of line
+                maxcol = gcol.nextToken();
+                if (maxcol.equals("|"))
+                {
+                  maxcol = "";
+                }
+                else
+                {
+                  gcol.nextToken(); // skip next '|'
+                }
+                abso = gcol.nextToken();
+                gcol.nextToken(); // skip next '|'
+                if (abso.toLowerCase().indexOf("abso") != 0)
+                {
+                  minval = abso;
+                  abso = null;
+                }
+                else
+                {
+                  minval = gcol.nextToken();
+                  gcol.nextToken(); // skip next '|'
+                }
+                maxval = gcol.nextToken();
+                if (gcol.hasMoreTokens())
+                {
+                  gcol.nextToken(); // skip next '|'
+                }
+                try
+                {
+                  if (minval.length() > 0)
+                  {
+                    min = new Float(minval).floatValue();
+                  }
+                } catch (Exception e)
+                {
+                  System.err
+                          .println("Couldn't parse the minimum value for graduated colour for type ("
+                                  + colscheme
+                                  + ") - did you misspell 'auto' for the optional automatic colour switch ?");
+                  e.printStackTrace();
+                }
+                try
+                {
+                  if (maxval.length() > 0)
+                  {
+                    max = new Float(maxval).floatValue();
+                  }
+                } catch (Exception e)
+                {
+                  System.err
+                          .println("Couldn't parse the maximum value for graduated colour for type ("
+                                  + colscheme + ")");
+                  e.printStackTrace();
+                }
+              }
+              else
+              {
+                // add in some dummy min/max colours for the label-only
+                // colourscheme.
+                mincol = "FFFFFF";
+                maxcol = "000000";
+              }
+              try
+              {
+                colour = new jalview.schemes.GraduatedColor(
+                        new UserColourScheme(mincol).findColour('A'),
+                        new UserColourScheme(maxcol).findColour('A'), min,
+                        max);
+              } catch (Exception e)
+              {
+                System.err
+                        .println("Couldn't parse the graduated colour scheme ("
+                                + colscheme + ")");
+                e.printStackTrace();
+              }
+              if (colour != null)
+              {
+                ((jalview.schemes.GraduatedColor) colour)
+                        .setColourByLabel(labelCol);
+                ((jalview.schemes.GraduatedColor) colour)
+                        .setAutoScaled(abso == null);
+                // add in any additional parameters
+                String ttype = null, tval = null;
+                if (gcol.hasMoreTokens())
+                {
+                  // threshold type and possibly a threshold value
+                  ttype = gcol.nextToken();
+                  if (ttype.toLowerCase().startsWith("below"))
+                  {
+                    ((jalview.schemes.GraduatedColor) colour)
+                            .setThreshType(AnnotationColourGradient.BELOW_THRESHOLD);
+                  }
+                  else if (ttype.toLowerCase().startsWith("above"))
+                  {
+                    ((jalview.schemes.GraduatedColor) colour)
+                            .setThreshType(AnnotationColourGradient.ABOVE_THRESHOLD);
+                  }
+                  else
+                  {
+                    ((jalview.schemes.GraduatedColor) colour)
+                            .setThreshType(AnnotationColourGradient.NO_THRESHOLD);
+                    if (!ttype.toLowerCase().startsWith("no"))
+                    {
+                      System.err
+                              .println("Ignoring unrecognised threshold type : "
+                                      + ttype);
+                    }
+                  }
+                }
+                if (((GraduatedColor) colour).getThreshType() != AnnotationColourGradient.NO_THRESHOLD)
+                {
+                  try
+                  {
+                    gcol.nextToken();
+                    tval = gcol.nextToken();
+                    ((jalview.schemes.GraduatedColor) colour)
+                            .setThresh(new Float(tval).floatValue());
+                  } catch (Exception e)
+                  {
+                    System.err
+                            .println("Couldn't parse threshold value as a float: ("
+                                    + tval + ")");
+                    e.printStackTrace();
+                  }
+                }
+                // parse the thresh-is-min token ?
+                if (gcol.hasMoreTokens())
+                {
+                  System.err
+                          .println("Ignoring additional tokens in parameters in graduated colour specification\n");
+                  while (gcol.hasMoreTokens())
+                  {
+                    System.err.println("|" + gcol.nextToken());
+                  }
+                  System.err.println("\n");
+                }
+              }
+            }
+            else
+            {
+              UserColourScheme ucs = new UserColourScheme(colscheme);
+              colour = ucs.findColour('A');
+            }
+            if (colour != null)
+            {
+              colours.put(type, colour);
+            }
+            if (st.hasMoreElements())
+            {
+              String link = st.nextToken();
+              typeLink.put(type, link);
+              if (featureLink == null)
+              {
+                featureLink = new Hashtable();
+              }
+              featureLink.put(type, link);
+            }
+          }
+          continue;
+        }
+        String seqId = "";
+        while (st.hasMoreElements())
+        {
+
+          if (GFFFile)
+          {
+            // Still possible this is an old Jalview file,
+            // which does not have type colours at the beginning
+            seqId = token = st.nextToken();
+            seq = findName(align, seqId, relaxedIdmatching);
+            if (seq != null)
+            {
+              desc = st.nextToken();
+              String group = null;
+              if (doGffSource && desc.indexOf(' ') == -1)
+              {
+                // could also be a source term rather than description line
+                group = new String(desc);
+              }
+              type = st.nextToken();
+              try
+              {
+                String stt = st.nextToken();
+                if (stt.length() == 0 || stt.equals("-"))
+                {
+                  start = 0;
+                }
+                else
+                {
+                  start = Integer.parseInt(stt);
+                }
+              } catch (NumberFormatException ex)
+              {
+                start = 0;
+              }
+              try
+              {
+                String stt = st.nextToken();
+                if (stt.length() == 0 || stt.equals("-"))
+                {
+                  end = 0;
+                }
+                else
+                {
+                  end = Integer.parseInt(stt);
+                }
+              } catch (NumberFormatException ex)
+              {
+                end = 0;
+              }
+              // TODO: decide if non positional feature assertion for input data
+              // where end==0 is generally valid
+              if (end == 0)
+              {
+                // treat as non-positional feature, regardless.
+                start = 0;
+              }
+              try
+              {
+                score = new Float(st.nextToken()).floatValue();
+              } catch (NumberFormatException ex)
+              {
+                score = 0;
+              }
+
+              sf = new SequenceFeature(type, desc, start, end, score, group);
+
+              try
+              {
+                sf.setValue("STRAND", st.nextToken());
+                sf.setValue("FRAME", st.nextToken());
+              } catch (Exception ex)
+              {
+              }
+
+              if (st.hasMoreTokens())
+              {
+                StringBuffer attributes = new StringBuffer();
+                while (st.hasMoreTokens())
+                {
+                  attributes.append("\t" + st.nextElement());
+                }
+                // TODO validate and split GFF2 attributes field ? parse out
+                // ([A-Za-z][A-Za-z0-9_]*) <value> ; and add as
+                // sf.setValue(attrib, val);
+                sf.setValue("ATTRIBUTES", attributes.toString());
+              }
+
+              seq.addSequenceFeature(sf);
+              while ((seq = align.findName(seq, seqId, true)) != null)
+              {
+                seq.addSequenceFeature(new SequenceFeature(sf));
+              }
+              break;
+            }
+          }
+
+          if (GFFFile && seq == null)
+          {
+            desc = token;
+          }
+          else
+          {
+            desc = st.nextToken();
+          }
+          if (!st.hasMoreTokens())
+          {
+            System.err
+                    .println("DEBUG: Run out of tokens when trying to identify the destination for the feature.. giving up.");
+            // in all probability, this isn't a file we understand, so bail
+            // quietly.
+            return false;
+          }
+
+          token = st.nextToken();
+
+          if (!token.equals("ID_NOT_SPECIFIED"))
+          {
+            seq = findName(align, seqId = token, relaxedIdmatching);
+            st.nextToken();
+          }
+          else
+          {
+            seqId = null;
+            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);
+          if (st.hasMoreTokens())
+          {
+            try
+            {
+              score = new Float(st.nextToken()).floatValue();
+              // update colourgradient bounds if allowed to
+            } catch (NumberFormatException ex)
+            {
+              score = 0;
+            }
+            sf.setScore(score);
+          }
+          if (groupLink != null && removeHTML)
+          {
+            sf.addLink(groupLink);
+            sf.description += "%LINK%";
+          }
+          if (typeLink.containsKey(type) && removeHTML)
+          {
+            sf.addLink(typeLink.get(type).toString());
+            sf.description += "%LINK%";
+          }
+
+          parseDescriptionHTML(sf, removeHTML);
+
+          seq.addSequenceFeature(sf);
+
+          while (seqId != null
+                  && (seq = align.findName(seq, seqId, false)) != null)
+          {
+            seq.addSequenceFeature(new SequenceFeature(sf));
+          }
+          // If we got here, its not a GFFFile
+          GFFFile = false;
+        }
+      }
+      resetMatcher();
+    } catch (Exception ex)
+    {
+      System.out.println(line);
+      System.out.println("Error parsing feature file: " + ex + "\n" + line);
+      ex.printStackTrace(System.err);
+      resetMatcher();
+      return false;
+    }
+
+    return true;
+  }
+
+  private AlignmentI lastmatchedAl = null;
+
+  private SequenceIdMatcher matcher = null;
+
+  /**
+   * clear any temporary handles used to speed up ID matching
+   */
+  private void resetMatcher()
+  {
+    lastmatchedAl = null;
+    matcher = null;
+  }
+
+  private SequenceI findName(AlignmentI align, String seqId,
+          boolean relaxedIdMatching)
+  {
+    SequenceI match = null;
+    if (relaxedIdMatching)
+    {
+      if (lastmatchedAl != align)
+      {
+        matcher = new SequenceIdMatcher(
+                (lastmatchedAl = align).getSequencesArray());
+      }
+      match = matcher.findIdMatch(seqId);
+    }
+    else
+    {
+      match = align.findName(seqId, true);
+    }
+    return match;
+  }
+
+  public void parseDescriptionHTML(SequenceFeature sf, boolean removeHTML)
+  {
+    if (sf.getDescription() == null)
+    {
+      return;
+    }
+    jalview.util.ParseHtmlBodyAndLinks parsed = new jalview.util.ParseHtmlBodyAndLinks(
+            sf.getDescription(), removeHTML, newline);
+
+    sf.description = (removeHTML) ? parsed.getNonHtmlContent()
+            : sf.description;
+    for (String link : parsed.getLinks())
+    {
+      sf.addLink(link);
+    }
+
+  }
+
+  /**
+   * generate a features file for seqs includes non-pos features by default.
+   * 
+   * @param seqs
+   *          source of sequence features
+   * @param visible
+   *          hash of feature types and colours
+   * @return features file contents
+   */
+  public String printJalviewFormat(SequenceI[] seqs, Hashtable visible)
+  {
+    return printJalviewFormat(seqs, visible, true, true);
+  }
+
+  /**
+   * generate a features file for seqs with colours from visible (if any)
+   * 
+   * @param seqs
+   *          source of features
+   * @param visible
+   *          hash of Colours for each feature type
+   * @param visOnly
+   *          when true only feature types in 'visible' will be output
+   * @param nonpos
+   *          indicates if non-positional features should be output (regardless
+   *          of group or type)
+   * @return features file contents
+   */
+  public String printJalviewFormat(SequenceI[] seqs, Hashtable visible,
+          boolean visOnly, boolean nonpos)
+  {
+    StringBuffer out = new StringBuffer();
+    SequenceFeature[] next;
+    boolean featuresGen = false;
+    if (visOnly && !nonpos && (visible == null || visible.size() < 1))
+    {
+      // no point continuing.
+      return "No Features Visible";
+    }
+
+    if (visible != null && visOnly)
+    {
+      // write feature colours only if we're given them and we are generating
+      // viewed features
+      // TODO: decide if feature links should also be written here ?
+      Enumeration en = visible.keys();
+      String type, color;
+      while (en.hasMoreElements())
+      {
+        type = en.nextElement().toString();
+
+        if (visible.get(type) instanceof GraduatedColor)
+        {
+          GraduatedColor gc = (GraduatedColor) visible.get(type);
+          color = (gc.isColourByLabel() ? "label|" : "")
+                  + Format.getHexString(gc.getMinColor()) + "|"
+                  + Format.getHexString(gc.getMaxColor())
+                  + (gc.isAutoScale() ? "|" : "|abso|") + gc.getMin() + "|"
+                  + gc.getMax() + "|";
+          if (gc.getThreshType() != AnnotationColourGradient.NO_THRESHOLD)
+          {
+            if (gc.getThreshType() == AnnotationColourGradient.BELOW_THRESHOLD)
+            {
+              color += "below";
+            }
+            else
+            {
+              if (gc.getThreshType() != AnnotationColourGradient.ABOVE_THRESHOLD)
+              {
+                System.err.println("WARNING: Unsupported threshold type ("
+                        + gc.getThreshType() + ") : Assuming 'above'");
+              }
+              color += "above";
+            }
+            // add the value
+            color += "|" + gc.getThresh();
+          }
+          else
+          {
+            color += "none";
+          }
+        }
+        else if (visible.get(type) instanceof java.awt.Color)
+        {
+          color = Format.getHexString((java.awt.Color) visible.get(type));
+        }
+        else
+        {
+          // legacy support for integer objects containing colour triplet values
+          color = Format.getHexString(new java.awt.Color(Integer
+                  .parseInt(visible.get(type).toString())));
+        }
+        out.append(type);
+        out.append("\t");
+        out.append(color);
+        out.append(newline);
+      }
+    }
+    // Work out which groups are both present and visible
+    Vector groups = new Vector();
+    int groupIndex = 0;
+    boolean isnonpos = false;
+
+    for (int i = 0; i < seqs.length; i++)
+    {
+      next = seqs[i].getSequenceFeatures();
+      if (next != null)
+      {
+        for (int j = 0; j < next.length; j++)
+        {
+          isnonpos = next[j].begin == 0 && next[j].end == 0;
+          if ((!nonpos && isnonpos)
+                  || (!isnonpos && visOnly && !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 && groupIndex < groups.size())
+      {
+        group = groups.elementAt(groupIndex).toString();
+        out.append(newline);
+        out.append("STARTGROUP\t");
+        out.append(group);
+        out.append(newline);
+      }
+      else
+      {
+        group = null;
+      }
+
+      for (int i = 0; i < seqs.length; i++)
+      {
+        next = seqs[i].getSequenceFeatures();
+        if (next != null)
+        {
+          for (int j = 0; j < next.length; j++)
+          {
+            isnonpos = next[j].begin == 0 && next[j].end == 0;
+            if ((!nonpos && isnonpos)
+                    || (!isnonpos && visOnly && !visible
+                            .containsKey(next[j].type)))
+            {
+              // skip if feature is nonpos and we ignore them or if we only
+              // output visible and it isn't non-pos and it's not visible
+              continue;
+            }
+
+            if (group != null
+                    && (next[j].featureGroup == null || !next[j].featureGroup
+                            .equals(group)))
+            {
+              continue;
+            }
+
+            if (group == null && next[j].featureGroup != null)
+            {
+              continue;
+            }
+            // we have features to output
+            featuresGen = true;
+            if (next[j].description == null
+                    || next[j].description.equals(""))
+            {
+              out.append(next[j].type + "\t");
+            }
+            else
+            {
+              if (next[j].links != null
+                      && next[j].getDescription().indexOf("<html>") == -1)
+              {
+                out.append("<html>");
+              }
+
+              out.append(next[j].description + " ");
+              if (next[j].links != null)
+              {
+                for (int l = 0; l < next[j].links.size(); l++)
+                {
+                  String label = next[j].links.elementAt(l).toString();
+                  String href = label.substring(label.indexOf("|") + 1);
+                  label = label.substring(0, label.indexOf("|"));
+
+                  if (next[j].description.indexOf(href) == -1)
+                  {
+                    out.append("<a href=\"" + href + "\">" + label + "</a>");
+                  }
+                }
+
+                if (next[j].getDescription().indexOf("</html>") == -1)
+                {
+                  out.append("</html>");
+                }
+              }
+
+              out.append("\t");
+            }
+            out.append(seqs[i].getName());
+            out.append("\t-1\t");
+            out.append(next[j].begin);
+            out.append("\t");
+            out.append(next[j].end);
+            out.append("\t");
+            out.append(next[j].type);
+            if (next[j].score != Float.NaN)
+            {
+              out.append("\t");
+              out.append(next[j].score);
+            }
+            out.append(newline);
+          }
+        }
+      }
+
+      if (group != null)
+      {
+        out.append("ENDGROUP\t");
+        out.append(group);
+        out.append(newline);
+        groupIndex++;
+      }
+      else
+      {
+        break;
+      }
+
+    } while (groupIndex < groups.size() + 1);
+
+    if (!featuresGen)
+    {
+      return "No Features Visible";
+    }
+
+    return out.toString();
+  }
+
+  /**
+   * generate a gff file for sequence features includes non-pos features by
+   * default.
+   * 
+   * @param seqs
+   * @param visible
+   * @return
+   */
+  public String printGFFFormat(SequenceI[] seqs, Hashtable visible)
+  {
+    return printGFFFormat(seqs, visible, true, true);
+  }
+
+  public String printGFFFormat(SequenceI[] seqs, Hashtable visible,
+          boolean visOnly, boolean nonpos)
+  {
+    StringBuffer out = new StringBuffer();
+    SequenceFeature[] next;
+    String source;
+    boolean isnonpos;
+    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++)
+        {
+          isnonpos = next[j].begin == 0 && next[j].end == 0;
+          if ((!nonpos && isnonpos)
+                  || (!isnonpos && visOnly && !visible
+                          .containsKey(next[j].type)))
+          {
+            continue;
+          }
+
+          source = next[j].featureGroup;
+          if (source == null)
+          {
+            source = next[j].getDescription();
+          }
+
+          out.append(seqs[i].getName());
+          out.append("\t");
+          out.append(source);
+          out.append("\t");
+          out.append(next[j].type);
+          out.append("\t");
+          out.append(next[j].begin);
+          out.append("\t");
+          out.append(next[j].end);
+          out.append("\t");
+          out.append(next[j].score);
+          out.append("\t");
+
+          if (next[j].getValue("STRAND") != null)
+          {
+            out.append(next[j].getValue("STRAND"));
+            out.append("\t");
+          }
+          else
+          {
+            out.append(".\t");
+          }
+
+          if (next[j].getValue("FRAME") != null)
+          {
+            out.append(next[j].getValue("FRAME"));
+          }
+          else
+          {
+            out.append(".");
+          }
+          // TODO: verify/check GFF - should there be a /t here before attribute
+          // output ?
+
+          if (next[j].getValue("ATTRIBUTES") != null)
+          {
+            out.append(next[j].getValue("ATTRIBUTES"));
+          }
+
+          out.append(newline);
+
+        }
+      }
+    }
+
+    return out.toString();
+  }
+
+  /**
+   * this is only for the benefit of object polymorphism - method does nothing.
+   */
+  public void parse()
+  {
+    // IGNORED
+  }
+
+  /**
+   * this is only for the benefit of object polymorphism - method does nothing.
+   * 
+   * @return error message
+   */
+  public String print()
+  {
+    return "USE printGFFFormat() or printJalviewFormat()";
+  }
+
+}
index ed4001e..1cdd95d 100755 (executable)
@@ -304,7 +304,6 @@ public class IdentifyFile
 
   public static void main(String[] args)
   {
-        
     for (int i = 0; args != null && i < args.length; i++)
     {
       IdentifyFile ider = new IdentifyFile();
index 2e2c896..b0db2e0 100755 (executable)
@@ -171,7 +171,7 @@ public class JalviewFileChooser extends JFileChooser
     {
       format = "PFAM";
     }
-    
+
     return format;
   }
 
index bfe2156..90808de 100644 (file)
@@ -51,7 +51,6 @@ public class AnnotationRenderer
           int lastSSX, int x, int y, int iconOffset, int startRes,
           int column, boolean validRes, boolean validEnd)
   {
-       
     g.setColor(STEM_COLOUR);
     int sCol = (lastSSX / charWidth) + startRes;
     int x1 = lastSSX;
index 08e699b..42f4feb 100644 (file)
@@ -1,4 +1,21 @@
-package jalview.schemes;
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
+ * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * 
+ * This file is part of Jalview.
+ * 
+ * Jalview 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 3 of the License, or (at your option) any later version.
+ *  
+ * Jalview 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 Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ */
+ package jalview.schemes;
 
 import jalview.datamodel.SequenceI;
 
index 266fdcd..86c3336 100644 (file)
@@ -20,7 +20,6 @@ package jalview.workers;
 import java.util.Hashtable;
 
 import jalview.analysis.StructureFrequency;
-import jalview.analysis.StructureFrequency;
 import jalview.api.AlignCalcWorkerI;
 import jalview.api.AlignViewportI;
 import jalview.api.AlignmentViewPanel;
index d018eab..01892e7 100644 (file)
@@ -1,3 +1,20 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
+ * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * 
+ * This file is part of Jalview.
+ * 
+ * Jalview 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 3 of the License, or (at your option) any later version.
+ *  
+ * Jalview 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 Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package jalview.ws;
 
 import java.io.BufferedReader;
index 505e15f..5457c3a 100644 (file)
@@ -1,4 +1,21 @@
-package jalview.ws.jws1;
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
+ * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * 
+ * This file is part of Jalview.
+ * 
+ * Jalview 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 3 of the License, or (at your option) any later version.
+ *  
+ * Jalview 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 Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ */
+ package jalview.ws.jws1;
 
 import java.io.BufferedInputStream;
 import java.io.BufferedReader;