X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqCanvas.java;h=318d74d7a2900f329ec73351ae07c7cdebbf1a70;hb=60ee9fb76ea07566ece5c3455a1abedfff467354;hp=c46e75236fb5510b8b1df49f55f3b7acc0eef806;hpb=607a4aecda2f99866bb1acf7d364a6dde4e215bd;p=jalview.git

diff --git a/src/jalview/gui/SeqCanvas.java b/src/jalview/gui/SeqCanvas.java
index c46e752..318d74d 100755
--- a/src/jalview/gui/SeqCanvas.java
+++ b/src/jalview/gui/SeqCanvas.java
@@ -30,6 +30,7 @@ import jalview.renderer.ScaleRenderer.ScaleMark;
 import jalview.viewmodel.ViewportListenerI;
 import jalview.viewmodel.ViewportRanges;
 
+import java.awt.AlphaComposite;
 import java.awt.BasicStroke;
 import java.awt.BorderLayout;
 import java.awt.Color;
@@ -60,10 +61,6 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   Graphics2D gg;
 
-  int imgWidth;
-
-  int imgHeight;
-
   AlignViewport av;
 
   boolean fastPaint = false;
@@ -286,8 +283,6 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     fastpainting = true;
     fastPaint = true;
     updateViewport();
-    gg.copyArea(horizontal * charWidth, vertical * charHeight, imgWidth,
-            imgHeight, -horizontal * charWidth, -vertical * charHeight);
 
     ViewportRanges ranges = av.getRanges();
     int sr = ranges.getStartRes();
@@ -297,6 +292,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     int transX = 0;
     int transY = 0;
 
+    gg.copyArea(horizontal * charWidth, vertical * charHeight,
+            img.getWidth(), img.getHeight(), -horizontal * charWidth,
+            -vertical * charHeight);
+
     if (horizontal > 0) // scrollbar pulled right, image to the left
     {
       transX = (er - sr - horizontal) * charWidth;
@@ -316,7 +315,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       }
       else
       {
-        transY = imgHeight - ((vertical + 1) * charHeight);
+        transY = img.getHeight() - ((vertical + 1) * charHeight);
       }
     }
     else if (vertical < 0)
@@ -350,62 +349,61 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   @Override
   public void paintComponent(Graphics g)
   {
-    updateViewport();
-    BufferedImage lcimg = img; // take reference since other threads may null
-    // img and call later.
     super.paintComponent(g);
 
-    if (lcimg != null
-            && (fastPaint
-                    || (getVisibleRect().width != g.getClipBounds().width) || (getVisibleRect().height != g
-                    .getClipBounds().height)))
+    updateViewport();
+
+    // img is a cached version of the last view we drew
+    // selectImage will hold any selection we have
+    // lcimg is a local *copy* of img which we'll draw selectImage on top of
+
+    ViewportRanges ranges = av.getRanges();
+    BufferedImage selectImage = drawSelectionGroup(
+            av.getRanges().getStartRes(), av.getRanges().getEndRes(),
+            ranges.getStartSeq(), ranges.getEndSeq());
+
+    if (fastPaint || (getVisibleRect().width != g.getClipBounds().width)
+            || (getVisibleRect().height != g.getClipBounds().height))
     {
+      BufferedImage lcimg = buildLocalImage(selectImage);
       g.drawImage(lcimg, 0, 0, this);
+
       fastPaint = false;
       return;
     }
 
-    // this draws the whole of the alignment
-    imgWidth = getWidth();
-    imgHeight = getHeight();
+    int width = getWidth();
+    int height = getHeight();
 
-    imgWidth -= (imgWidth % charWidth);
-    imgHeight -= (imgHeight % charHeight);
+    width -= (width % charWidth);
+    height -= (height % charHeight);
 
-    if ((imgWidth < 1) || (imgHeight < 1))
+    if ((width < 1) || (height < 1))
     {
       return;
     }
 
-    if (lcimg == null || imgWidth != lcimg.getWidth()
-            || imgHeight != lcimg.getHeight())
+    if (img == null || width != img.getWidth() || height != img.getHeight())
     {
-      try
-      {
-        lcimg = img = new BufferedImage(imgWidth, imgHeight,
-                BufferedImage.TYPE_INT_RGB);
-        gg = (Graphics2D) img.getGraphics();
-        gg.setFont(av.getFont());
-      } catch (OutOfMemoryError er)
-      {
-        System.gc();
-        System.err.println("SeqCanvas OutOfMemory Redraw Error.\n" + er);
-        new OOMWarning("Creating alignment image for display", er);
-
-        return;
-      }
+      img = setupImage();
+      gg = (Graphics2D) img.getGraphics();
+      gg.setFont(av.getFont());
+    }
+    if (img == null)
+    {
+      return;
     }
 
+    
     if (av.antiAlias)
     {
       gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
               RenderingHints.VALUE_ANTIALIAS_ON);
     }
