(JAL-958) - normalised sequence logo for applet
[jalview.git] / src / jalview / appletgui / AnnotationPanel.java
index d4fcf97..b61f1cb 100755 (executable)
@@ -26,9 +26,11 @@ import java.awt.geom.AffineTransform;
 
 import jalview.analysis.AAFrequency;
 import jalview.datamodel.*;
+import jalview.renderer.AnnotationRenderer;
+import jalview.renderer.AwtRenderPanelI;
 import jalview.schemes.ColourSchemeI;
 
-public class AnnotationPanel extends Panel implements AdjustmentListener,
+public class AnnotationPanel extends Panel implements AwtRenderPanelI, AdjustmentListener,
         ActionListener, MouseListener, MouseMotionListener
 {
   AlignViewport av;
@@ -74,6 +76,8 @@ public class AnnotationPanel extends Panel implements AdjustmentListener,
 
   boolean MAC = false;
 
+  public final AnnotationRenderer renderer;
+
   public AnnotationPanel(AlignmentPanel ap)
   {
     MAC = new jalview.util.Platform().isAMac();
@@ -88,11 +92,13 @@ public class AnnotationPanel extends Panel implements AdjustmentListener,
     addMouseListener(this);
 
     // ap.annotationScroller.getVAdjustable().addAdjustmentListener( this );
+    renderer = new AnnotationRenderer();
   }
 
   public AnnotationPanel(AlignViewport av)
   {
     this.av = av;
+    renderer = new AnnotationRenderer();
   }
 
   public void adjustmentValueChanged(AdjustmentEvent evt)
@@ -624,664 +630,32 @@ public class AnnotationPanel extends Panel implements AdjustmentListener,
 
       return;
     }
