git://source.jalview.org / jalview.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
JAL-2089 patch broken merge to master for Release 2.10.0b1
[jalview.git] / src / jalview / renderer / AnnotationRenderer.java
diff --git a/src/jalview/renderer/AnnotationRenderer.java b/src/jalview/renderer/AnnotationRenderer.java
index 4c3711d..3fdcb3b 100644 (file)
--- a/src/jalview/renderer/AnnotationRenderer.java
+++ b/src/jalview/renderer/AnnotationRenderer.java
@@ -1,6 +1,6 @@
 /*
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
- * Copyright (C) 2014 The Jalview Authors
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors
  * 
  * This file is part of Jalview.
  * 
  * 
  * This file is part of Jalview.
  * 
@@ -21,12 +21,16 @@
 package jalview.renderer;
 
 import jalview.analysis.AAFrequency;
 package jalview.renderer;
 
 import jalview.analysis.AAFrequency;
+import jalview.analysis.CodingUtils;
+import jalview.analysis.Rna;
 import jalview.analysis.StructureFrequency;
 import jalview.api.AlignViewportI;
 import jalview.datamodel.AlignmentAnnotation;
 import jalview.datamodel.Annotation;
 import jalview.datamodel.ColumnSelection;
 import jalview.schemes.ColourSchemeI;
 import jalview.analysis.StructureFrequency;
 import jalview.api.AlignViewportI;
 import jalview.datamodel.AlignmentAnnotation;
 import jalview.datamodel.Annotation;
 import jalview.datamodel.ColumnSelection;
 import jalview.schemes.ColourSchemeI;
+import jalview.schemes.ResidueProperties;
+import jalview.util.Platform;
 
 import java.awt.BasicStroke;
 import java.awt.Color;
 
 import java.awt.BasicStroke;
 import java.awt.Color;
@@ -41,88 +45,18 @@ import java.awt.image.ImageObserver;
 import java.util.BitSet;
 import java.util.Hashtable;
 
 import java.util.BitSet;
 import java.util.Hashtable;
 
-import com.stevesoft.pat.Regex;
-
 public class AnnotationRenderer
 {
 public class AnnotationRenderer
 {
-  /**
-   * flag indicating if timing and redraw parameter info should be output
-   */
-  private final boolean debugRedraw;
+  private static final int UPPER_TO_LOWER = 'a' - 'A'; // 32
 
 
-  public AnnotationRenderer()
-  {
-    this(false);
-  }
+  private static final int CHAR_A = 'A'; // 65
+
+  private static final int CHAR_Z = 'Z'; // 90
 
   /**
 
   /**
-   * Create a new annotation Renderer
-   * 
-   * @param debugRedraw
-   *          flag indicating if timing and redraw parameter info should be
-   *          output
+   * flag indicating if timing and redraw parameter info should be output
    */
    */