-
+    
     gg.setColor(Color.white);
-    gg.fillRect(0, 0, imgWidth, imgHeight);
-
-    ViewportRanges ranges = av.getRanges();
+    gg.fillRect(0, 0, img.getWidth(), img.getHeight());
+    
     if (av.getWrapAlignment())
     {
       drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
@@ -416,8 +414,70 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
               ranges.getStartSeq(), ranges.getEndSeq(), 0);
     }
 
+    BufferedImage lcimg = buildLocalImage(selectImage);
     g.drawImage(lcimg, 0, 0, this);
+  }
+
+  /*
+   * Make a local image by combining the cached image img
+   * with any selection
+   */
+  private BufferedImage buildLocalImage(BufferedImage selectImage)
+  {
+    // clone the cached image
+    BufferedImage lcimg = new BufferedImage(img.getWidth(), img.getHeight(),
+            img.getType());
+    Graphics2D g2d = lcimg.createGraphics();
+    g2d.drawImage(img, 0, 0, null);
+
+    // overlay selection group on lcimg
+    if (selectImage != null)
+    {
+      g2d.setComposite(
+              AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
+      g2d.drawImage(selectImage, 0, 0, this);
+    }
+    g2d.dispose();
+
+    return lcimg;
+  }
+
+  private void paintSeqGroup()
+  {
+    fastPaint = true;
+    repaint();
+  }
+
+  private BufferedImage setupImage()
+  {
+    BufferedImage lcimg = null;
+
+    int width = getWidth();
+    int height = getHeight();
 
+    width -= (width % charWidth);
+    height -= (height % charHeight);
+
+    if ((width < 1) || (height < 1))
+    {
+      return null;
+    }
+
+    try
+    {
+      lcimg = new BufferedImage(width, height,
+              BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
+    } catch (OutOfMemoryError er)
+    {
+      System.gc();
+      System.err.println(
+              "Selection Group image OutOfMemory Redraw Error.\n" + er);
+      new OOMWarning("Creating alignment image for display", er);
+
+      return null;
+    }
+
+    return lcimg;
   }
 
   /**
@@ -494,6 +554,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
     FontMetrics fm = getFontMetrics(av.getFont());
 
+    LABEL_EAST = 0;
+    LABEL_WEST = 0;
+
     if (av.getScaleRightWrapped())
     {
       LABEL_EAST = fm.stringWidth(getMask());
@@ -515,16 +578,16 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
     av.setWrappedWidth(cWidth);
 
-    av.getRanges().setEndRes(av.getRanges().getStartRes() + cWidth - 1);
+    av.getRanges().setViewportStartAndWidth(startRes, cWidth);
 
     int endx;
     int ypos = hgap;
-    int maxwidth = av.getAlignment().getWidth() - 1;
+    int maxwidth = av.getAlignment().getWidth();
 
     if (av.hasHiddenColumns())
     {
       maxwidth = av.getAlignment().getHiddenColumns()
-              .findColumnPosition(maxwidth) - 1;
+              .findColumnPosition(maxwidth);
     }
 
     while ((ypos <= canvasHeight) && (startRes < maxwidth))
@@ -668,7 +731,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       int blockEnd = endRes;
 
       for (int[] region : av.getAlignment().getHiddenColumns()
-              .getHiddenColumnsCopyAsList())
+              .getHiddenColumnsCopy())
       {
         int hideStart = region[0];
         int hideEnd = region[1];
@@ -790,7 +853,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     // ///////////////////////////////////
     // Now outline any areas if necessary
     // ///////////////////////////////////
-    SequenceGroup group = av.getSelectionGroup();
+
+    SequenceGroup group = null;
 
     int sx = -1;
     int sy = -1;
@@ -798,7 +862,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     int groupIndex = -1;
     int visWidth = (endRes - startRes + 1) * charWidth;
 
-    if ((group == null) && (av.getAlignment().getGroups().size() > 0))
+    if (av.getAlignment().getGroups().size() > 0)
     {
       group = av.getAlignment().getGroups().get(0);
       groupIndex = 0;
@@ -816,8 +880,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
         for (i = startSeq; i <= endSeq; i++)
         {
+          // position of start residue of group relative to startRes, in pixels
           sx = (group.getStartRes() - startRes) * charWidth;
           sy = offset + ((i - startSeq) * charHeight);
+          // width of group in pixels
           ex = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth) - 1;
 
           if (sx + ex < 0 || sx > visWidth)
@@ -848,29 +914,23 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
               oldY = sy;
               inGroup = true;
 
-              if (group == av.getSelectionGroup())
-              {
-                g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
-                        BasicStroke.JOIN_ROUND, 3f, new float[] { 5f, 3f },
-                        0f));
-                g.setColor(Color.RED);
-              }
-              else
-              {
-                g.setStroke(new BasicStroke());
-                g.setColor(group.getOutlineColour());
-              }
+              g.setStroke(new BasicStroke());
+              g.setColor(group.getOutlineColour());
             }
           }
           else
           {
             if (inGroup)
             {
+              // if start position is visible, draw vertical line to left of
+              // group
               if (sx >= 0 && sx < visWidth)
               {
                 g.drawLine(sx, oldY, sx, sy);
               }
 
+              // if end position is visible, draw vertical line to right of
+              // group
               if (sx + ex < visWidth)
               {
                 g.drawLine(sx + ex, oldY, sx + ex, sy);
@@ -892,12 +952,14 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
                 ex = (endRes - startRes + 1) * charWidth;
               }
 
+              // draw horizontal line at top of group
               if (top != -1)
               {
                 g.drawLine(sx, top, sx + ex, top);
                 top = -1;
               }
 
+              // draw horizontal line at bottom of group
               if (bottom != -1)
               {
                 g.drawLine(sx, bottom, sx + ex, bottom);
@@ -969,6 +1031,247 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   }
 
+
+  /*
+   * Draw the selection group as a separate image and overlay
+   */
+  private BufferedImage drawSelectionGroup(int startRes, int endRes,
+          int startSeq, int endSeq)
+  {
+    // get a new image of the correct size
+    BufferedImage selectionImage = setupImage();
+
+    if (selectionImage == null)
+    {
+      return null;
+    }
+
+    SequenceGroup group = av.getSelectionGroup();
+    if (group == null)
+    {
+      // nothing to draw
+      return null;
+    }
+    
+    // set up drawing colour
+    Graphics2D g = (Graphics2D) selectionImage.getGraphics();
+    g.translate(LABEL_WEST, 0);
+    // set background to transparent
+    g.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
+    g.fillRect(0, 0, selectionImage.getWidth(), selectionImage.getHeight());
+
+    g.setComposite(AlphaComposite.Src);
+    g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
+            BasicStroke.JOIN_ROUND, 3f, new float[]
+    { 5f, 3f }, 0f));
+    g.setColor(Color.RED);
+
+    if (!av.hasHiddenColumns())
+    {
+      drawSelectionGroupPart(g, group, startRes, endRes, startSeq, endSeq);
+    }
+    else
+    {
+      // package into blocks of visible columns
+      // Graphics2D g = (Graphics2D) selectionImage.getGraphics();
+      // Graphics g1 = selectionImage.getGraphics();
+
+      int screenY = 0;
+      int blockStart = startRes;
+      int blockEnd = endRes;
+
+      for (int[] region : av.getAlignment().getHiddenColumns()
+              .getHiddenColumnsCopy())
+      {
+        int hideStart = region[0];
+        int hideEnd = region[1];
+
+        if (hideStart <= blockStart)
+        {
+          blockStart += (hideEnd - hideStart) + 1;
+          continue;
+        }
+
+        blockEnd = hideStart - 1;
+
+        g.translate(screenY * charWidth, 0);
+
+        drawSelectionGroupPart(g, group,
+                blockStart, blockEnd, startSeq, endSeq);
+
+        g.translate(-screenY * charWidth, 0);
+        screenY += blockEnd - blockStart + 1;
+        blockStart = hideEnd + 1;
+
+        if (screenY > (endRes - startRes))
+        {
+          // already rendered last block
+          break;
+        }
+      }
+
+      if (screenY <= (endRes - startRes))
+      {
+        // remaining visible region to render
+        blockEnd = blockStart + (endRes - startRes) - screenY;
+        g.translate(screenY * charWidth, 0);
+        drawSelectionGroupPart(g, group,
+                blockStart, blockEnd, startSeq, endSeq);
+
+        g.translate(-screenY * charWidth, 0);
+      }
+    }
+    g.translate(-LABEL_WEST, 0);
+    return selectionImage;
+  }
+
+  /*
+   * Draw the selection group as a separate image and overlay
+   */
+  private void drawSelectionGroupPart(Graphics2D g, SequenceGroup group,
+          int startRes, int endRes, int startSeq, int endSeq)
+  {
+    // set up values in case the alignment is wrapped
+    int verticalOffset = 0;
+    int horizontalOffset = 0;
+    if (av.getWrapAlignment())
+    {
+      int hgap = charHeight;
+      if (av.getScaleAboveWrapped())
+      {
+        hgap += charHeight;
+      }
+      
+      // get the start res of the group and work out the offsets for it in the wrapped alignment
+      int groupstart = group.getStartRes();
+      int cWidth = (getWidth() - LABEL_EAST - LABEL_WEST) / charWidth;
+      
+      // group is in which slice of alignment? res position / width in residues
+      int slice = groupstart / cWidth;
+      // vertical offset is increased by slice number * number of sequences * height of each sequence
+      verticalOffset = slice * (av.getAlignment().getHeight() * charHeight
+              + getAnnotationHeight() + hgap) + hgap;
+
+      // horizontal offset is number of residues to subtract from group residue
+      // position
+      horizontalOffset = (slice * cWidth);
+    }
+
+    int visWidth = av.getRanges().getViewportWidth() * charWidth;
+
+    // set x start and end positions of group
+    int startx = (group.getStartRes() - startRes - horizontalOffset)
+            * charWidth;
+    int endx = (group.getEndRes() - startRes + 1 - horizontalOffset)
+            * charWidth;
+
+    int oldY = -1;
+    int i = 0;
+    boolean inGroup = false;
+    int top = -1;
+    int bottom = -1;
+
+    // get sequences to determine y positions of group
+    for (i = startSeq; i <= endSeq; ++i)
+    {
+      int sy = verticalOffset + (i - startSeq) * charHeight;
+
+      if (group.getSequences(null)
+              .contains(av.getAlignment().getSequenceAt(i)))
+      {
+        if ((bottom == -1) && !group.getSequences(null)
+                .contains(av.getAlignment().getSequenceAt(i + 1)))
+        {
+          bottom = sy + charHeight;
+        }
+
+        if (!inGroup)
+        {
+          if (((top == -1) && (i == 0)) || !group.getSequences(null)
+                  .contains(av.getAlignment().getSequenceAt(i - 1)))
+          {
+            top = sy;
+          }
+
+          oldY = sy;
+          inGroup = true;
+        }
+      }
+      else
+      {
+        if (inGroup)
+        {
+          // if start position is visible, draw vertical line to left of
+          // group
+          if (startx >= 0 && startx < visWidth * charWidth)
+          {
+            g.drawLine(startx, oldY, startx, sy);
+          }
+
+          // if end position is visible, draw vertical line to right of
+          // group
+          if (endx <= visWidth * charWidth)
+          {
+            g.drawLine(endx, oldY, endx, sy);
+          }
+
+          if (endx > visWidth * charWidth)
+          {
+            endx = visWidth * charWidth;
+          }
+
+          // draw horizontal line at top of group
+          if (top != -1)
+          {
+            g.drawLine(startx, top, endx, top);
+            top = -1;
+          }
+
+          // draw horizontal line at bottom of group
+          if (bottom != -1)
+          {
+            g.drawLine(startx, bottom, endx, bottom);
+            bottom = -1;
+          }
+
+          inGroup = false;
+        }
+      }
+    }
+    if (inGroup)
+    {
+      int sy = verticalOffset + (i - startSeq) * charHeight;
+      if (startx >= 0 && startx < visWidth)
+      {
+        g.drawLine(startx, oldY, startx, sy);
+      }
+
+      if (endx < visWidth)
+      {
+        g.drawLine(endx, oldY, endx, sy);
+      }
+
+      if (endx > visWidth)
+      {
+        endx = visWidth;
+      }
+
+      if (top != -1)
+      {
+        g.drawLine(startx, top, endx, top);
+        top = -1;
+      }
+
+      if (bottom != -1)
+      {
+        g.drawLine(startx, bottom - 1, endx, bottom - 1);
+        bottom = -1;
+      }
+
+      inGroup = false;
+    }
+  }
+
   /**
    * DOCUMENT ME!
    * 
@@ -987,28 +1290,52 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   @Override
   public void propertyChange(PropertyChangeEvent evt)
   {
-    if (!av.getWrapAlignment())
+    String eventName = evt.getPropertyName();
+
+    if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
+    {
+      paintSeqGroup();
+    }
+    else if (av.getWrapAlignment())
+    {
+      if (eventName.equals(ViewportRanges.STARTRES))
+      {
+        repaint();
+      }
+    }
+    else
     {
-      if (evt.getPropertyName().equals("startres")
-              || evt.getPropertyName().equals("endres"))
+      int scrollX = 0;
+      if (eventName.equals(ViewportRanges.STARTRES))
       {
         // Make sure we're not trying to draw a panel
         // larger than the visible window
         ViewportRanges vpRanges = av.getRanges();
-        int scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
-        if (scrollX > vpRanges.getEndRes() - vpRanges.getStartRes())
+        scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
+        int range = vpRanges.getEndRes() - vpRanges.getStartRes();
+        if (scrollX > range)
         {
-          scrollX = vpRanges.getEndRes() - vpRanges.getStartRes();
+          scrollX = range;
         }
-        else if (scrollX < vpRanges.getStartRes() - vpRanges.getEndRes())
+        else if (scrollX < -range)
         {
-          scrollX = vpRanges.getStartRes() - vpRanges.getEndRes();
+          scrollX = -range;
         }
+      }
+
+      // Both scrolling and resizing change viewport ranges: scrolling changes
+      // both start and end points, but resize only changes end values.
+      // Here we only want to fastpaint on a scroll, with resize using a normal
+      // paint, so scroll events are identified as changes to the horizontal or
+      // vertical start value.
+      if (eventName.equals(ViewportRanges.STARTRES))
+      {
+        // scroll - startres and endres both change
         fastPaint(scrollX, 0);
       }
-      else if (evt.getPropertyName().equals("startseq")
-              || evt.getPropertyName().equals("endseq"))
+      else if (eventName.equals(ViewportRanges.STARTSEQ))
       {
+        // scroll
         fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
       }
     }