-
-    AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();
-    g.translate(0, -scrollOffset);
-    int x = 0;
-    int y = 0;
-    int column = 0;
-    char lastSS;
-    int lastSSX;
-    int iconOffset = av.charHeight / 2;
-    boolean validRes = false;
-    boolean validEnd = false;
-    boolean labelAllCols = false;
-    boolean centreColLabels, centreColLabelsDef = av
-            .getCentreColumnLabels();
-    boolean scaleColLabel = false;
-    boolean[] graphGroupDrawn = new boolean[aa.length];
-    int charOffset = 0; // offset for a label
-    float fmWidth, fmScaling = 1f; // scaling for a label to fit it into a
-                                   // column.
-    // \u03B2 \u03B1
-    for (int i = 0; i < aa.length; i++)
-    {
-      AlignmentAnnotation row = aa[i];
-
-      if (!row.visible)
-      {
-        continue;
-      }
-      centreColLabels = row.centreColLabels || centreColLabelsDef;
-      labelAllCols = row.showAllColLabels;
-      scaleColLabel = row.scaleColLabel;
-      lastSS = ' ';
-      lastSSX = 0;
-
-      if (row.graph > 0)
-      {
-        if (row.graphGroup > -1 && graphGroupDrawn[row.graphGroup])
-        {
-          continue;
-        }
-
-        // this is so that we draw the characters below the graph
-        y += row.height;
-
-        if (row.hasText)
-        {
-          iconOffset = av.charHeight - fm.getDescent();
-          y -= av.charHeight;
-        }
-      }
-      // TODO: else is the logic used in application, applet had no 'else'
-      else if (row.hasText)
-      {
-        iconOffset = av.charHeight - fm.getDescent();
-
-      }
-      else
-      {
-        iconOffset = 0;
-      }
-
-      x = 0;
-      while (x < endRes - startRes)
-      {
-        if (av.hasHiddenColumns)
-        {
-          column = av.getColumnSelection().adjustForHiddenColumns(
-                  startRes + x);
-          if (column > row.annotations.length - 1)
-          {
-            break;
-          }
-        }
-        else
-        {
-          column = startRes + x;
-        }
-
-        if ((row.annotations.length <= column)
-                || (row.annotations[column] == null))
-        {
-          validRes = false;
-        }
-        else
-        {
-          validRes = true;
-        }
-
-        if (activeRow == i)
-        {
-          g.setColor(Color.red);
-
-          if (av.getColumnSelection() != null)
-          {
-            for (int n = 0; n < av.getColumnSelection().size(); n++)
-            {
-              int v = av.getColumnSelection().columnAt(n);
-
-              if (v == column)
-              {
-                g.fillRect(x * av.charWidth, y, av.charWidth, av.charHeight);
-              }
-            }
-          }
-        }
-
-        if (av.validCharWidth
-                && validRes
-                && (row.annotations[column].displayCharacter != null && row.annotations[column].displayCharacter
-                        .length() > 0))
-        {
-
-          if (centreColLabels || scaleColLabel)
-          {
-            fmWidth = (float) fm.charsWidth(
-                    row.annotations[column].displayCharacter.toCharArray(),
-                    0, row.annotations[column].displayCharacter.length());
-
-            if (scaleColLabel)
-            {
-              // justify the label and scale to fit in column
-              if (fmWidth > av.charWidth)
-              {
-                // scale only if the current font isn't already small enough
-                fmScaling = av.charWidth;
-                fmScaling /= fmWidth;
-                // not 1.1 // g.setFont(new
-                // Font(ofont,AffineTransform.getScaleInstance(fmScaling,
-                // 1.0)));
-                // and update the label's width to reflect the scaling.
-                fmWidth = av.charWidth;
-              }
-            }
-          }
-          else
-          {
-            fmWidth = (float) fm
-                    .charWidth(row.annotations[column].displayCharacter
-                            .charAt(0));
-          }
-          charOffset = (int) ((av.charWidth - fmWidth) / 2f);
-
-          if (row.annotations[column].colour == null)
-            g.setColor(Color.black);
-          else
-            g.setColor(row.annotations[column].colour);
-
-          if (column == 0 || row.graph > 0)
-          {
-            g.drawString(row.annotations[column].displayCharacter,
-                    (x * av.charWidth) + charOffset, y + iconOffset + 3); // +
-                                                                          // 3?
-          }
-          else if (row.annotations[column - 1] == null
-                  || (labelAllCols
-                          || !row.annotations[column].displayCharacter
-                                  .equals(row.annotations[column - 1].displayCharacter) || (row.annotations[column].displayCharacter
-                          .length() < 2 && row.annotations[column].secondaryStructure == ' ')))
-          {
-            g.drawString(row.annotations[column].displayCharacter,
-                    (x * av.charWidth) + charOffset, y + iconOffset + 3); // +3?
-          }
-          g.setFont(ofont);
-        }
-
-        if (row.hasIcons)
-        {
-          if (!validRes
-                  || (row.annotations[column].secondaryStructure != lastSS))
-          {
-            switch (lastSS)
-            {
-            case 'H':
-              g.setColor(HELIX_COLOUR);
-              if (MAC)
-              {
-                // Off by 1 offset when drawing rects and ovals
-                // to offscreen image on the MAC
-                g.fillRoundRect(lastSSX, y + 4 + iconOffset,
-                        (x * av.charWidth) - lastSSX, 7, 8, 8);
-                break;
-              }
-
-              int sCol = (lastSSX / av.charWidth) + startRes;
-              int x1 = lastSSX;
-              int x2 = (x * av.charWidth);
-
-              if (sCol == 0
-                      || row.annotations[sCol - 1] == null
-                      || row.annotations[sCol - 1].secondaryStructure != 'H')
-              {
-                g.fillArc(lastSSX, y + 4 + iconOffset, av.charWidth, 8, 90,
-                        180);
-                x1 += av.charWidth / 2;
-              }
-
-              if (!validRes || row.annotations[column] == null
-                      || row.annotations[column].secondaryStructure != 'H')
-              {
-                g.fillArc((x * av.charWidth) - av.charWidth, y + 4
-                        + iconOffset, av.charWidth, 8, 270, 180);
-                x2 -= av.charWidth / 2;
-              }
-
-              g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
-              break;
-
-            case 'E':
-              g.setColor(SHEET_COLOUR);
-              g.fillRect(lastSSX, y + 4 + iconOffset, (x * av.charWidth)
-                      - lastSSX - 4, 7);
-              g.fillPolygon(new int[]
-              { (x * av.charWidth) - 4, (x * av.charWidth) - 4,
-                  (x * av.charWidth) }, new int[]
-              { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
-                      3);
-
-              break;
-
-            default:
-              g.setColor(Color.gray);
-              g.fillRect(lastSSX, y + 6 + iconOffset, (x * av.charWidth)
-                      - lastSSX, 2);
-
-              break;
-            }
-
-            if (validRes)
-            {
-              lastSS = row.annotations[column].secondaryStructure;
-            }
-            else
-            {
-              lastSS = ' ';
-            }
-
-            lastSSX = (x * av.charWidth);
-          }
-        }
-
-        column++;
-        x++;
-      }
-
-      if (column >= row.annotations.length)
-      {
-        column = row.annotations.length - 1;
-        validEnd = false;
-      }
-      else
-      {
-        validEnd = true;
-      }
-
-      // x ++;
-
-      if (row.hasIcons)
-      {
-        switch (lastSS)
-        {
-        case 'H':
-          g.setColor(HELIX_COLOUR);
-          if (MAC)
-          {
-            // Off by 1 offset when drawing rects and ovals
-            // to offscreen image on the MAC
-            g.fillRoundRect(lastSSX, y + 4 + iconOffset, (x * av.charWidth)
-                    - lastSSX, 7, 8, 8);
-            break;
-          }
-
-          int sCol = (lastSSX / av.charWidth) + startRes;
-          int x1 = lastSSX;
-          int x2 = (x * av.charWidth);
-
-          if (sCol == 0 || row.annotations[sCol - 1] == null
-                  || row.annotations[sCol - 1].secondaryStructure != 'H')
-          {
-            g.fillArc(lastSSX, y + 4 + iconOffset, av.charWidth, 8, 90, 180);
-            x1 += av.charWidth / 2;
-          }
-
-          if (row.annotations[column] == null
-                  || row.annotations[column].secondaryStructure != 'H')
-          {
-            g.fillArc((x * av.charWidth) - av.charWidth,
-                    y + 4 + iconOffset, av.charWidth, 8, 270, 180);
-            x2 -= av.charWidth / 2;
-          }
-
-          g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
-
-          break;
-
-        case 'E':
-          g.setColor(SHEET_COLOUR);
-
-          if (!validEnd || row.annotations[endRes] == null
-                  || row.annotations[endRes].secondaryStructure != 'E')
-          {
-            g.fillRect(lastSSX, y + 4 + iconOffset, (x * av.charWidth)
-                    - lastSSX - 4, 7);
-            g.fillPolygon(new int[]
-            { (x * av.charWidth) - 4, (x * av.charWidth) - 4,
-                (x * av.charWidth) }, new int[]
-            { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset }, 3);
-          }
-          else
-          {
-            g.fillRect(lastSSX, y + 4 + iconOffset, x * av.charWidth
-                    - lastSSX, 7);
-          }
-          break;
-
-        default:
-          g.setColor(Color.gray);
-          if (!av.wrapAlignment || endRes == av.endRes)
-          {
-            g.fillRect(lastSSX, y + 6 + iconOffset, (x * av.charWidth)
-                    - lastSSX, 2);
-          }
-
-          break;
-        }
-      }
-
-      if (row.graph > 0 && row.graphHeight > 0)
-      {
-        if (row.graph == AlignmentAnnotation.LINE_GRAPH)
-        {
-          if (row.graphGroup > -1 && !graphGroupDrawn[row.graphGroup])
-          {
-            float groupmax = -999999, groupmin = 9999999;
-            for (int gg = 0; gg < aa.length; gg++)
-            {
-              if (aa[gg].graphGroup != row.graphGroup)
-              {
-                continue;
-              }
-
-              if (aa[gg] != row)
-              {
-                aa[gg].visible = false;
-              }
-
-              if (aa[gg].graphMax > groupmax)
-              {
-                groupmax = aa[gg].graphMax;
-              }
-              if (aa[gg].graphMin < groupmin)
-              {
-                groupmin = aa[gg].graphMin;
-              }
-            }
-
-            for (int gg = 0; gg < aa.length; gg++)
-            {
-              if (aa[gg].graphGroup == row.graphGroup)
-              {
-                drawLineGraph(g, aa[gg], startRes, endRes, y, groupmin,
-                        groupmax, row.graphHeight);
-              }
-            }
-
-            graphGroupDrawn[row.graphGroup] = true;
-          }
-          else
-          {
-            drawLineGraph(g, row, startRes, endRes, y, row.graphMin,
-                    row.graphMax, row.graphHeight);
-          }
-        }
-        else if (row.graph == AlignmentAnnotation.BAR_GRAPH)
-        {
-          drawBarGraph(g, row, startRes, endRes, row.graphMin,
-                  row.graphMax, y);
-        }
-      }
-
-      if (row.graph > 0 && row.hasText)
-      {
-        y += av.charHeight;
-      }
-
-      if (row.graph == 0)
-      {
-        y += aa[i].height;
-      }
-    }
-    g.translate(0, +scrollOffset);
-  }
-
-  public void drawLineGraph(Graphics g, AlignmentAnnotation aa, int sRes,
-          int eRes, int y, float min, float max, int graphHeight)
-  {
-    if (sRes > aa.annotations.length)
-    {
-      return;
-    }
-
-    int x = 0;
-
-    // Adjustment for fastpaint to left
-    if (eRes < av.endRes)
-    {
-      eRes++;
-    }
-
-    eRes = Math.min(eRes, aa.annotations.length);
-
-    int y1 = y, y2 = y;
-    float range = max - min;
-
-    // //Draw origin
-    if (min < 0)
-    {
-      y2 = y - (int) ((0 - min / range) * graphHeight);
-    }
-
-    g.setColor(Color.gray);
-    g.drawLine(x - av.charWidth, y2, (eRes - sRes) * av.charWidth, y2);
-
-    eRes = Math.min(eRes, aa.annotations.length);
-
-    int column;
-    int aaMax = aa.annotations.length - 1;
-
-    while (x < eRes - sRes)
-    {
-      column = sRes + x;
-      if (av.hasHiddenColumns)
-      {
-        column = av.getColumnSelection().adjustForHiddenColumns(column);
-      }
-
-      if (column > aaMax)
-      {
-        break;
-      }
-
-      if (aa.annotations[column] == null) // || coaa.annotations[column - 1] ==
-      // null)
-      {
-        x++;
-        continue;
-      }
-
-      if (aa.annotations[column].colour == null)
-        g.setColor(Color.black);
-      else
-        g.setColor(aa.annotations[column].colour);
-      if (column == 0 || aa.annotations[column - 1] == null)
-      {
-        y1 = y
-                - (int) (((aa.annotations[column].value - min) / range) * graphHeight);
-      }
-      else
-      {
-        y1 = y
-                - (int) (((aa.annotations[column - 1].value - min) / range) * graphHeight);
-      }
-      y2 = y
-              - (int) (((aa.annotations[column].value - min) / range) * graphHeight);
-
-      g.drawLine(x * av.charWidth - av.charWidth / 2, y1, x * av.charWidth
-              + av.charWidth / 2, y2);
-      x++;
-    }
-
-    if (aa.threshold != null)
-    {
-      g.setColor(aa.threshold.colour);
-
-      y2 = (int) (y - ((aa.threshold.value - min) / range) * graphHeight);
-      g.drawLine(0, y2, (eRes - sRes) * av.charWidth, y2);
-    }
+    renderer.drawComponent(this, av, g, activeRow, startRes, endRes);
   }