-  public AnnotationRenderer(boolean debugRedraw)
-  {
-    this.debugRedraw = debugRedraw;
-  }
-
-  public void drawStemAnnot(Graphics g, Annotation[] row_annotations,
-          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;
-    int x2 = (x * charWidth);
-    Regex closeparen = new Regex("(\\))");
-
-    String dc = (column == 0 || row_annotations[column - 1] == null) ? ""
-            : row_annotations[column - 1].displayCharacter;
-
-    boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
-            || !dc.equals(row_annotations[sCol - 1].displayCharacter);
-    boolean diffdownstream = !validRes || !validEnd
-            || row_annotations[column] == null
-            || !dc.equals(row_annotations[column].displayCharacter);
-    // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream);
-    // If a closing base pair half of the stem, display a backward arrow
-    if (column > 0 && closeparen.search(dc))
-    {
-
-      if (diffupstream)
-      // if (validRes && column>1 && row_annotations[column-2]!=null &&
-      // dc.equals(row_annotations[column-2].displayCharacter))
-      {
-        g.fillPolygon(new int[]
-        { lastSSX + 5, lastSSX + 5, lastSSX }, new int[]
-        { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
-        x1 += 5;
-      }
-      if (diffdownstream)
-      {
-        x2 -= 1;
-      }
-    }
-    else
-    {
-
-      // display a forward arrow
-      if (diffdownstream)
-      {
-        g.fillPolygon(new int[]
-        { x2 - 5, x2 - 5, x2 }, new int[]
-        { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
-        x2 -= 5;
-      }
-      if (diffupstream)
-      {
-        x1 += 1;
-      }
-    }
-    // draw arrow body
-    g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
-  }
+  private final boolean debugRedraw;
 
   private int charWidth, endRes, charHeight;
 
 
   private int charWidth, endRes, charHeight;
 
@@ -130,7 +64,7 @@ public class AnnotationRenderer
 
   private FontMetrics fm;
 
 
   private FontMetrics fm;
 
-  private final boolean MAC = new jalview.util.Platform().isAMac();
+  private final boolean MAC = Platform.isAMac();
 
   boolean av_renderHistogram = true, av_renderProfile = true,
           av_normaliseProfile = false;
 
   boolean av_renderHistogram = true, av_renderProfile = true,
           av_normaliseProfile = false;
@@ -141,6 +75,8 @@ public class AnnotationRenderer
 
   private Hashtable[] hconsensus;
 
 
   private Hashtable[] hconsensus;
 
+  private Hashtable[] complementConsensus;
+
   private Hashtable[] hStrucConsensus;
 
   private boolean av_ignoreGapsConsensus;
   private Hashtable[] hStrucConsensus;
 
   private boolean av_ignoreGapsConsensus;
@@ -186,7 +122,96 @@ public class AnnotationRenderer
    */
   private boolean canClip = false;
 
    */
   private boolean canClip = false;
 
-  public void drawNotCanonicalAnnot(Graphics g, Color nonCanColor,
+  public AnnotationRenderer()
+  {
+    this(false);
+  }
+
+  /**
+   * Create a new annotation Renderer
+   * 
+   * @param debugRedraw
+   *          flag indicating if timing and redraw parameter info should be
+   *          output
+   */
+  public AnnotationRenderer(boolean debugRedraw)
+  {
+    this.debugRedraw = debugRedraw;
+  }
+
+  /**
+   * Remove any references and resources when this object is no longer required
+   */
+  public void dispose()
+  {
+    hconsensus = null;
+    complementConsensus = null;
+    hStrucConsensus = null;
+    fadedImage = null;
+    annotationPanel = null;
+  }
+
+  void drawStemAnnot(Graphics g, Annotation[] row_annotations, 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;
+    int x2 = (x * charWidth);
+
+    char dc = (column == 0 || row_annotations[column - 1] == null) ? ' '
+            : row_annotations[column - 1].secondaryStructure;
+
+    boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
+            || dc != row_annotations[sCol - 1].secondaryStructure;
+    boolean diffdownstream = !validRes || !validEnd
+            || row_annotations[column] == null
+            || dc != row_annotations[column].secondaryStructure;
+
+    if (column > 0 && Rna.isClosingParenthesis(dc))
+    {
+      if (diffupstream)
+      // if (validRes && column>1 && row_annotations[column-2]!=null &&
+      // dc.equals(row_annotations[column-2].displayCharacter))
+      {
+        /*
+         * if new annotation with a closing base pair half of the stem, 
+         * display a backward arrow
+         */
+        g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
+                new int[] { y + iconOffset, y + 14 + iconOffset,
+                    y + 8 + iconOffset }, 3);
+        x1 += 5;
+      }
+      if (diffdownstream)
+      {
+        x2 -= 1;
+      }
+    }
+    else
+    {
+      // display a forward arrow
+      if (diffdownstream)
+      {
+        /*
+         * if annotation ending with an opeing base pair half of the stem, 
+         * display a forward arrow
+         */
+        g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 }, new int[] {
+            y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
+        x2 -= 5;
+      }
+      if (diffupstream)
+      {
+        x1 += 1;
+      }
+    }
+    // draw arrow body
+    g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
+  }
+
+  void drawNotCanonicalAnnot(Graphics g, Color nonCanColor,
           Annotation[] row_annotations, int lastSSX, int x, int y,
           int iconOffset, int startRes, int column, boolean validRes,
           boolean validEnd)
           Annotation[] row_annotations, int lastSSX, int x, int y,
           int iconOffset, int startRes, int column, boolean validRes,
           boolean validEnd)
@@ -197,7 +222,6 @@ public class AnnotationRenderer
     int sCol = (lastSSX / charWidth) + startRes;
     int x1 = lastSSX;
     int x2 = (x * charWidth);
     int sCol = (lastSSX / charWidth) + startRes;
     int x1 = lastSSX;
     int x2 = (x * charWidth);
-    Regex closeparen = new Regex("}|]|<|[a-z]");
 
     String dc = (column == 0 || row_annotations[column - 1] == null) ? ""
             : row_annotations[column - 1].displayCharacter;
 
     String dc = (column == 0 || row_annotations[column - 1] == null) ? ""
             : row_annotations[column - 1].displayCharacter;
@@ -209,17 +233,16 @@ public class AnnotationRenderer
             || !dc.equals(row_annotations[column].displayCharacter);
     // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream);
     // If a closing base pair half of the stem, display a backward arrow
             || !dc.equals(row_annotations[column].displayCharacter);
     // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream);
     // If a closing base pair half of the stem, display a backward arrow
-    if (column > 0 && closeparen.search(dc))// closeletter_b.search(dc)||closeletter_c.search(dc)||closeletter_d.search(dc)||closecrochet.search(dc))
-                                            // )
+    if (column > 0 && Rna.isClosingParenthesis(dc))
     {
 
       if (diffupstream)
       // if (validRes && column>1 && row_annotations[column-2]!=null &&
       // dc.equals(row_annotations[column-2].displayCharacter))
       {
     {
 
       if (diffupstream)
       // if (validRes && column>1 && row_annotations[column-2]!=null &&
       // dc.equals(row_annotations[column-2].displayCharacter))
       {
-        g.fillPolygon(new int[]
-        { lastSSX + 5, lastSSX + 5, lastSSX }, new int[]
-        { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
+        g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
+                new int[] { y + iconOffset, y + 14 + iconOffset,
+                    y + 8 + iconOffset }, 3);
         x1 += 5;
       }
       if (diffdownstream)
         x1 += 5;
       }
       if (diffdownstream)
@@ -233,9 +256,8 @@ public class AnnotationRenderer
       // display a forward arrow
       if (diffdownstream)
       {
       // display a forward arrow
       if (diffdownstream)
       {
-        g.fillPolygon(new int[]
-        { x2 - 5, x2 - 5, x2 }, new int[]
-        { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
+        g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 }, new int[] {
+            y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
         x2 -= 5;
       }
       if (diffupstream)
         x2 -= 5;
       }
       if (diffupstream)
@@ -298,22 +320,36 @@ public class AnnotationRenderer
               : new jalview.schemes.ZappoColourScheme();
     }
     columnSelection = av.getColumnSelection();
               : new jalview.schemes.ZappoColourScheme();
     }
     columnSelection = av.getColumnSelection();
-    hconsensus = av.getSequenceConsensusHash();// hconsensus;
-    hStrucConsensus = av.getRnaStructureConsensusHash(); // hStrucConsensus;
-    av_ignoreGapsConsensus = av.getIgnoreGapsConsensus();
+    hconsensus = av.getSequenceConsensusHash();
+    complementConsensus = av.getComplementConsensusHash();
+    hStrucConsensus = av.getRnaStructureConsensusHash();
+    av_ignoreGapsConsensus = av.isIgnoreGapsConsensus();
   }
 
   }
 
-  public int[] getProfileFor(AlignmentAnnotation aa, int column)
+  /**
+   * Returns profile data; the first element is the profile type, the second is
+   * the number of distinct values, the third the total count, and the remainder
+   * depend on the profile type.
+   * 
+   * @param aa
+   * @param column
+   * @return
+   */
+  int[] getProfileFor(AlignmentAnnotation aa, int column)
   {
     // TODO : consider refactoring the global alignment calculation
     // properties/rendering attributes as a global 'alignment group' which holds
     // all vis settings for the alignment as a whole rather than a subset
     //
   {
     // TODO : consider refactoring the global alignment calculation
     // properties/rendering attributes as a global 'alignment group' which holds
     // all vis settings for the alignment as a whole rather than a subset
     //
-    if (aa.autoCalculated && aa.label.startsWith("Consensus"))
+    if (aa.autoCalculated
+            && (aa.label.startsWith("Consensus") || aa.label
+                    .startsWith("cDNA Consensus")))
     {
     {
+      boolean forComplement = aa.label.startsWith("cDNA Consensus");
       if (aa.groupRef != null && aa.groupRef.consensusData != null
               && aa.groupRef.isShowSequenceLogo())
       {
       if (aa.groupRef != null && aa.groupRef.consensusData != null
               && aa.groupRef.isShowSequenceLogo())
       {
+        // TODO? group consensus for cDNA complement
         return AAFrequency.extractProfile(
                 aa.groupRef.consensusData[column],
                 aa.groupRef.getIgnoreGapsConsensus());
         return AAFrequency.extractProfile(
                 aa.groupRef.consensusData[column],
                 aa.groupRef.getIgnoreGapsConsensus());
@@ -322,8 +358,16 @@ public class AnnotationRenderer
       // be stored
       if (aa.groupRef == null && aa.sequenceRef == null)
       {
       // be stored
       if (aa.groupRef == null && aa.sequenceRef == null)
       {
-        return AAFrequency.extractProfile(hconsensus[column],
-                av_ignoreGapsConsensus);
+        if (forComplement)
+        {
+          return AAFrequency.extractCdnaProfile(
+                  complementConsensus[column], av_ignoreGapsConsensus);
+        }
+        else
+        {
+          return AAFrequency.extractProfile(hconsensus[column],
+                  av_ignoreGapsConsensus);
+        }
       }
     }
     else
       }
     }
     else
@@ -353,6 +397,8 @@ public class AnnotationRenderer
     return null;
   }
 
     return null;
   }
 
+  boolean rna = false;
+
   /**
    * Render the annotation rows associated with an alignment.
    * 
   /**
    * Render the annotation rows associated with an alignment.
    * 
@@ -396,13 +442,16 @@ public class AnnotationRenderer
     boolean validRes = false;
     boolean validEnd = false;
     boolean labelAllCols = false;
     boolean validRes = false;
     boolean validEnd = false;
     boolean labelAllCols = false;
-    boolean centreColLabels, centreColLabelsDef = av
-            .getCentreColumnLabels();
+    boolean centreColLabels;
+    boolean centreColLabelsDef = av.isCentreColumnLabels();
     boolean scaleColLabel = false;
     boolean scaleColLabel = false;
-    AlignmentAnnotation consensusAnnot = av
-            .getAlignmentConsensusAnnotation(), structConsensusAnnot = av
+    final AlignmentAnnotation consensusAnnot = av
+            .getAlignmentConsensusAnnotation();
+    final AlignmentAnnotation structConsensusAnnot = av
             .getAlignmentStrucConsensusAnnotation();
             .getAlignmentStrucConsensusAnnotation();
-    boolean renderHistogram = true, renderProfile = true, normaliseProfile = false;
+    final AlignmentAnnotation complementConsensusAnnot = av
+            .getComplementConsensusAnnotation();
+    boolean renderHistogram = true, renderProfile = true, normaliseProfile = false, isRNA = rna;
 
     BitSet graphGroupDrawn = new BitSet();
     int charOffset = 0; // offset for a label
 
     BitSet graphGroupDrawn = new BitSet();
     int charOffset = 0; // offset for a label
@@ -416,6 +465,7 @@ public class AnnotationRenderer
     for (int i = 0; i < aa.length; i++)
     {
       AlignmentAnnotation row = aa[i];
     for (int i = 0; i < aa.length; i++)
     {
       AlignmentAnnotation row = aa[i];
+      isRNA = row.isRNA();
       {
         // check if this is a consensus annotation row and set the display
         // settings appropriately
       {
         // check if this is a consensus annotation row and set the display
         // settings appropriately
@@ -427,7 +477,8 @@ public class AnnotationRenderer
           renderProfile = row.groupRef.isShowSequenceLogo();
           normaliseProfile = row.groupRef.isNormaliseSequenceLogo();
         }
           renderProfile = row.groupRef.isShowSequenceLogo();
           normaliseProfile = row.groupRef.isNormaliseSequenceLogo();
         }
-        else if (row == consensusAnnot || row == structConsensusAnnot)
+        else if (row == consensusAnnot || row == structConsensusAnnot
+                || row == complementConsensusAnnot)
         {
           renderHistogram = av_renderHistogram;
           renderProfile = av_renderProfile;
         {
           renderHistogram = av_renderHistogram;
           renderProfile = av_renderProfile;
@@ -551,6 +602,8 @@ public class AnnotationRenderer
           {
             validRes = true;
           }
           {
             validRes = true;
           }
+          final String displayChar = validRes ? row_annotations[column].displayCharacter
+                  : null;
           if (x > -1)
           {
             if (activeRow == i)
           if (x > -1)
           {
             if (activeRow == i)
@@ -559,77 +612,77 @@ public class AnnotationRenderer
 
               if (columnSelection != null)
               {
 
               if (columnSelection != null)
               {
-                for (int n = 0; n < columnSelection.size(); n++)
+                if (columnSelection.contains(column))
                 {
                 {
-                  int v = columnSelection.columnAt(n);
-
-                  if (v == column)
-                  {
-                    g.fillRect(x * charWidth, y, charWidth, charHeight);
-                  }
+                  g.fillRect(x * charWidth, y, charWidth, charHeight);
                 }
               }
             }
                 }
               }
             }
-            if (!row.isValidStruc())
+            if (row.getInvalidStrucPos() > x)
             {
               g.setColor(Color.orange);
             {
               g.setColor(Color.orange);
-              g.fillRect((int) row.getInvalidStrucPos() * charWidth, y,
-                      charWidth, charHeight);
+              g.fillRect(x * charWidth, y, charWidth, charHeight);
+            }
+            else if (row.getInvalidStrucPos() == x)
+            {
+              g.setColor(Color.orange.darker());
+              g.fillRect(x * charWidth, y, charWidth, charHeight);
             }
             }
-            if (validCharWidth
-                    && validRes
-                    && row_annotations[column].displayCharacter != null
-                    && (row_annotations[column].displayCharacter.length() > 0))
+            if (validCharWidth && validRes && displayChar != null
+                    && (displayChar.length() > 0))
             {
 
             {
 
-              if (centreColLabels || scaleColLabel)
+              fmWidth = fm.charsWidth(displayChar.toCharArray(), 0,
+                      displayChar.length());
+              if (/* centreColLabels || */scaleColLabel)
               {
               {
-                fmWidth = fm.charsWidth(
-                        row_annotations[column].displayCharacter
-                                .toCharArray(), 0,
-                        row_annotations[column].displayCharacter.length());
-
-                if (scaleColLabel)
+                // fmWidth = fm.charsWidth(displayChar.toCharArray(), 0,
+                // displayChar.length());
+                //
+                // if (scaleColLabel)
+                // {
+                // justify the label and scale to fit in column
+                if (fmWidth > charWidth)
                 {
                 {
-                  // justify the label and scale to fit in column
-                  if (fmWidth > charWidth)
-                  {
-                    // scale only if the current font isn't already small enough
-                    fmScaling = charWidth;
-                    fmScaling /= fmWidth;
-                    g.setFont(ofont.deriveFont(AffineTransform
-                            .getScaleInstance(fmScaling, 1.0)));
-                    // and update the label's width to reflect the scaling.
-                    fmWidth = charWidth;
-                  }
+                  // scale only if the current font isn't already small enough
+                  fmScaling = charWidth;
+                  fmScaling /= fmWidth;
+                  g.setFont(ofont.deriveFont(AffineTransform
+                          .getScaleInstance(fmScaling, 1.0)));
+                  // and update the label's width to reflect the scaling.
+                  fmWidth = charWidth;
                 }
                 }
+                // }
               }
               }
-              else
-              {
-                fmWidth = fm
-                        .charWidth(row_annotations[column].displayCharacter
-                                .charAt(0));
-              }
+              // TODO is it ok to use width of / show all characters here?
+              // else
+              // {
+              // fmWidth = fm.charWidth(displayChar.charAt(0));
+              // }
               charOffset = (int) ((charWidth - fmWidth) / 2f);
 
               if (row_annotations[column].colour == null)
               charOffset = (int) ((charWidth - fmWidth) / 2f);
 
               if (row_annotations[column].colour == null)
+              {
                 g.setColor(Color.black);
                 g.setColor(Color.black);
+              }
               else
               else
+              {
                 g.setColor(row_annotations[column].colour);
                 g.setColor(row_annotations[column].colour);
+              }
 
               if (column == 0 || row.graph > 0)
               {
 
               if (column == 0 || row.graph > 0)
               {
-                g.drawString(row_annotations[column].displayCharacter,
-                        (x * charWidth) + charOffset, y + iconOffset);
+                g.drawString(displayChar, (x * charWidth) + charOffset, y
+                        + iconOffset);
               }
               else if (row_annotations[column - 1] == null
                       || (labelAllCols
               }
               else if (row_annotations[column - 1] == null
                       || (labelAllCols
-                              || !row_annotations[column].displayCharacter
-                                      .equals(row_annotations[column - 1].displayCharacter) || (row_annotations[column].displayCharacter
+                              || !displayChar
+                                      .equals(row_annotations[column - 1].displayCharacter) || (displayChar
                               .length() < 2 && row_annotations[column].secondaryStructure == ' ')))
               {
                               .length() < 2 && row_annotations[column].secondaryStructure == ' ')))
               {
-                g.drawString(row_annotations[column].displayCharacter, x
-                        * charWidth + charOffset, y + iconOffset);
+                g.drawString(displayChar, x * charWidth + charOffset, y
+                        + iconOffset);
               }
               g.setFont(ofont);
             }
               }
               g.setFont(ofont);
             }
@@ -642,7 +695,7 @@ public class AnnotationRenderer
             if (ss == '(')
             {
               // distinguish between forward/backward base-pairing
             if (ss == '(')
             {
               // distinguish between forward/backward base-pairing
-              if (row_annotations[column].displayCharacter.indexOf(')') > -1)
+              if (displayChar.indexOf(')') > -1)
               {
 
                 ss = ')';
               {
 
                 ss = ')';
@@ -651,7 +704,7 @@ public class AnnotationRenderer
             }
             if (ss == '[')
             {
             }
             if (ss == '[')
             {
-              if ((row_annotations[column].displayCharacter.indexOf(']') > -1))
+              if ((displayChar.indexOf(']') > -1))
               {
                 ss = ']';
 
               {
                 ss = ']';
 
@@ -660,7 +713,7 @@ public class AnnotationRenderer
             if (ss == '{')
             {
               // distinguish between forward/backward base-pairing
             if (ss == '{')
             {
               // distinguish between forward/backward base-pairing
-              if (row_annotations[column].displayCharacter.indexOf('}') > -1)
+              if (displayChar.indexOf('}') > -1)
               {
                 ss = '}';
 
               {
                 ss = '}';
 
@@ -669,20 +722,20 @@ public class AnnotationRenderer
             if (ss == '<')
             {
               // distinguish between forward/backward base-pairing
             if (ss == '<')
             {
               // distinguish between forward/backward base-pairing
-              if (row_annotations[column].displayCharacter.indexOf('<') > -1)
+              if (displayChar.indexOf('<') > -1)
               {
                 ss = '>';
 
               }
             }
               {
                 ss = '>';
 
               }
             }
-            if (ss >= 65)
+            if (isRNA && (ss >= CHAR_A) && (ss <= CHAR_Z))
             {
               // distinguish between forward/backward base-pairing
             {
               // distinguish between forward/backward base-pairing
-              if (row_annotations[column].displayCharacter.indexOf(ss + 32) > -1)
+              int ssLowerCase = ss + UPPER_TO_LOWER;
+              // TODO would .equals() be safer here? or charAt(0)?
+              if (displayChar.indexOf(ssLowerCase) > -1)
               {
               {
-
-                ss = (char) (ss + 32);
-
+                ss = (char) ssLowerCase;
               }
             }
 
               }
             }
 
@@ -696,23 +749,32 @@ public class AnnotationRenderer
                 // System.out.println("\t type :"+lastSS+"\t x :"+x+"\t nbre annot :"+nb_annot);
                 switch (lastSS)
                 {
                 // System.out.println("\t type :"+lastSS+"\t x :"+x+"\t nbre annot :"+nb_annot);
                 switch (lastSS)
                 {
-
-                case '$':
-                  drawHelixAnnot(g, row_annotations, lastSSX, x, y,
-                          iconOffset, startRes, column, validRes, validEnd);
-                  break;
-
-                case '�':
-                  drawSheetAnnot(g, row_annotations, lastSSX, x, y,
-                          iconOffset, startRes, column, validRes, validEnd);
-                  break;
-
                 case '(': // Stem case for RNA secondary structure
                 case ')': // and opposite direction
                   drawStemAnnot(g, row_annotations, lastSSX, x, y,
                           iconOffset, startRes, column, validRes, validEnd);
                   temp = x;
                   break;
                 case '(': // Stem case for RNA secondary structure
                 case ')': // and opposite direction
                   drawStemAnnot(g, row_annotations, lastSSX, x, y,
                           iconOffset, startRes, column, validRes, validEnd);
                   temp = x;
                   break;
+
+                case 'H':
+                  if (!isRNA)
+                  {
+                    drawHelixAnnot(g, row_annotations, lastSSX, x, y,
+                            iconOffset, startRes, column, validRes,
+                            validEnd);
+                    break;
+                  }
+                  // no break if isRNA - falls through to drawNotCanonicalAnnot!
+                case 'E':
+                  if (!isRNA)
+                  {
+                    drawSheetAnnot(g, row_annotations, lastSSX, x, y,
+                            iconOffset, startRes, column, validRes,
+                            validEnd);
+                    break;
+                  }
+                  // no break if isRNA - fall through to drawNotCanonicalAnnot!
+
                 case '{':
                 case '}':
                 case '[':
                 case '{':
                 case '}':
                 case '[':
@@ -727,13 +789,11 @@ public class AnnotationRenderer
                 case 'c':
                 case 'D':
                 case 'd':
                 case 'c':
                 case 'D':
                 case 'd':
-                case 'E':
                 case 'e':
                 case 'F':
                 case 'f':
                 case 'G':
                 case 'g':
                 case 'e':
                 case 'F':
                 case 'f':
                 case 'G':
                 case 'g':
-                case 'H':
                 case 'h':
                 case 'I':
                 case 'i':
                 case 'h':
                 case 'I':
                 case 'i':
@@ -821,24 +881,33 @@ public class AnnotationRenderer
         {
           validRes = true;
         }
         {
           validRes = true;
         }
-
         // x ++;
 
         if (row.hasIcons)
         {
           switch (lastSS)
           {
         // x ++;
 
         if (row.hasIcons)
         {
           switch (lastSS)
           {
-          case '$':
-            drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
-                    startRes, column, validRes, validEnd);
-            break;
 
 
-          case '�':
-            drawSheetAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
-                    startRes, column, validRes, validEnd);
-            break;
-          case 's':
-          case 'S': // Stem case for RNA secondary structure
+          case 'H':
+            if (!isRNA)
+            {
+              drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
+                      startRes, column, validRes, validEnd);
+              break;
+            }
+            // no break if isRNA - fall through to drawNotCanonicalAnnot!
+
+          case 'E':
+            if (!isRNA)
+            {
+              drawSheetAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
+                      startRes, column, validRes, validEnd);
+              break;
+            }
+            // no break if isRNA - fall through to drawNotCanonicalAnnot!
+
+          case '(':
+          case ')': // Stem case for RNA secondary structure
 
             drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
                     startRes, column, validRes, validEnd);
 
             drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
                     startRes, column, validRes, validEnd);
@@ -858,13 +927,11 @@ public class AnnotationRenderer
           case 'c':
           case 'D':
           case 'd':
           case 'c':
           case 'D':
           case 'd':
-          case 'E':
           case 'e':
           case 'F':
           case 'f':
           case 'G':
           case 'g':
           case 'e':
           case 'F':
           case 'f':
           case 'G':
           case 'g':
-          case 'H':
           case 'h':
           case 'I':
           case 'i':
           case 'h':
           case 'I':
           case 'i':
@@ -1008,25 +1075,25 @@ public class AnnotationRenderer
     return !usedFaded;
   }
 
     return !usedFaded;
   }
 
-  private final Color GLYPHLINE_COLOR = Color.gray;
+  public static final Color GLYPHLINE_COLOR = Color.gray;
 
 
-  private final Color SHEET_COLOUR = Color.green;
+  public static final Color SHEET_COLOUR = Color.green;
 
 
-  private final Color HELIX_COLOUR = Color.red;
+  public static final Color HELIX_COLOUR = Color.red;
 
 
-  private final Color STEM_COLOUR = Color.blue;
+  public static final Color STEM_COLOUR = Color.blue;
 
   private Color sdNOTCANONICAL_COLOUR;
 
 
   private Color sdNOTCANONICAL_COLOUR;
 
-  public void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX,
-          int x, int y, int iconOffset, int startRes, int column,
+  void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX, int x,
+          int y, int iconOffset, int startRes, int column,
           boolean validRes, boolean validEnd)
   {
     g.setColor(GLYPHLINE_COLOR);
     g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
   }
 
           boolean validRes, boolean validEnd)
   {
     g.setColor(GLYPHLINE_COLOR);
     g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
   }
 
-  public void drawSheetAnnot(Graphics g, Annotation[] row,
+  void drawSheetAnnot(Graphics g, Annotation[] row,
 
   int lastSSX, int x, int y, int iconOffset, int startRes, int column,
           boolean validRes, boolean validEnd)
 
   int lastSSX, int x, int y, int iconOffset, int startRes, int column,
           boolean validRes, boolean validEnd)
@@ -1038,11 +1105,9 @@ public class AnnotationRenderer
     {
       g.fillRect(lastSSX, y + 4 + iconOffset,
               (x * charWidth) - lastSSX - 4, 7);
     {
       g.fillRect(lastSSX, y + 4 + iconOffset,
               (x * charWidth) - lastSSX - 4, 7);
-      g.fillPolygon(new int[]
-      { (x * charWidth) - 4, (x * charWidth) - 4, (x * charWidth) },
-              new int[]
-              { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset },
-              3);
+      g.fillPolygon(new int[] { (x * charWidth) - 4, (x * charWidth) - 4,
+          (x * charWidth) }, new int[] { y + iconOffset,
+          y + 14 + iconOffset, y + 7 + iconOffset }, 3);
     }
     else
     {
     }
     else
     {
@@ -1052,8 +1117,8 @@ public class AnnotationRenderer
 
   }
 
 
   }
 
-  public void drawHelixAnnot(Graphics g, Annotation[] row, int lastSSX,
-          int x, int y, int iconOffset, int startRes, int column,
+  void drawHelixAnnot(Graphics g, Annotation[] row, int lastSSX, int x,
+          int y, int iconOffset, int startRes, int column,
           boolean validRes, boolean validEnd)
   {
     g.setColor(HELIX_COLOUR);
           boolean validRes, boolean validEnd)
   {
     g.setColor(HELIX_COLOUR);
@@ -1112,7 +1177,7 @@ public class AnnotationRenderer
     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
   }
 
     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
   }
 
-  public void drawLineGraph(Graphics g, AlignmentAnnotation _aa,
+  void drawLineGraph(Graphics g, AlignmentAnnotation _aa,
           Annotation[] aa_annotations, int sRes, int eRes, int y,
           float min, float max, int graphHeight)
   {
           Annotation[] aa_annotations, int sRes, int eRes, int y,
           float min, float max, int graphHeight)
   {
@@ -1174,9 +1239,13 @@ public class AnnotationRenderer
       }
 
       if (aa_annotations[column].colour == null)
       }
 
       if (aa_annotations[column].colour == null)
+      {
         g.setColor(Color.black);
         g.setColor(Color.black);
+      }
       else
       else
+      {
         g.setColor(aa_annotations[column].colour);
         g.setColor(aa_annotations[column].colour);
+      }
 
       y1 = y
               - (int) (((aa_annotations[column - 1].value - min) / range) * graphHeight);
 
       y1 = y
               - (int) (((aa_annotations[column - 1].value - min) / range) * graphHeight);
@@ -1193,8 +1262,7 @@ public class AnnotationRenderer
       g.setColor(_aa.threshold.colour);
       Graphics2D g2 = (Graphics2D) g;
       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
       g.setColor(_aa.threshold.colour);
       Graphics2D g2 = (Graphics2D) g;
       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
-              BasicStroke.JOIN_ROUND, 3f, new float[]
-              { 5f, 3f }, 0f));
+              BasicStroke.JOIN_ROUND, 3f, new float[] { 5f, 3f }, 0f));
 
       y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight);
       g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
 
       y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight);
       g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
@@ -1202,7 +1270,7 @@ public class AnnotationRenderer
     }
   }
 
     }
   }
 
