X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FAnnotationFile.java;h=44c7f2e5efb53845de2b60d2c17bf48249c4c8bf;hb=797df64fa2a0a30773d0f48f5494d4155e5a8be3;hp=aac48eb0fe46c6366a736ecd868f8df285ce1ca4;hpb=a9108fa3538ddb2ef02aa231e233dc978654d6f6;p=jalview.git

diff --git a/src/jalview/io/AnnotationFile.java b/src/jalview/io/AnnotationFile.java
index aac48eb..44c7f2e 100755
--- a/src/jalview/io/AnnotationFile.java
+++ b/src/jalview/io/AnnotationFile.java
@@ -1,20 +1,19 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)
- * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
+ * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, 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 file is part of Jalview.
  * 
- * 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.
+ * 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.
  * 
- * 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
+ * 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.io;
 
@@ -28,8 +27,41 @@ import jalview.schemes.*;
 
 public class AnnotationFile
 {
-  StringBuffer text = new StringBuffer("JALVIEW_ANNOTATION\n"
-          + "# Created: " + new java.util.Date() + "\n\n");
+  public AnnotationFile()
+  {
+    init();
+  }
+
+  /**
+   * character used to write newlines
+   */
+  protected String newline = System.getProperty("line.separator");
+
+  /**
+   * set new line string and reset the output buffer
+   * 
+   * @param nl
+   */
+  public void setNewlineString(String nl)
+  {
+    newline = nl;
+    init();
+  }
+
+  public String getNewlineString()
+  {
+    return newline;
+  }
+
+  StringBuffer text;
+
+  private void init()
+  {
+    text = new StringBuffer("JALVIEW_ANNOTATION"+newline + "# Created: "
+            + new java.util.Date() + newline + newline);
+    refSeq = null;
+    refSeqId = null;
+  }
 
   /**
    * convenience method for pre-2.4 feature files which have no view, hidden
@@ -72,8 +104,11 @@ public class AnnotationFile
       this.hiddenRepSeqs = hiddenRepSeqs;
     }
   }
+
   /**
-   * Prepare an annotation file given a set of annotations, groups, alignment properties and views. 
+   * Prepare an annotation file given a set of annotations, groups, alignment
+   * properties and views.
+   * 
    * @param annotations
    * @param groups
    * @param properties
@@ -83,13 +118,15 @@ public class AnnotationFile
   public String printAnnotations(AlignmentAnnotation[] annotations,
           Vector groups, Hashtable properties, ViewDef[] views)
   {
-    // TODO: resolve views issue : annotationFile could contain visible region, or full data + hidden region specifications for a view.
+    // TODO: resolve views issue : annotationFile could contain visible region,
+    // or full data + hidden region specifications for a view.
     if (annotations != null)
     {
       boolean oneColour = true;
       AlignmentAnnotation row;
       String comma;
       SequenceI refSeq = null;
+      SequenceGroup refGroup = null;
 
       StringBuffer colours = new StringBuffer();
       StringBuffer graphLine = new StringBuffer();
@@ -114,17 +151,50 @@ public class AnnotationFile
         {
           if (refSeq != null)
           {
-            text.append("\nSEQUENCE_REF\tALIGNMENT\n");
+            text.append(newline);
+            text.append("SEQUENCE_REF\tALIGNMENT");
+            text.append(newline);
           }
 
           refSeq = null;
         }
 
-        else if (refSeq == null || refSeq != row.sequenceRef)
+        else
+        {
+          if (refSeq == null || refSeq != row.sequenceRef)
+          {
+            refSeq = row.sequenceRef;
+            text.append(newline);
+            text.append("SEQUENCE_REF\t");
+            text.append(refSeq.getName());
+            text.append(newline);
+          }
+        }
+        // mark any group references for the row
+        if (row.groupRef == null)
         {
-          refSeq = row.sequenceRef;
-          text.append("\nSEQUENCE_REF\t" + refSeq.getName() + "\n");
+
+          if (refGroup != null)
+          {
+            text.append(newline);
+            text.append("GROUP_REF\tALIGNMENT");
+            text.append(newline);
+          }
+
+          refGroup = null;
         }
+        else
+        {
+          if (refGroup == null || refGroup != row.groupRef)
+          {
+            refGroup = row.groupRef;
+            text.append(newline);
+            text.append("GROUP_REF\t");
+            text.append(refGroup.getName());
+            text.append(newline);
+          }
+        }
+
         boolean hasGlyphs = row.hasIcons, hasLabels = row.hasText, hasValues = row.hasScore, hasText = false;
         // lookahead to check what the annotation row object actually contains.
         for (int j = 0; row.annotations != null
@@ -138,8 +208,8 @@ public class AnnotationFile
                     .equals(" "));
             hasGlyphs |= (row.annotations[j].secondaryStructure != 0 && row.annotations[j].secondaryStructure != ' ');
             hasValues |= (row.annotations[j].value != Float.NaN); // NaNs can't
-                                                                  // be
-                                                                  // rendered..
+            // be
+            // rendered..
             hasText |= (row.annotations[j].description != null && row.annotations[j].description
                     .length() > 0);
           }
@@ -167,16 +237,16 @@ public class AnnotationFile
 
           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");
+            graphLine.append("GRAPHLINE\t");
+            graphLine.append(row.label);
+            graphLine.append("\t");
+            graphLine.append(row.getThreshold().value);
+            graphLine.append("\t");
+            graphLine.append(row.getThreshold().label);
+            graphLine.append("\t");
+            graphLine.append(jalview.util.Format.getHexString(row
+                    .getThreshold().colour));
+            graphLine.append(newline);
           }
 
           if (row.graphGroup > -1)
@@ -210,7 +280,7 @@ public class AnnotationFile
           if (row.annotations[j] != null)
           {
             comma = "";
-            if (hasGlyphs) // could be also hasGlyphs || ... 
+            if (hasGlyphs) // could be also hasGlyphs || ...
             {
 
               text.append(comma);
@@ -281,24 +351,32 @@ public class AnnotationFile
         if (row.hasScore())
           text.append("\t" + row.score);
 
-        text.append("\n");
+        text.append(newline);
 
         if (color != null && color != java.awt.Color.black && oneColour)
         {
-          colours.append("COLOUR\t" + row.label + "\t"
-                  + jalview.util.Format.getHexString(color) + "\n");
+          colours.append("COLOUR\t");
+          colours.append(row.label);
+          colours.append("\t");
+          colours.append(jalview.util.Format.getHexString(color));
+          colours.append(newline);
         }
-        if (row.scaleColLabel || row.showAllColLabels || row.centreColLabels)
+        if (row.scaleColLabel || row.showAllColLabels
+                || row.centreColLabels)
         {
-          rowprops.append("ROWPROPERTIES\t"+row.label);
-          rowprops.append("\tscaletofit="+row.scaleColLabel);
-          rowprops.append("\tshowalllabs="+row.showAllColLabels);
-          rowprops.append("\tcentrelabs="+row.centreColLabels);
-          rowprops.append("\n");
+          rowprops.append("ROWPROPERTIES\t");
+          rowprops.append(row.label);
+          rowprops.append("\tscaletofit=");
+          rowprops.append(row.scaleColLabel);
+          rowprops.append("\tshowalllabs=");
+          rowprops.append(row.showAllColLabels);
+          rowprops.append("\tcentrelabs=");
+          rowprops.append(row.centreColLabels);
+          rowprops.append(newline);
         }
       }
 
-      text.append("\n");
+      text.append(newline);
 
       text.append(colours.toString());
       text.append(graphLine.toString());
@@ -308,7 +386,8 @@ public class AnnotationFile
         Enumeration en = graphGroup.elements();
         while (en.hasMoreElements())
         {
-          text.append(en.nextElement() + "\n");
+          text.append(en.nextElement());
+          text.append(newline);
         }
       }
       text.append(rowprops.toString());
@@ -321,12 +400,17 @@ public class AnnotationFile
 
     if (properties != null)
     {
-      text.append("\n\nALIGNMENT");
+      text.append(newline);
+      text.append(newline);
+      text.append("ALIGNMENT");
       Enumeration en = properties.keys();
       while (en.hasMoreElements())
       {
         String key = en.nextElement().toString();
-        text.append("\t" + key + "=" + properties.get(key));
+        text.append("\t");
+        text.append(key);
+        text.append("=");
+        text.append(properties.get(key));
       }
       // TODO: output alignment visualization settings here if required
 
@@ -352,61 +436,90 @@ public class AnnotationFile
       else
       {
         seqrep = sg.getSeqrep();
-        text.append("SEQUENCE_REF\t" + seqrep.getName() + "\n");
-        text.append("SEQUENCE_GROUP\t" + sg.getName() + "\t"
-                + (seqrep.findPosition(sg.getStartRes())) + "\t"
-                + (seqrep.findPosition(sg.getEndRes())) + "\t" + "-1\t");
+        text.append("SEQUENCE_REF\t");
+        text.append(seqrep.getName());
+        text.append(newline);
+        text.append("SEQUENCE_GROUP\t");
+        text.append(sg.getName());
+        text.append("\t");
+        text.append((seqrep.findPosition(sg.getStartRes())));
+        text.append("\t");
+        text.append((seqrep.findPosition(sg.getEndRes())));
+        text.append("\t");
+        text.append("-1\t");
       }
       for (int s = 0; s < sg.getSize(); s++)
       {
-        text.append(sg.getSequenceAt(s).getName() + "\t");
+        text.append(sg.getSequenceAt(s).getName());
+        text.append("\t");
       }
-
-      text.append("\nPROPERTIES\t" + sg.getName() + "\t");
+      text.append(newline);
+      text.append("PROPERTIES\t");
+      text.append(sg.getName());
+      text.append("\t");
 
       if (sg.getDescription() != null)
       {
-        text.append("description=" + sg.getDescription() + "\t");
+        text.append("description=");
+        text.append(sg.getDescription());
+        text.append("\t");
       }
       if (sg.cs != null)
       {
-        text.append("colour=" + ColourSchemeProperty.getColourName(sg.cs)
-                + "\t");
+        text.append("colour=");
+        text.append(ColourSchemeProperty.getColourName(sg.cs));
+        text.append("\t");
         if (sg.cs.getThreshold() != 0)
         {
-          text.append("pidThreshold=" + sg.cs.getThreshold());
+          text.append("pidThreshold=");
+          text.append(sg.cs.getThreshold());
         }
         if (sg.cs.conservationApplied())
         {
-          text.append("consThreshold=" + sg.cs.getConservationInc() + "\t");
+          text.append("consThreshold=");
+          text.append(sg.cs.getConservationInc());
+          text.append("\t");
         }
       }
-      text.append("outlineColour="
-              + jalview.util.Format.getHexString(sg.getOutlineColour())
-              + "\t");
-
-      text.append("displayBoxes=" + sg.getDisplayBoxes() + "\t");
-      text.append("displayText=" + sg.getDisplayText() + "\t");
-      text.append("colourText=" + sg.getColourText() + "\t");
-      text.append("showUnconserved=" + sg.getShowunconserved() + "\t");
+      text.append("outlineColour=");
+      text.append(jalview.util.Format.getHexString(sg.getOutlineColour()));
+      text.append("\t");
+
+      text.append("displayBoxes=");
+      text.append(sg.getDisplayBoxes());
+      text.append("\t");
+      text.append("displayText=");
+      text.append(sg.getDisplayText());
+      text.append("\t");
+      text.append("colourText=");
+      text.append(sg.getColourText());
+      text.append("\t");
+      text.append("showUnconserved=");
+      text.append(sg.getShowNonconserved());
+      text.append("\t");
       if (sg.textColour != java.awt.Color.black)
       {
-        text.append("textCol1="
-                + jalview.util.Format.getHexString(sg.textColour) + "\t");
+        text.append("textCol1=");
+        text.append(jalview.util.Format.getHexString(sg.textColour));
+        text.append("\t");
       }
       if (sg.textColour2 != java.awt.Color.white)
       {
-        text.append("textCol2="
-                + jalview.util.Format.getHexString(sg.textColour2) + "\t");
+        text.append("textCol2=");
+        text.append(jalview.util.Format.getHexString(sg.textColour2));
+        text.append("\t");
       }
       if (sg.thresholdTextColour != 0)
       {
-        text.append("textColThreshold=" + sg.thresholdTextColour + "\t");
+        text.append("textColThreshold=");
+        text.append(sg.thresholdTextColour);
+        text.append("\t");
       }
       if (sg.idColour != null)
       {
-        text.append("idColour="
-                + jalview.util.Format.getHexString(sg.idColour) + "\t");
+        text.append("idColour=");
+        text.append(jalview.util.Format.getHexString(sg.idColour));
+        text.append("\t");
       }
       if (sg.isHidereps())
       {
@@ -419,9 +532,11 @@ public class AnnotationFile
       if (seqrep != null)
       {
         // terminate the last line and clear the sequence ref for the group
-        text.append("\nSEQUENCE_REF");
+        text.append(newline);
+        text.append("SEQUENCE_REF");
       }
-      text.append("\n\n");
+      text.append(newline);
+      text.append(newline);
 
     }
   }
@@ -433,10 +548,9 @@ public class AnnotationFile
   public boolean readAnnotationFile(AlignmentI al, String file,
           String protocol)
   {
-    Hashtable autoAnnots=new Hashtable();
+    BufferedReader in = null;
     try
     {
-      BufferedReader in = null;
       if (protocol.equals(AppletFormatAdapter.FILE))
       {
         in = new BufferedReader(new FileReader(file));
@@ -458,26 +572,52 @@ public class AnnotationFile
           in = new BufferedReader(new java.io.InputStreamReader(is));
         }
       }
+      if (in != null)
+      {
+        return parseAnnotationFrom(al, in);
+      }
+
+    } catch (Exception ex)
+    {
+      ex.printStackTrace();
+      System.out.println("Problem reading annotation file: " + ex);
+      return false;
+    }
+    return false;
+  }
+
+  public boolean parseAnnotationFrom(AlignmentI al, BufferedReader in)
+          throws Exception
+  {
+    boolean modified = false;
+    String groupRef = null;
+    Hashtable groupRefRows = new Hashtable();
 
+    Hashtable autoAnnots = new Hashtable();
+    {
       String line, label, description, token;
       int graphStyle, index;
       int refSeqIndex = 1;
       int existingAnnotations = 0;
-      // when true - will add new rows regardless of whether they are duplicate auto-annotation like consensus or conservation graphs
-      boolean overrideAutoAnnot=false; 
+      // when true - will add new rows regardless of whether they are duplicate
+      // auto-annotation like consensus or conservation graphs
+      boolean overrideAutoAnnot = false;
       if (al.getAlignmentAnnotation() != null)
       {
         existingAnnotations = al.getAlignmentAnnotation().length;
-        if (existingAnnotations>0)
+        if (existingAnnotations > 0)
         {
           AlignmentAnnotation[] aa = al.getAlignmentAnnotation();
-          for (int aai=0;aai<aa.length;aai++)
+          for (int aai = 0; aai < aa.length; aai++)
           {
             if (aa[aai].autoCalculated)
             {
               // make a note of the name and description
-              autoAnnots.put(aa[aai].graph+"\t"+aa[aai].label+"\t"+aa[aai].description+"\t"+(aa[aai].sequenceRef!=null ? aa[aai].sequenceRef.getDisplayId(true) : "")
-                      ,new Integer(1));
+              autoAnnots.put(
+                      autoAnnotsKey(aa[aai], aa[aai].sequenceRef,
+                              (aa[aai].groupRef == null ? null
+                                      : aa[aai].groupRef.getName())),
+                      new Integer(1));
             }
           }
         }
@@ -526,22 +666,26 @@ public class AnnotationFile
         {
           // TODO: use graduated colour def'n here too
           colourAnnotations(al, st.nextToken(), st.nextToken());
+          modified = true;
           continue;
         }
 
         else if (token.equalsIgnoreCase("COMBINE"))
         {
           combineAnnotations(al, st);
+          modified = true;
           continue;
         }
         else if (token.equalsIgnoreCase("ROWPROPERTIES"))
         {
           addRowProperties(al, st);
+          modified = true;
           continue;
         }
         else if (token.equalsIgnoreCase("GRAPHLINE"))
         {
           addLine(al, st);
+          modified = true;
           continue;
         }
 
@@ -575,7 +719,28 @@ public class AnnotationFile
           }
           continue;
         }
-
+        else if (token.equalsIgnoreCase("GROUP_REF"))
+        {
+          // Group references could be forward or backwards, so they are
+          // resolved after the whole file is read in
+          groupRef = null;
+          if (st.hasMoreTokens())
+          {
+            groupRef = st.nextToken();
+            if (groupRef.length() < 1)
+            {
+              groupRef = null; // empty string
+            }
+            else
+            {
+              if (groupRefRows.get(groupRef) == null)
+              {
+                groupRefRows.put(groupRef, new Vector());
+              }
+            }
+          }
+          continue;
+        }
         else if (token.equalsIgnoreCase("SEQUENCE_GROUP"))
         {
           addGroup(al, st);
@@ -585,20 +750,24 @@ public class AnnotationFile
         else if (token.equalsIgnoreCase("PROPERTIES"))
         {
           addProperties(al, st);
+          modified = true;
           continue;
         }
 
         else if (token.equalsIgnoreCase("BELOW_ALIGNMENT"))
         {
           setBelowAlignment(al, st);
+          modified = true;
           continue;
         }
         else if (token.equalsIgnoreCase("ALIGNMENT"))
         {
           addAlignmentDetails(al, st);
+          modified = true;
           continue;
         }
 
+        // Parse out the annotation row
         graphStyle = AlignmentAnnotation.getGraphValueFromString(token);
         label = st.nextToken();
 
@@ -661,12 +830,14 @@ public class AnnotationFile
           }
 
         }
-        
+
         annotation = new AlignmentAnnotation(label, description,
                 (index == 0) ? null : annotations, 0, 0, graphStyle);
 
         annotation.score = score;
-        if (!overrideAutoAnnot && autoAnnots.containsKey(annotation.graph+"\t"+annotation.label+"\t"+annotation.description+"\t"+(refSeq!=null ? refSeq.getDisplayId(true) : "")))
+        if (!overrideAutoAnnot
+                && autoAnnots.containsKey(autoAnnotsKey(annotation, refSeq,
+                        groupRef)))
         {
           // skip - we've already got an automatic annotation of this type.
           continue;
@@ -674,7 +845,7 @@ public class AnnotationFile
         // otherwise add it!
         if (refSeq != null)
         {
-          
+
           annotation.belowAlignment = false;
           // make a copy of refSeq so we can find other matches in the alignment
           SequenceI referedSeq = refSeq;
@@ -692,6 +863,10 @@ public class AnnotationFile
             al.setAnnotationIndex(annotation,
                     al.getAlignmentAnnotation().length
                             - existingAnnotations - 1);
+            if (groupRef != null)
+            {
+              ((Vector) groupRefRows.get(groupRef)).addElement(annotation);
+            }
             // and recover our virgin copy to use again if necessary.
             annotation = ann;
 
@@ -704,21 +879,78 @@ public class AnnotationFile
           al.setAnnotationIndex(annotation,
                   al.getAlignmentAnnotation().length - existingAnnotations
                           - 1);
+          if (groupRef != null)
+          {
+            ((Vector) groupRefRows.get(groupRef)).addElement(annotation);
+          }
         }
+        // and set modification flag
+        modified = true;
       }
+      // Finally, resolve the groupRefs
+      Enumeration en = groupRefRows.keys();
+      SequenceGroup theGroup = null;
 
-    } catch (Exception ex)
-    {
-      ex.printStackTrace();
-      System.out.println("Problem reading annotation file: " + ex);
-      return false;
+      while (en.hasMoreElements())
+      {
+        groupRef = (String) en.nextElement();
+        boolean matched = false;
+        // Resolve group: TODO: add a getGroupByName method to alignments
+        Vector grps = al.getGroups();
+        for (int g = 0, gSize = grps.size(); g < gSize; g++)
+        {
+          theGroup = (SequenceGroup) grps.elementAt(g);
+          if (theGroup.getName().equals(groupRef))
+          {
+            if (matched)
+            {
+              // TODO: specify and implement duplication of alignment annotation
+              // for multiple group references.
+              System.err
+                      .println("Ignoring 1:many group reference mappings for group name '"
+                              + groupRef + "'");
+            }
+            else
+            {
+              matched = true;
+              Vector rowset = (Vector) groupRefRows.get(groupRef);
+              if (rowset != null && rowset.size() > 0)
+              {
+                AlignmentAnnotation alan = null;
+                for (int elm = 0, elmSize = rowset.size(); elm < elmSize; elm++)
+                {
+                  alan = (AlignmentAnnotation) rowset.elementAt(elm);
+                  alan.groupRef = theGroup;
+                }
+              }
+            }
+          }
+        }
+        ((Vector) groupRefRows.get(groupRef)).removeAllElements();
+      }
     }
-    return true;
+    return modified;
+  }
+
+  private Object autoAnnotsKey(AlignmentAnnotation annotation,
+          SequenceI refSeq, String groupRef)
+  {
+    return annotation.graph + "\t" + annotation.label + "\t"
+            + annotation.description + "\t"
+            + (refSeq != null ? refSeq.getDisplayId(true) : "");
   }
 
   Annotation parseAnnotation(String string, int graphStyle)
   {
-    boolean hasSymbols = (graphStyle == AlignmentAnnotation.NO_GRAPH); // don't do the glyph test if we don't want secondary structure
+    boolean hasSymbols = (graphStyle == AlignmentAnnotation.NO_GRAPH); // don't
+    // do the
+    // glyph
+    // test
+    // if we
+    // don't
+    // want
+    // secondary
+    // structure
     String desc = null, displayChar = null;
     char ss = ' '; // secondaryStructure
     float value = 0;
@@ -733,7 +965,7 @@ public class AnnotationFile
       UserColourScheme ucs = new UserColourScheme();
 
       colour = ucs.getColourFromString(string.substring(i + 1, j));
-      if ( i>0 && string.charAt(i-1)==',')
+      if (i > 0 && string.charAt(i - 1) == ',')
       {
         // clip the preceding comma as well
         i--;
@@ -743,8 +975,8 @@ public class AnnotationFile
 
     StringTokenizer st = new StringTokenizer(string, ",", true);
     String token;
-    boolean seenContent=false;
-    int pass=0;
+    boolean seenContent = false;
+    int pass = 0;
     while (st.hasMoreTokens())
     {
       pass++;
@@ -759,7 +991,9 @@ public class AnnotationFile
         }
         seenContent = false;
         continue;
-      } else {
+      }
+      else
+      {
         seenContent = true;
       }
 
@@ -767,7 +1001,7 @@ public class AnnotationFile
       {
         try
         {
-          displayChar = token; 
+          displayChar = token;
           // foo
           value = new Float(token).floatValue();
           parsedValue = true;
@@ -775,13 +1009,17 @@ public class AnnotationFile
         } catch (NumberFormatException ex)
         {
         }
-      } else {
-        if (token.length()==1)
+      }
+      else
+      {
+        if (token.length() == 1)
         {
           displayChar = token;
         }
       }
-      if (hasSymbols && (token.equals("H") || token.equals("E") || token.equals(" ")))
+      if (hasSymbols
+              && (token.equals("H") || token.equals("E") || token.equals("S") || token
+                      .equals(" ")))
       {
         // Either this character represents a helix or sheet
         // or an integer which can be displayed
@@ -791,26 +1029,29 @@ public class AnnotationFile
           displayChar = "";
         }
       }
-      else if (desc == null || (parsedValue && pass>2))
+      else if (desc == null || (parsedValue && pass > 2))
       {
         desc = token;
       }
 
     }
-//    if (!dcset && string.charAt(string.length() - 1) == ',')
-//    {
-//      displayChar = " "; // empty display char symbol.
-//    }
-    if (displayChar != null && desc!=null && desc.length()==1) 
+    // if (!dcset && string.charAt(string.length() - 1) == ',')
+    // {
+    // displayChar = " "; // empty display char symbol.
+    // }
+    if (displayChar != null && desc != null && desc.length() == 1)
     {
       if (displayChar.length() > 1)
       {
-        // switch desc and displayChar - legacy support  
+        // switch desc and displayChar - legacy support
         String tmp = displayChar;
         displayChar = desc;
         desc = tmp;
-      } else {
-        if (displayChar.equals(desc)) {
+      }
+      else
+      {
+        if (displayChar.equals(desc))
+        {
           // duplicate label - hangover from the 'robust parser' above
           desc = null;
         }
@@ -848,45 +1089,55 @@ public class AnnotationFile
     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() != null)
     {
-      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))
         {
+          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;
+          }
+        }
+      }
+    }
+    else
+    {
+      System.err
+              .println("Couldn't combine annotations. None are added to alignment yet!");
     }
   }
 
   void addLine(AlignmentI al, StringTokenizer st)
   {
     String group = st.nextToken();
-    AlignmentAnnotation annotation = null;
-
-    for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
+    AlignmentAnnotation annotation = null, alannot[] = al
+            .getAlignmentAnnotation();
+    if (alannot != null)
     {
-      if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
+      for (int i = 0; i < alannot.length; i++)
       {
-        annotation = al.getAlignmentAnnotation()[i];
-        break;
+        if (alannot[i].label.equalsIgnoreCase(group))
+        {
+          annotation = alannot[i];
+          break;
+        }
       }
     }
-
     if (annotation == null)
     {
       return;
@@ -977,9 +1228,7 @@ public class AnnotationFile
         }
         else
         {
-          sg
-                  .addSequence(al.getSequenceAt(Integer.parseInt(tmp) - 1),
-                          false);
+          sg.addSequence(al.getSequenceAt(Integer.parseInt(tmp) - 1), false);
         }
       }
     }
@@ -999,22 +1248,28 @@ public class AnnotationFile
 
   void addRowProperties(AlignmentI al, StringTokenizer st)
   {
-    String label = st.nextToken(),keyValue,key,value;
-    boolean scaletofit=false,centerlab=false,showalllabs=false;
-    while (st.hasMoreTokens()) {
-      keyValue=st.nextToken();
+    String label = st.nextToken(), keyValue, key, value;
+    boolean scaletofit = false, centerlab = false, showalllabs = false;
+    while (st.hasMoreTokens())
+    {
+      keyValue = st.nextToken();
       key = keyValue.substring(0, keyValue.indexOf("="));
       value = keyValue.substring(keyValue.indexOf("=") + 1);
-      if (key.equalsIgnoreCase("scaletofit")) {
+      if (key.equalsIgnoreCase("scaletofit"))
+      {
         scaletofit = Boolean.valueOf(value).booleanValue();
       }
-        if (key.equalsIgnoreCase("showalllabs")) {
-          showalllabs = Boolean.valueOf(value).booleanValue();
-        }
-        if (key.equalsIgnoreCase("centrelabs")) {
-          centerlab = Boolean.valueOf(value).booleanValue();
-    }
-        AlignmentAnnotation[] alr = al.getAlignmentAnnotation(); 
+      if (key.equalsIgnoreCase("showalllabs"))
+      {
+        showalllabs = Boolean.valueOf(value).booleanValue();
+      }
+      if (key.equalsIgnoreCase("centrelabs"))
+      {
+        centerlab = Boolean.valueOf(value).booleanValue();
+      }
+      AlignmentAnnotation[] alr = al.getAlignmentAnnotation();
+      if (alr != null)
+      {
         for (int i = 0; i < alr.length; i++)
         {
           if (alr[i].label.equalsIgnoreCase(label))
@@ -1024,8 +1279,10 @@ public class AnnotationFile
             alr[i].showAllColLabels = showalllabs;
           }
         }
+      }
     }
   }
+
   void addProperties(AlignmentI al, StringTokenizer st)
   {
 
@@ -1082,8 +1339,8 @@ public class AnnotationFile
         {
           sg.cs.setConservationInc(Integer.parseInt(value));
           Conservation c = new Conservation("Group",
-                  ResidueProperties.propHash, 3, sg.getSequences(null), sg
-                          .getStartRes(), sg.getEndRes() + 1);
+                  ResidueProperties.propHash, 3, sg.getSequences(null),
+                  sg.getStartRes(), sg.getEndRes() + 1);
 
           c.calculate();
           c.verdict(false, 25);
@@ -1101,7 +1358,7 @@ public class AnnotationFile
         }
         else if (key.equalsIgnoreCase("showUnconserved"))
         {
-          sg.setShowunconserved(Boolean.valueOf(value).booleanValue());
+          sg.setShowNonconserved(Boolean.valueOf(value).booleanValue());
         }
         else if (key.equalsIgnoreCase("displayText"))
         {
@@ -1151,19 +1408,35 @@ public class AnnotationFile
   void setBelowAlignment(AlignmentI al, StringTokenizer st)
   {
     String token;
-    AlignmentAnnotation aa;
+    AlignmentAnnotation aa, ala[] = al.getAlignmentAnnotation();
+    if (ala == null)
+    {
+      System.err
+              .print("Warning - no annotation to set below for sequence associated annotation:");
+    }
     while (st.hasMoreTokens())
     {
       token = st.nextToken();
-      for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
+      if (ala == null)
+      {
+        System.err.print(" " + token);
+      }
+      else
       {
-        aa = al.getAlignmentAnnotation()[i];
-        if (aa.sequenceRef == refSeq && aa.label.equals(token))
+        for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
         {
-          aa.belowAlignment = true;
+          aa = al.getAlignmentAnnotation()[i];
+          if (aa.sequenceRef == refSeq && aa.label.equals(token))
+          {
+            aa.belowAlignment = true;
+          }
         }
       }
     }
+    if (ala == null)
+    {
+      System.err.print("\n");
+    }
   }
 
   void addAlignmentDetails(AlignmentI al, StringTokenizer st)
@@ -1204,7 +1477,7 @@ public class AnnotationFile
         else
         {
           sp.append(atos.substring(p));
-          sp.append("\n");
+          sp.append(newline);
         }
         p = cp + 1;
       } while (p > 0);