+  
+  int scrollOffset = 0;
 
-  public void drawBarGraph(Graphics g, AlignmentAnnotation aa, int sRes,
-          int eRes, float min, float max, int y)
+  public void setScrollOffset(int value)
   {
-    ColourSchemeI profcolour = av.getGlobalColourScheme();
-    if (profcolour == null)
-    {
-      profcolour = new jalview.schemes.ZappoColourScheme();
-    }
-    if (sRes > aa.annotations.length)
-    {
-      return;
-    }
-    Font ofont = g.getFont();
-    eRes = Math.min(eRes, aa.annotations.length);
-
-    int x = 0, y1 = y, y2 = y;
-
-    float range = max - min;
-
-    if (min < 0)
-    {
-      y2 = y - (int) ((0 - min / (range)) * aa.graphHeight);
-    }
-
-    g.setColor(Color.gray);
-
-    g.drawLine(x, y2, (eRes - sRes) * av.charWidth, y2);
-
-    int column;
-    int aaMax = aa.annotations.length - 1;
-    boolean renderHistogram = true, renderProfile = false;
-    if (aa.autoCalculated && aa.label.startsWith("Consensus"))
-    { // TODO: generalise this to have render styles for consensus/profile data
-      if (aa.groupRef != null)
-      {
-        renderHistogram = aa.groupRef.isShowConsensusHistogram();
-        renderProfile = aa.groupRef.isShowSequenceLogo();
-      }
-      else
-      {
-        renderHistogram = av.isShowConsensusHistogram();
-        renderProfile = av.isShowSequenceLogo();
-      }
-    }
-
-    while (x < eRes - sRes)
-    {
-      column = sRes + x;
-      if (av.hasHiddenColumns)
-      {
-        column = av.getColumnSelection().adjustForHiddenColumns(column);
-      }
-
-      if (column > aaMax)
-      {
-        break;
-      }
-
-      if (aa.annotations[column] == null)
-      {
-        x++;
-        continue;
-      }
-
-      if (aa.annotations[column].colour == null)
-        g.setColor(Color.black);
-      else
-        g.setColor(aa.annotations[column].colour);
-
-      y1 = y
-              - (int) (((aa.annotations[column].value - min) / (range)) * aa.graphHeight);
-
-      if (renderHistogram)
-      {
-        if (y1 - y2 > 0)
-        {
-          g.fillRect(x * av.charWidth, y2, av.charWidth, y1 - y2);
-        }
-        else
-        {
-          g.fillRect(x * av.charWidth, y1, av.charWidth, y2 - y1);
-        }
-      }
-      // draw profile if available
-      if (aa.annotations[column].value != 0 && renderProfile)
-      {
-        int profl[] = getProfileFor(aa, column);
-        int ht = y1, htn = y2 - y1;// aa.graphHeight;
-        float wdth;
-        double ht2 = 0;
-        char[] dc = new char[1];
-        LineMetrics lm;
-        for (int c = 1; profl != null && c < profl[0];)
-        {
-          dc[0] = (char) profl[c++];
-          wdth = av.charWidth;
-          wdth /= (float) fm.charsWidth(dc, 0, 1);
-
-          if (c > 2)
-          {
-            ht += (int) ht2;
-          }
-          { // not java 1.1 compatible: Bug # 0060064
-            g.setFont(ofont.deriveFont(AffineTransform.getScaleInstance(
-                    wdth, (ht2 = (htn * ((double) profl[c++]) / 100.0))
-                            / av.charHeight)));
-            lm = g.getFontMetrics().getLineMetrics(dc, 0, 1, g);
-            g.setColor(profcolour.findColour(dc[0]));
-            g.drawChars(dc, 0, 1, x * av.charWidth,
-                    (int) (ht + lm.getHeight()));
-          }
-        }
-        g.setFont(ofont);
-      }
-
-      x++;
-
-    }
-    if (aa.threshold != null)
-    {
-      g.setColor(aa.threshold.colour);
-      y2 = (int) (y - ((aa.threshold.value - min) / range) * aa.graphHeight);
-      g.drawLine(0, y2, (eRes - sRes) * av.charWidth, y2);
-    }
+    scrollOffset = value;
+    repaint();
   }
 