-  public void drawBarGraph(Graphics g, AlignmentAnnotation _aa,
+  void drawBarGraph(Graphics g, AlignmentAnnotation _aa,
           Annotation[] aa_annotations, int sRes, int eRes, float min,
           float max, int y, boolean renderHistogram, boolean renderProfile,
           boolean normaliseProfile)
           Annotation[] aa_annotations, int sRes, int eRes, float min,
           float max, int y, boolean renderHistogram, boolean renderProfile,
           boolean normaliseProfile)
@@ -1248,9 +1316,13 @@ public class AnnotationRenderer
         continue;
       }
       if (aa_annotations[column].colour == null)
         continue;
       }
       if (aa_annotations[column].colour == null)
+      {
         g.setColor(Color.black);
         g.setColor(Color.black);
+      }
       else
       else
+      {
         g.setColor(aa_annotations[column].colour);
         g.setColor(aa_annotations[column].colour);
+      }
 
       y1 = y
               - (int) (((aa_annotations[column].value - min) / (range)) * _aa.graphHeight);
 
       y1 = y
               - (int) (((aa_annotations[column].value - min) / (range)) * _aa.graphHeight);
@@ -1270,10 +1342,16 @@ public class AnnotationRenderer
       if (renderProfile)
       {
 
       if (renderProfile)
       {
 
+        /*
+         * {profile type, #values, total count, char1, pct1, char2, pct2...}
+         */
         int profl[] = getProfileFor(_aa, column);
         int profl[] = getProfileFor(_aa, column);
+
         // just try to draw the logo if profl is not null
         // just try to draw the logo if profl is not null
-        if (profl != null && profl[1] != 0)
+        if (profl != null && profl[2] != 0)
         {
         {
+          boolean isStructureProfile = profl[0] == AlignmentAnnotation.STRUCTURE_PROFILE;
+          boolean isCdnaProfile = profl[0] == AlignmentAnnotation.CDNA_PROFILE;
           float ht = normaliseProfile ? y - _aa.graphHeight : y1;
           double htn = normaliseProfile ? _aa.graphHeight : (y2 - y1);// aa.graphHeight;
           double hght;
           float ht = normaliseProfile ? y - _aa.graphHeight : y1;
           double htn = normaliseProfile ? _aa.graphHeight : (y2 - y1);// aa.graphHeight;
           double hght;
@@ -1282,55 +1360,81 @@ public class AnnotationRenderer
           char[] dc;
 
           /**
           char[] dc;
 
           /**
-           * profl.length == 74 indicates that the profile of a secondary
-           * structure conservation row was accesed. Therefore dc gets length 2,
-           * to have space for a basepair instead of just a single nucleotide
+           * Render a single base for a sequence profile, a base pair for
+           * structure profile, and a triplet for a cdna profile
            */
            */
-          if (profl.length == 74)
-          {
-            dc = new char[2];
-          }
-          else
-          {
-            dc = new char[1];
-          }
+          dc = new char[isStructureProfile ? 2 : (isCdnaProfile ? 3 : 1)];
+
           LineMetrics lm = g.getFontMetrics(ofont).getLineMetrics("Q", g);
           LineMetrics lm = g.getFontMetrics(ofont).getLineMetrics("Q", g);
-          double scale = 1f / (normaliseProfile ? profl[1] : 100f);
+          double scale = 1f / (normaliseProfile ? profl[2] : 100f);
           float ofontHeight = 1f / lm.getAscent();// magnify to fill box
           double scl = 0.0;
           float ofontHeight = 1f / lm.getAscent();// magnify to fill box
           double scl = 0.0;
-          for (int c = 2; c < profl[0];)
-          {
-            dc[0] = (char) profl[c++];
 
 
-            if (_aa.label.startsWith("StrucConsensus"))
+          /*
+           * Traverse the character(s)/percentage data in the array
+           */
+          int c = 3;
+          int valuesProcessed = 0;
+          // profl[1] is the number of values in the profile
+          while (valuesProcessed < profl[1])
+          {
+            if (isStructureProfile)
             {
             {
+              // todo can we encode a structure pair as an int, like codons?
+              dc[0] = (char) profl[c++];
               dc[1] = (char) profl[c++];
             }
               dc[1] = (char) profl[c++];
             }
+            else if (isCdnaProfile)
+            {
+              dc = CodingUtils.decodeCodon(profl[c++]);
+            }
+            else
+            {
+              dc[0] = (char) profl[c++];
+            }
 
             wdth = charWidth;
             wdth /= fm.charsWidth(dc, 0, dc.length);
 
             ht += scl;
 
             wdth = charWidth;
             wdth /= fm.charsWidth(dc, 0, dc.length);
 
             ht += scl;
+            // next profl[] position is profile % for the character(s)
+            scl = htn * scale * profl[c++];
+            lm = ofont.getLineMetrics(dc, 0, 1, g.getFontMetrics()
+                    .getFontRenderContext());
+            Font font = ofont.deriveFont(AffineTransform.getScaleInstance(
+                    wdth, scl / lm.getAscent()));
+            g.setFont(font);
+            lm = g.getFontMetrics().getLineMetrics(dc, 0, 1, g);
+
+            // Debug - render boxes around characters
+            // g.setColor(Color.red);
+            // g.drawRect(x*av.charWidth, (int)ht, av.charWidth,
+            // (int)(scl));
+            // g.setColor(profcolour.findColour(dc[0]).darker());
+
+            /*
+             * Set character colour as per alignment colour scheme; use the
+             * codon translation if a cDNA profile
+             */
+            Color colour = null;
+            if (isCdnaProfile)
+            {
+              final String codonTranslation = ResidueProperties
+                      .codonTranslate(new String(dc));
+              colour = profcolour.findColour(codonTranslation.charAt(0),
+                      column, null);
+            }
+            else
             {
             {
-              scl = htn * scale * profl[c++];
-              lm = ofont.getLineMetrics(dc, 0, 1, g.getFontMetrics()
-                      .getFontRenderContext());
-              g.setFont(ofont.deriveFont(AffineTransform.getScaleInstance(
-                      wdth, scl / lm.getAscent())));
-              lm = g.getFontMetrics().getLineMetrics(dc, 0, 1, g);
-
-              // Debug - render boxes around characters
-              // g.setColor(Color.red);
-              // g.drawRect(x*av.charWidth, (int)ht, av.charWidth,
-              // (int)(scl));
-              // g.setColor(profcolour.findColour(dc[0]).darker());
-              g.setColor(profcolour.findColour(dc[0], column, null));
-
-              hght = (ht + (scl - lm.getDescent() - lm.getBaselineOffsets()[lm
-                      .getBaselineIndex()]));
-
-              g.drawChars(dc, 0, dc.length, x * charWidth, (int) hght);
+              colour = profcolour.findColour(dc[0], column, null);
             }
             }
+            g.setColor(colour == Color.white ? Color.lightGray : colour);
+
+            hght = (ht + (scl - lm.getDescent() - lm.getBaselineOffsets()[lm
+                    .getBaselineIndex()]));
+
+            g.drawChars(dc, 0, dc.length, x * charWidth, (int) hght);
+            valuesProcessed++;
           }
           g.setFont(ofont);
         }
           }
           g.setFont(ofont);
         }
@@ -1342,8 +1446,7 @@ public class AnnotationRenderer
       g.setColor(_aa.threshold.colour);
       Graphics2D g2 = (Graphics2D) g;
       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
       g.setColor(_aa.threshold.colour);
       Graphics2D g2 = (Graphics2D) g;
       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
-              BasicStroke.JOIN_ROUND, 3f, new float[]
-              { 5f, 3f }, 0f));
+              BasicStroke.JOIN_ROUND, 3f, new float[] { 5f, 3f }, 0f));
 
       y2 = (int) (y - ((_aa.threshold.value - min) / range)
               * _aa.graphHeight);
 
       y2 = (int) (y - ((_aa.threshold.value - min) / range)
               * _aa.graphHeight);
@@ -1368,9 +1471,13 @@ public class AnnotationRenderer
       if (aa_annotations[j] != null)
       {
         if (aa_annotations[j].colour == null)
       if (aa_annotations[j] != null)
       {
         if (aa_annotations[j].colour == null)
+        {
           g.setColor(Color.black);
           g.setColor(Color.black);
+        }
         else
         else
+        {
           g.setColor(aa_annotations[j].colour);
           g.setColor(aa_annotations[j].colour);
+        }
 
         height = (int) ((aa_annotations[j].value / _aa.graphMax) * y);
         if (height > y)
 
         height = (int) ((aa_annotations[j].value / _aa.graphMax) * y);
         if (height > y)