Merge remote-tracking branch 'origin/feature/2588' into feature/JAL-2527

Conflicts:
	src/jalview/renderer/OverviewRenderer.java

diff --cc src/jalview/renderer/OverviewRenderer.java
index 2f8f5fe,2e2bc37..56dba82
--- 1/src/jalview/renderer/OverviewRenderer.java
--- 2/src/jalview/renderer/OverviewRenderer.java
+++ b/src/jalview/renderer/OverviewRenderer.java
@@@ -37,13 -37,8 +39,11 @@@ import java.awt.image.BufferedImage
  
  public class OverviewRenderer
  {
 +  // transparency of hidden cols/seqs overlay
 +  private final float TRANSPARENCY = 0.5f;
 +
    private FeatureColourFinder finder;
  
-   private jalview.api.SequenceRenderer sr;
- 
    // image to render on
    private BufferedImage miniMe;
  
@@@ -90,10 -96,13 +101,13 @@@
        {
          break;
        }
 -
 +    
        // get details of this alignment row
 -      boolean hidden = rows.isHidden(alignmentRow);
        SequenceI seq = rows.getSequence(alignmentRow);
-     
++
+       // rate limiting step when rendering overview for lots of groups
+       SequenceGroup[] allGroups = al.findAllGroups(seq);
+ 
        // calculate where this row extends to in pixels
        int endRow = Math.min(Math.round((seqIndex + 1) * pixelsPerSeq) - 1,
                miniMe.getHeight() - 1);
@@@ -116,10 -125,11 +130,9 @@@
          // panel
          if (pixelCol <= endCol)
          {
-           rgbcolor = getColumnColourFromSequence(seq,
-                   alignmentCol,
-                   finder);
 -          // determine the colour based on the sequence and column position
+           rgbcolor = getColumnColourFromSequence(allGroups, seq,
 -                  hidden || cols.isHidden(alignmentCol), alignmentCol,
 -                  finder);
 -
++                  alignmentCol, finder);
 +    
            // fill in the appropriate number of pixels
            for (int row = pixelRow; row <= endRow; ++row)
            {
@@@ -141,138 -149,28 +154,141 @@@
      return miniMe;
    }
  
 -  /*
 +  /**
     * Find the colour of a sequence at a specified column position
 +   * 
 +   * @param seq
 +   *          sequence to get colour for
 +   * @param lastcol
 +   *          column position to get colour for
 +   * @param fcfinder
 +   *          FeatureColourFinder to use
 +   * @return colour of sequence at this position, as RGB
     */
-   private int getColumnColourFromSequence(jalview.datamodel.SequenceI seq,
+   private int getColumnColourFromSequence(SequenceGroup[] allGroups,
+           jalview.datamodel.SequenceI seq,
 -          boolean isHidden, int lastcol, FeatureColourFinder fcfinder)
 +          int lastcol, FeatureColourFinder fcfinder)
    {
      Color color = Color.white;
  
      if ((seq != null) && (seq.getLength() > lastcol))
      {
-       color = sr.getResidueColour(seq, lastcol, fcfinder);
+       color = resColFinder.getResidueColour(true, shader, allGroups, seq,
+               lastcol,
+               fcfinder);
      }
  
 -    if (isHidden)
 +    return color.getRGB();
 +  }
 +
 +  /**
 +   * Overlay the hidden regions on the overview image
 +   * 
 +   * @param rows
 +   *          collection of rows the overview is built over
 +   * @param cols
 +   *          collection of columns the overview is built over
 +   */
 +  private void overlayHiddenRegions(AlignmentRowsCollectionI rows,
 +          AlignmentColsCollectionI cols)
 +  {
 +    if (cols.hasHidden() || rows.hasHidden())
      {
 -      color = color.darker().darker();
 +      BufferedImage mask = buildHiddenImage(rows, cols, miniMe.getWidth(),
 +              miniMe.getHeight());
 +
 +      Graphics2D g = (Graphics2D) miniMe.getGraphics();
 +      g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
 +              TRANSPARENCY));
 +      g.drawImage(mask, 0, 0, miniMe.getWidth(), miniMe.getHeight(), null);
      }
 +  }
  
 -    return color.getRGB();
 +  /**
 +   * Build a masking image of hidden columns and rows to be applied on top of
 +   * the main overview image.
 +   * 
 +   * @param rows
 +   *          collection of rows the overview is built over
 +   * @param cols
 +   *          collection of columns the overview is built over
 +   * @param width
 +   *          width of overview in pixels
 +   * @param height
 +   *          height of overview in pixels
 +   * @return BufferedImage containing mask of hidden regions
 +   */
 +  private BufferedImage buildHiddenImage(AlignmentRowsCollectionI rows,
 +          AlignmentColsCollectionI cols, int width, int height)
 +  {
 +    // new masking image
 +    BufferedImage hiddenImage = new BufferedImage(width, height,
 +            BufferedImage.TYPE_INT_ARGB);
 +
 +    int colIndex = 0;
 +    int pixelCol = 0;
 +
 +    Color hidden = Color.DARK_GRAY.darker();
 +
 +    Graphics2D g2d = (Graphics2D) hiddenImage.getGraphics();
 +
 +    // set background to transparent
 +    g2d.setComposite(AlphaComposite.Clear);
 +    g2d.fillRect(0, 0, width, height);
 +
 +    // set next colour to opaque
 +    g2d.setComposite(AlphaComposite.Src);
 +
 +    for (int alignmentCol : cols)
 +    {
 +      if (redraw)
 +      {
 +        break;
 +      }
 +
 +      // calculate where this column extends to in pixels
 +      int endCol = Math.min(Math.round((colIndex + 1) * pixelsPerCol) - 1,
 +              hiddenImage.getWidth() - 1);
 +
 +      if (pixelCol <= endCol)
 +      {
 +        // determine the colour based on the sequence and column position
 +        if (cols.isHidden(alignmentCol))
 +        {
 +          g2d.setColor(hidden);
 +          g2d.fillRect(pixelCol, 0, endCol - pixelCol + 1, height);
 +        }
 +
 +        pixelCol = endCol + 1;
 +      }
 +      colIndex++;
 +
 +    }
 +
 +    int seqIndex = 0;
 +    int pixelRow = 0;
 +    for (int alignmentRow : rows)
 +    {
 +      if (redraw)
 +      {
 +        break;
 +      }
 +
 +      // calculate where this row extends to in pixels
 +      int endRow = Math.min(Math.round((seqIndex + 1) * pixelsPerSeq) - 1,
 +              miniMe.getHeight() - 1);
 +
 +      // get details of this alignment row
 +      if (rows.isHidden(alignmentRow))
 +      {
 +        g2d.setColor(hidden);
 +        g2d.fillRect(0, pixelRow, width, endRow - pixelRow + 1);
 +      }
 +      pixelRow = endRow + 1;
 +      seqIndex++;
 +    }
 +
 +    return hiddenImage;
    }
  
    /**