-  private int[] getProfileFor(AlignmentAnnotation aa, int column)
+  @Override
+  public FontMetrics getFontMetrics()
   {
-    // if (aa.autoCalculated && aa.label.startsWith("Consensus")) {
-    if (aa.groupRef != null && aa.groupRef.consensusData != null)
-    {
-      // && aa.groupRef.isShowSequenceLogo()) {
-      return AAFrequency.extractProfile(aa.groupRef.consensusData[column],
-              aa.groupRef.getIgnoreGapsConsensus());
-    }
-    // TODO extend annotation row to enable dynamic and static profile data to
-    // be stored
-    if (aa.groupRef == null && aa.sequenceRef == null)
-    // && av.isShowSequenceLogo())
-    {
-      return AAFrequency.extractProfile(av.hconsensus[column],
-              av.getIgnoreGapsConsensus());
-    }
-    // }
-    return null;
+    return fm;
   }
 
-  // used by overview window
-  public void drawGraph(Graphics g, AlignmentAnnotation aa, int width,
-          int y, int sRes, int eRes)
+  @Override
+  public Image getFadedImage()
   {
-    eRes = Math.min(eRes, aa.annotations.length);
-    g.setColor(Color.white);
-    g.fillRect(0, 0, width, y);
-    g.setColor(new Color(0, 0, 180));
-
-    int x = 0, height;
-
-    for (int j = sRes; j < eRes; j++)
-    {
-      if (aa.annotations[j].colour == null)
-        g.setColor(Color.black);
-      else
-        g.setColor(aa.annotations[j].colour);
-
-      height = (int) ((aa.annotations[j].value / aa.graphMax) * GRAPH_HEIGHT);
-      if (height > y)
-      {
-        height = y;
-      }
-      g.fillRect(x, y - height, av.charWidth, height);
-      x += av.charWidth;
-    }
+    return image;
   }
 
-  int scrollOffset = 0;
-
-  public void setScrollOffset(int value)
+  @Override
+  public int getFadedImageWidth()
   {
-    scrollOffset = value;
-    repaint();
+    return imgWidth;
   }
 }