X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqCanvas.java;h=9d11976ee34fb57bfe4d787408d4a48f0a2ef76c;hb=21fb81914f40016a2860c71948a4a2759c9e153c;hp=fdad32bd58d3f6d7a4fa76a656fa7f1dcc0f29d9;hpb=76b5df40b2ae218a21d54b30bf726684fe660971;p=jalview.git

diff --git a/src/jalview/gui/SeqCanvas.java b/src/jalview/gui/SeqCanvas.java
index fdad32b..9d11976 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;
@@ -277,7 +278,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    * @param vertical
    *          shift up or down in repaint
    */
-  public void fastPaint(int horizontal, int vertical, boolean isresize)
+  public void fastPaint(int horizontal, int vertical)
   {
     if (fastpainting || gg == null)
     {
@@ -295,68 +296,38 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     int transX = 0;
     int transY = 0;
 
-    if (isresize)
-    {
-      imgWidth = getWidth();
-      imgHeight = getHeight();
-
-      imgWidth -= (imgWidth % charWidth);
-      imgHeight -= (imgHeight % charHeight);
+    gg.copyArea(horizontal * charWidth, vertical * charHeight, imgWidth,
+            imgHeight, -horizontal * charWidth, -vertical * charHeight);
 
-      BufferedImage newimg = new BufferedImage(imgWidth, imgHeight,
-              BufferedImage.TYPE_INT_ARGB);
-
-      gg = (Graphics2D) newimg.getGraphics();
-      gg.setFont(av.getFont());
-      gg.drawImage(img, null, 0, 0);
-      img = newimg;
+    if (horizontal > 0) // scrollbar pulled right, image to the left
+    {
+      transX = (er - sr - horizontal) * charWidth;
+      sr = er - horizontal;
+    }
+    else if (horizontal < 0)
+    {
+      er = sr - horizontal;
+    }
+    else if (vertical > 0) // scroll down
+    {
+      ss = es - vertical;
 
-      if (horizontal != 0)
-      {
-        transX = (er - horizontal - sr) * charWidth;
-        sr = er - horizontal - sr;
+      if (ss < ranges.getStartSeq())
+      { // ie scrolling too fast, more than a page at a time
+        ss = ranges.getStartSeq();
       }
-      else if (vertical != 0)
+      else
       {
         transY = imgHeight - ((vertical + 1) * charHeight);
-        ss = es - vertical - ss;
       }
     }
-    else
+    else if (vertical < 0)
     {
-      gg.copyArea(horizontal * charWidth, vertical * charHeight, imgWidth,
-              imgHeight, -horizontal * charWidth, -vertical * charHeight);
+      es = ss - vertical;
 
-      if (horizontal > 0) // scrollbar pulled right, image to the left
-      {
-        transX = (er - sr - horizontal) * charWidth;
-        sr = er - horizontal;
-      }
-      else if (horizontal < 0)
+      if (es > ranges.getEndSeq())
       {
-        er = sr - horizontal;
-      }
-      else if (vertical > 0) // scroll down
-      {
-        ss = es - vertical;
-
-        if (ss < ranges.getStartSeq())
-        { // ie scrolling too fast, more than a page at a time
-          ss = ranges.getStartSeq();
-        }
-        else
-        {
-          transY = imgHeight - ((vertical + 1) * charHeight);
-        }
-      }
-      else if (vertical < 0)
-      {
-        es = ss - vertical;
-
-        if (es > ranges.getEndSeq())
-        {
-          es = ranges.getEndSeq();
-        }
+        es = ranges.getEndSeq();
       }
     }
 
@@ -382,20 +353,98 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   public void paintComponent(Graphics g)
   {
     updateViewport();
-    BufferedImage lcimg = img; // take reference since other threads may null
+
+    // 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
+
+    if (img == null)
+    {
+      setupImage();
+    }
+    if (img == null)
+    {
+      return;
+    }
+    BufferedImage lcimg = new BufferedImage(img.getWidth(), img.getHeight(),
+            img.getType());
+    Graphics2D g2d = lcimg.createGraphics();
+    g2d.drawImage(img, 0, 0, null);
+    g2d.dispose();
+
+
+    // BufferedImage lcimg = img; // take reference since other threads may null
     // img and call later.
     super.paintComponent(g);
 
+    BufferedImage selectImage = drawSelectionGroup();
+
     if (lcimg != null
             && (fastPaint
                     || (getVisibleRect().width != g.getClipBounds().width) || (getVisibleRect().height != g
                     .getClipBounds().height)))
     {
+      Graphics2D g2 = (Graphics2D) lcimg.getGraphics();
+
+      // overlay selection group on lcimg
+      if (selectImage != null)
+      {
+        g2.setComposite(
+                AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
+        g2.drawImage(selectImage, 0, 0, this);
+      }
       g.drawImage(lcimg, 0, 0, this);
+
       fastPaint = false;
       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();
+    if (av.getWrapAlignment())
+    {
+      drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
+    }
+    else
+    {
+      drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
+              ranges.getStartSeq(), ranges.getEndSeq(), 0);
+    }
+
+    lcimg = new BufferedImage(img.getWidth(), img.getHeight(),
+            img.getType());
+    g2d = lcimg.createGraphics();
+    g2d.drawImage(img, 0, 0, null);
+    g2d.dispose();
+
+    Graphics2D g2 = (Graphics2D) lcimg.getGraphics();
+
+    // overlay selection group on lcimg
+    if (selectImage != null)
+    {
+      g2.setComposite(
+              AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
+      g2.drawImage(selectImage, 0, 0, this);
+    }
+    g.drawImage(lcimg, 0, 0, this);
+  }
+
+  private void paintSeqGroup()
+  {
+    fastPaint = true;
+    repaint();
+  }
 
+  private void setupImage()
+  {
     // this draws the whole of the alignment
     imgWidth = getWidth();
     imgHeight = getHeight();
@@ -408,13 +457,11 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       return;
     }
 
-    if (lcimg == null || imgWidth != lcimg.getWidth()
-            || imgHeight != lcimg.getHeight())
-    {
+
       try
       {
-        lcimg = img = new BufferedImage(imgWidth, imgHeight,
-                BufferedImage.TYPE_INT_RGB);
+      img = new BufferedImage(imgWidth, imgHeight,
+                BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
         gg = (Graphics2D) img.getGraphics();
         gg.setFont(av.getFont());
       } catch (OutOfMemoryError er)
@@ -423,32 +470,41 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         System.err.println("SeqCanvas OutOfMemory Redraw Error.\n" + er);
         new OOMWarning("Creating alignment image for display", er);
 
-        return;
+      return;
       }
-    }
 
-    if (av.antiAlias)
-    {
-      gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-              RenderingHints.VALUE_ANTIALIAS_ON);
-    }
+  }
 
-    gg.setColor(Color.white);
-    gg.fillRect(0, 0, imgWidth, imgHeight);
+  private BufferedImage setupSelectionImage()
+  {
+    BufferedImage lcimg = null;
 
-    ViewportRanges ranges = av.getRanges();
-    if (av.getWrapAlignment())
+    int width = getWidth();
+    int height = getHeight();
+
+    width -= (width % charWidth);
+    height -= (height % charHeight);
+
+    if ((width < 1) || (height < 1))
     {
-      drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
+      return null;
     }
-    else
+
+    try
     {
-      drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
-              ranges.getStartSeq(), ranges.getEndSeq(), 0);
-    }
+      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);
 
-    g.drawImage(lcimg, 0, 0, this);
+      return null;
+    }
 
+    return lcimg;
   }
 
   /**
@@ -525,6 +581,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());
@@ -546,16 +605,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))
@@ -821,7 +880,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;
@@ -829,7 +889,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;
@@ -847,8 +907,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)
@@ -879,29 +941,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);
@@ -909,8 +965,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
               if (sx < 0)
               {
-                ex += sx;
-                sx = 0;
+                // ex += sx;
+                // sx = 0;
               }
 
               if (sx + ex > visWidth)
@@ -923,12 +979,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);
@@ -1000,6 +1058,156 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   }
 
+  /*
+   * Draw the selection group as a separate image and overlay
+   */
+  private BufferedImage drawSelectionGroup()
+  {
+    // get a new image of the correct size
+    BufferedImage selectionImage = setupSelectionImage();
+
+    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();
+    // 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);
+
+    int visWidth = av.getRanges().getViewportWidth() * charWidth;
+
+    int startRes = av.getRanges().getStartRes();
+
+    // set x start and end positions of group
+    int startx = (group.getStartRes() - startRes) * charWidth;
+    int endx = (group.getEndRes() - startRes + 1) * charWidth;
+
+    int oldY = -1;
+    int i = 0;
+    boolean inGroup = false;
+    int top = -1;
+    int bottom = -1;
+
+    // get sequences to determine y positions of group
+    int startSeq = av.getRanges().getStartSeq();
+    for (i = startSeq; i <= av.getRanges().getEndSeq(); ++i)
+    {
+      int sy = (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 = (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;
+    }
+
+    return selectionImage;
+  }
+
   /**
    * DOCUMENT ME!
    * 
@@ -1018,42 +1226,53 @@ 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 (evt.getPropertyName().equals("startres"))
+      if (eventName.equals(ViewportRanges.STARTRES))
+      {
+        repaint();
+      }
+    }
+    else
+    {
+      int scrollX = 0;
+      if (eventName.equals(ViewportRanges.STARTRES))
       {
-        // scroll - startres and endres both change
-
         // 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;
         }
-        fastPaint(scrollX, 0, false);
       }
-      else if (evt.getPropertyName().equals("endres"))
+
+      // 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))
       {
-        // resize - only endres changes
-        int scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
-        fastPaint(scrollX, 0, true);
+        // scroll - startres and endres both change
+        fastPaint(scrollX, 0);
       }
-      else if (evt.getPropertyName().equals("startseq"))
+      else if (eventName.equals(ViewportRanges.STARTSEQ))
       {
         // scroll
-        fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue(), false);
-      }
-      else if (evt.getPropertyName().equals("endseq"))
-      {
-        // resize
-        fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue(),
-                true);
+        fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
       }
     }
   }