X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqCanvas.java;h=3d8b8aafeb3e5874138e20417f53fa0daecf6893;hb=e04bcd38992def511190a30f98cb3db3a720e0fc;hp=e7d90300fc3af87550608b97a80679d5c883731f;hpb=b2f9a8d7bce642ff4011bc6d49e02bb0569fbb11;p=jalview.git

diff --git a/src/jalview/gui/SeqCanvas.java b/src/jalview/gui/SeqCanvas.java
index e7d9030..3d8b8aa 100755
--- a/src/jalview/gui/SeqCanvas.java
+++ b/src/jalview/gui/SeqCanvas.java
@@ -1,28 +1,49 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.1)
- * 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.
  * 
  * Jalview is free software: you can redistribute it and/or
  * modify it under the terms of the GNU General Public License 
- * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
  *  
  * Jalview is distributed in the hope that it will be useful, but 
  * WITHOUT ANY WARRANTY; without even the implied warranty 
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
  * PURPOSE.  See the GNU General Public License for more details.
  * 
- * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  * The Jalview Authors are detailed in the 'AUTHORS' file.
  */
 package jalview.gui;
 
-import java.awt.*;
-import java.awt.image.*;
-import javax.swing.*;
-
-import jalview.datamodel.*;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.HiddenColumns;
+import jalview.datamodel.SearchResultsI;
+import jalview.datamodel.SequenceGroup;
+import jalview.datamodel.SequenceI;
+import jalview.renderer.ScaleRenderer;
+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;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.image.BufferedImage;
+import java.beans.PropertyChangeEvent;
+import java.util.List;
+
+import javax.swing.JComponent;
 
 /**
  * DOCUMENT ME!
@@ -30,24 +51,18 @@ import jalview.datamodel.*;
  * @author $author$
  * @version $Revision$
  */
-public class SeqCanvas extends JComponent
+public class SeqCanvas extends JComponent implements ViewportListenerI
 {
   final FeatureRenderer fr;
 
-  final SequenceRenderer sr;
+  final SequenceRenderer seqRdr;
 
   BufferedImage img;
 
   Graphics2D gg;
 
-  int imgWidth;
-
-  int imgHeight;
-
   AlignViewport av;
 
-  SearchResults searchResults = null;
-
   boolean fastPaint = false;
 
   int LABEL_WEST;
@@ -58,6 +73,14 @@ public class SeqCanvas extends JComponent
 
   int cursorY = 0;
 
+  int charHeight = 0;
+
+  int charWidth = 0;
+
+  boolean fastpainting = false;
+
+  AnnotationPanel annotations;
+
   /**
    * Creates a new SeqCanvas object.
    * 
@@ -67,16 +90,19 @@ public class SeqCanvas extends JComponent
   public SeqCanvas(AlignmentPanel ap)
   {
     this.av = ap.av;
+    updateViewport();
     fr = new FeatureRenderer(ap);
-    sr = new SequenceRenderer(av);
+    seqRdr = new SequenceRenderer(av);
     setLayout(new BorderLayout());
     PaintRefresher.Register(this, av.getSequenceSetId());
     setBackground(Color.white);
+
+    av.getRanges().addPropertyChangeListener(this);
   }
 
   public SequenceRenderer getSequenceRenderer()
   {
-    return sr;
+    return seqRdr;
   }
 
   public FeatureRenderer getFeatureRenderer()
@@ -84,6 +110,12 @@ public class SeqCanvas extends JComponent
     return fr;
   }
 
+  private void updateViewport()
+  {
+    charHeight = av.getCharHeight();
+    charWidth = av.getCharWidth();
+  }
+
   /**
    * DOCUMENT ME!
    * 
@@ -96,28 +128,29 @@ public class SeqCanvas extends JComponent
    * @param ypos
    *          DOCUMENT ME!
    */
-  void drawNorthScale(Graphics g, int startx, int endx, int ypos)
+  private void drawNorthScale(Graphics g, int startx, int endx, int ypos)
   {
-    int scalestartx = startx - (startx % 10) + 10;
-
-    g.setColor(Color.black);
-
-    // NORTH SCALE
-    for (int i = scalestartx; i < endx; i += 10)
+    updateViewport();
+    for (ScaleMark mark : new ScaleRenderer().calculateMarks(av, startx,
+            endx))
     {
-      int value = i;
-      if (av.hasHiddenColumns())
+      int mpos = mark.column; // (i - startx - 1)
+      if (mpos < 0)
       {
-        value = av.getColumnSelection().adjustForHiddenColumns(value);
+        continue;
       }
+      String mstring = mark.text;
 
-      g.drawString(String.valueOf(value), (i - startx - 1) * av.charWidth,
-              ypos - (av.charHeight / 2));
-
-      g.drawLine(((i - startx - 1) * av.charWidth) + (av.charWidth / 2),
-              (ypos + 2) - (av.charHeight / 2),
-              ((i - startx - 1) * av.charWidth) + (av.charWidth / 2),
-              ypos - 2);
+      if (mark.major)
+      {
+        if (mstring != null)
+        {
+          g.drawString(mstring, mpos * charWidth, ypos - (charHeight / 2));
+        }
+        g.drawLine((mpos * charWidth) + (charWidth / 2),
+                (ypos + 2) - (charHeight / 2),
+                (mpos * charWidth) + (charWidth / 2), ypos - 2);
+      }
     }
   }
 
@@ -136,18 +169,21 @@ public class SeqCanvas extends JComponent
   void drawWestScale(Graphics g, int startx, int endx, int ypos)
   {
     FontMetrics fm = getFontMetrics(av.getFont());
-    ypos += av.charHeight;
+    ypos += charHeight;
 
     if (av.hasHiddenColumns())
     {
-      startx = av.getColumnSelection().adjustForHiddenColumns(startx);
-      endx = av.getColumnSelection().adjustForHiddenColumns(endx);
+      startx = av.getAlignment().getHiddenColumns()
+              .adjustForHiddenColumns(startx);
+      endx = av.getAlignment().getHiddenColumns()
+              .adjustForHiddenColumns(endx);
     }
 
     int maxwidth = av.getAlignment().getWidth();
     if (av.hasHiddenColumns())
     {
-      maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
+      maxwidth = av.getAlignment().getHiddenColumns()
+              .findColumnPosition(maxwidth) - 1;
     }
 
     // WEST SCALE
@@ -174,9 +210,9 @@ public class SeqCanvas extends JComponent
       if (value != -1)
       {
         int x = LABEL_WEST - fm.stringWidth(String.valueOf(value))
-                - av.charWidth / 2;
-        g.drawString(value + "", x, (ypos + (i * av.charHeight))
-                - (av.charHeight / 5));
+                - charWidth / 2;
+        g.drawString(value + "", x,
+                (ypos + (i * charHeight)) - (charHeight / 5));
       }
     }
   }
@@ -195,11 +231,12 @@ public class SeqCanvas extends JComponent
    */
   void drawEastScale(Graphics g, int startx, int endx, int ypos)
   {
-    ypos += av.charHeight;
+    ypos += charHeight;
 
     if (av.hasHiddenColumns())
     {
-      endx = av.getColumnSelection().adjustForHiddenColumns(endx);
+      endx = av.getAlignment().getHiddenColumns()
+              .adjustForHiddenColumns(endx);
     }
 
     SequenceI seq;
@@ -226,13 +263,12 @@ public class SeqCanvas extends JComponent
 
       if (value != -1)
       {
-        g.drawString(String.valueOf(value), 0, (ypos + (i * av.charHeight))
-                - (av.charHeight / 5));
+        g.drawString(String.valueOf(value), 0,
+                (ypos + (i * charHeight)) - (charHeight / 5));
       }
     }
   }
 
-  boolean fastpainting = false;
 
   /**
    * need to make this thread safe move alignment rendering in response to
@@ -245,59 +281,55 @@ public class SeqCanvas extends JComponent
    */
   public void fastPaint(int horizontal, int vertical)
   {
-    if (fastpainting)
+    if (fastpainting || gg == null)
     {
       return;
     }
     fastpainting = true;
-    if (gg == null)
-    {
-      return;
-    }
-
     fastPaint = true;
+    updateViewport();
 
-    gg.copyArea(horizontal * av.charWidth, vertical * av.charHeight,
-            imgWidth, imgHeight, -horizontal * av.charWidth, -vertical
-                    * av.charHeight);
-
-    int sr = av.startRes;
-    int er = av.endRes;
-    int ss = av.startSeq;
-    int es = av.endSeq;
+    ViewportRanges ranges = av.getRanges();
+    int sr = ranges.getStartRes();
+    int er = ranges.getEndRes();
+    int ss = ranges.getStartSeq();
+    int es = ranges.getEndSeq();
     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
     {
-      er++;
-      transX = (er - sr - horizontal) * av.charWidth;
+      transX = (er - sr - horizontal) * charWidth;
       sr = er - horizontal;
     }
     else if (horizontal < 0)
     {
-      er = sr - horizontal - 1;
+      er = sr - horizontal;
     }
     else if (vertical > 0) // scroll down
     {
       ss = es - vertical;
 
-      if (ss < av.startSeq)
+      if (ss < ranges.getStartSeq())
       { // ie scrolling too fast, more than a page at a time
-        ss = av.startSeq;
+        ss = ranges.getStartSeq();
       }
       else
       {
-        transY = imgHeight - (vertical * av.charHeight);
+        transY = img.getHeight() - ((vertical + 1) * charHeight);
       }
     }
     else if (vertical < 0)
     {
       es = ss - vertical;
 
-      if (es > av.endSeq)
+      if (es > ranges.getEndSeq())
       {
-        es = av.endSeq;
+        es = ranges.getEndSeq();
       }
     }
 
@@ -319,73 +351,204 @@ public class SeqCanvas extends JComponent
    */
 
   // Set this to false to force a full panel paint
+  @Override
   public void paintComponent(Graphics g)
   {
-    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();
+
+    ViewportRanges ranges = av.getRanges();
+
+    int width = getWidth();
+    int height = getHeight();
+
+    width -= (width % charWidth);
+    height -= (height % charHeight);
+
+    // selectImage is the selection group outline image
+    BufferedImage selectImage = drawSelectionGroup(
+            ranges.getStartRes(), ranges.getEndRes(),
+            ranges.getStartSeq(), ranges.getEndSeq());
+
+    if ((img != null) && (fastPaint
+            || (getVisibleRect().width != g.getClipBounds().width)
+            || (getVisibleRect().height != g.getClipBounds().height)))
     {
+      BufferedImage lcimg = buildLocalImage(selectImage);
       g.drawImage(lcimg, 0, 0, this);
       fastPaint = false;
-      return;
     }
+    else if ((width > 0) && (height > 0))
+    {
+      // img is a cached version of the last view we drew, if any
+      // if we have no img or the size has changed, make a new one
+      if (img == null || width != img.getWidth()
+              || height != img.getHeight())
+      {
+        img = setupImage();
+        if (img == null)
+        {
+          return;
+        }
+        gg = (Graphics2D) img.getGraphics();
+        gg.setFont(av.getFont());
+      }
 
-    // this draws the whole of the alignment
-    imgWidth = getWidth();
-    imgHeight = getHeight();
+      if (av.antiAlias)
+      {
+        gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                RenderingHints.VALUE_ANTIALIAS_ON);
+      }
 
-    imgWidth -= (imgWidth % av.charWidth);
-    imgHeight -= (imgHeight % av.charHeight);
+      gg.setColor(Color.white);
+      gg.fillRect(0, 0, img.getWidth(), img.getHeight());
 
-    if ((imgWidth < 1) || (imgHeight < 1))
-    {
-      return;
+      if (av.getWrapAlignment())
+      {
+        drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
+      }
+      else
+      {
+        drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
+                ranges.getStartSeq(), ranges.getEndSeq(), 0);
+      }
+
+      // lcimg is a local *copy* of img which we'll draw selectImage on top of
+      BufferedImage lcimg = buildLocalImage(selectImage);
+      g.drawImage(lcimg, 0, 0, this);
     }
+  }
 
-    if (lcimg == null || imgWidth != lcimg.getWidth()
-            || imgHeight != lcimg.getHeight())
+  /**
+   * Draw an alignment panel for printing
+   * 
+   * @param g1
+   *          Graphics object to draw with
+   * @param startRes
+   *          start residue of print area
+   * @param endRes
+   *          end residue of print area
+   * @param startSeq
+   *          start sequence of print area
+   * @param endSeq
+   *          end sequence of print area
+   */
+  public void drawPanelForPrinting(Graphics g1, int startRes, int endRes,
+          int startSeq, int endSeq)
+  {
+    BufferedImage selectImage = drawSelectionGroup(startRes, endRes,
+            startSeq, endSeq);
+    drawPanel(g1, startRes, endRes, startSeq, endSeq, 0);
+    ((Graphics2D) g1).setComposite(
+            AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
+    g1.drawImage(selectImage, 0, 0, this);
+  }
+
+  /**
+   * Draw a wrapped alignment panel for printing
+   * 
+   * @param g
+   *          Graphics object to draw with
+   * @param canvasWidth
+   *          width of drawing area
+   * @param canvasHeight
+   *          height of drawing area
+   * @param startRes
+   *          start residue of print area
+   */
+  public void drawWrappedPanelForPrinting(Graphics g, int canvasWidth,
+          int canvasHeight, int startRes)
+  {
+    SequenceGroup group = av.getSelectionGroup();
+
+    drawWrappedPanel(g, canvasWidth, canvasHeight, startRes);
+
+    if (group != null)
     {
+      BufferedImage selectImage = null;
       try
       {
-        lcimg = img = new BufferedImage(imgWidth, imgHeight,
-                BufferedImage.TYPE_INT_RGB);
-        gg = (Graphics2D) img.getGraphics();
-        gg.setFont(av.getFont());
+        selectImage = new BufferedImage(canvasWidth, canvasHeight,
+                BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
       } catch (OutOfMemoryError er)
       {
         System.gc();
-        System.err.println("SeqCanvas OutOfMemory Redraw Error.\n" + er);
-        new OOMWarning("Creating alignment image for display", er);
-
-        return;
+        System.err.println("Print image OutOfMemory Error.\n" + er);
+        new OOMWarning("Creating wrapped alignment image for printing", er);
+      }
+      if (selectImage != null)
+      {
+        Graphics2D g2 = selectImage.createGraphics();
+        setupSelectionGroup(g2, selectImage);
+        drawWrappedSelection(g2, group, canvasWidth, canvasHeight,
+                startRes);
+
+        g2.setComposite(
+                AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
+        g.drawImage(selectImage, 0, 0, this);
+        g2.dispose();
       }
     }
+  }
 
-    if (av.antiAlias)
+  /*
+   * 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)
     {
-      gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-              RenderingHints.VALUE_ANTIALIAS_ON);
+      g2d.setComposite(
+              AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
+      g2d.drawImage(selectImage, 0, 0, this);
     }
+    g2d.dispose();
+
+    return lcimg;
+  }
 
-    gg.setColor(Color.white);
-    gg.fillRect(0, 0, imgWidth, imgHeight);
+  /*
+   * Set up a buffered image of the correct height and size for the sequence canvas
+   */
+  private BufferedImage setupImage()
+  {
+    BufferedImage lcimg = null;
+
+    int width = getWidth();
+    int height = getHeight();
 
-    if (av.getWrapAlignment())
+    width -= (width % charWidth);
+    height -= (height % charHeight);
+
+    if ((width < 1) || (height < 1))
     {
-      drawWrappedPanel(gg, getWidth(), getHeight(), av.startRes);
+      return null;
     }
-    else
+
+    try
     {
-      drawPanel(gg, av.startRes, av.endRes, av.startSeq, av.endSeq, 0);
-    }
+      lcimg = new BufferedImage(width, height,
+              BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
+    } catch (OutOfMemoryError er)
+    {
+      System.gc();
+      System.err.println(
+              "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;
   }
 
   /**
@@ -403,17 +566,17 @@ public class SeqCanvas extends JComponent
     LABEL_EAST = 0;
     LABEL_WEST = 0;
 
-    if (av.scaleRightWrapped)
+    if (av.getScaleRightWrapped())
     {
       LABEL_EAST = fm.stringWidth(getMask());
     }
 
-    if (av.scaleLeftWrapped)
+    if (av.getScaleLeftWrapped())
     {
       LABEL_WEST = fm.stringWidth(getMask());
     }
 
-    return (cwidth - LABEL_EAST - LABEL_WEST) / av.charWidth;
+    return (cwidth - LABEL_EAST - LABEL_WEST) / charWidth;
   }
 
   /**
@@ -454,43 +617,48 @@ public class SeqCanvas extends JComponent
    * @param startRes
    *          DOCUMENT ME!
    */
-  public void drawWrappedPanel(Graphics g, int canvasWidth,
+  private void drawWrappedPanel(Graphics g, int canvasWidth,
           int canvasHeight, int startRes)
   {
+    updateViewport();
     AlignmentI al = av.getAlignment();
 
     FontMetrics fm = getFontMetrics(av.getFont());
 
-    if (av.scaleRightWrapped)
+    LABEL_EAST = 0;
+    LABEL_WEST = 0;
+
+    if (av.getScaleRightWrapped())
     {
       LABEL_EAST = fm.stringWidth(getMask());
     }
 
-    if (av.scaleLeftWrapped)
+    if (av.getScaleLeftWrapped())
     {
       LABEL_WEST = fm.stringWidth(getMask());
     }
 
-    int hgap = av.charHeight;
-    if (av.scaleAboveWrapped)
+    int hgap = charHeight;
+    if (av.getScaleAboveWrapped())
     {
-      hgap += av.charHeight;
+      hgap += charHeight;
     }
 
-    int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / av.charWidth;
-    int cHeight = av.getAlignment().getHeight() * av.charHeight;
+    int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / charWidth;
+    int cHeight = av.getAlignment().getHeight() * charHeight;
 
     av.setWrappedWidth(cWidth);
 
-    av.endRes = av.startRes + cWidth;
+    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.getColumnSelection().findColumnPosition(maxwidth) - 1;
+      maxwidth = av.getAlignment().getHiddenColumns()
+              .findColumnPosition(maxwidth);
     }
 
     while ((ypos <= canvasHeight) && (startRes < maxwidth))
@@ -505,12 +673,12 @@ public class SeqCanvas extends JComponent
       g.setFont(av.getFont());
       g.setColor(Color.black);
 
-      if (av.scaleLeftWrapped)
+      if (av.getScaleLeftWrapped())
       {
         drawWestScale(g, startRes, endx, ypos);
       }
 
-      if (av.scaleRightWrapped)
+      if (av.getScaleRightWrapped())
       {
         g.translate(canvasWidth - LABEL_EAST, 0);
         drawEastScale(g, startRes, endx, ypos);
@@ -519,32 +687,34 @@ public class SeqCanvas extends JComponent
 
       g.translate(LABEL_WEST, 0);
 
-      if (av.scaleAboveWrapped)
+      if (av.getScaleAboveWrapped())
       {
         drawNorthScale(g, startRes, endx, ypos);
       }
 
-      if (av.hasHiddenColumns() && av.showHiddenMarkers)
+      if (av.hasHiddenColumns() && av.getShowHiddenMarkers())
       {
         g.setColor(Color.blue);
         int res;
-        for (int i = 0; i < av.getColumnSelection().getHiddenColumns()
-                .size(); i++)
+        HiddenColumns hidden = av.getAlignment().getHiddenColumns();
+        List<Integer> positions = hidden.findHiddenRegionPositions();
+        for (int pos : positions)
         {
-          res = av.getColumnSelection().findHiddenRegionPosition(i)
-                  - startRes;
+          res = pos - startRes;
 
           if (res < 0 || res > endx - startRes)
           {
             continue;
           }
 
-          gg.fillPolygon(new int[]
-          { res * av.charWidth - av.charHeight / 4,
-              res * av.charWidth + av.charHeight / 4, res * av.charWidth },
+          gg.fillPolygon(
                   new int[]
-                  { ypos - (av.charHeight / 2), ypos - (av.charHeight / 2),
-                      ypos - (av.charHeight / 2) + 8 }, 3);
+                  { res * charWidth - charHeight / 4,
+                      res * charWidth + charHeight / 4, res * charWidth },
+                  new int[]
+                  { ypos - (charHeight / 2), ypos - (charHeight / 2),
+                      ypos - (charHeight / 2) + 8 },
+                  3);
 
         }
       }
@@ -555,17 +725,17 @@ public class SeqCanvas extends JComponent
 
       if (clip == null)
       {
-        g.setClip(0, 0, cWidth * av.charWidth, canvasHeight);
+        g.setClip(0, 0, cWidth * charWidth, canvasHeight);
       }
       else
       {
-        g.setClip(0, (int) clip.getBounds().getY(), cWidth * av.charWidth,
+        g.setClip(0, (int) clip.getBounds().getY(), cWidth * charWidth,
                 (int) clip.getBounds().getHeight());
       }
 
-      drawPanel(g, startRes, endx, 0, al.getHeight(), ypos);
+      drawPanel(g, startRes, endx, 0, al.getHeight() - 1, ypos);
 
-      if (av.showAnnotation)
+      if (av.isShowAnnotation())
       {
         g.translate(0, cHeight + ypos + 3);
         if (annotations == null)
@@ -573,8 +743,8 @@ public class SeqCanvas extends JComponent
           annotations = new AnnotationPanel(av);
         }
 
-        annotations.renderer.drawComponent(annotations, av, (Graphics2D) g,
-                -1, startRes, endx + 1);
+        annotations.renderer.drawComponent(annotations, av, g, -1, startRes,
+                endx + 1);
         g.translate(0, -cHeight - ypos - 3);
       }
       g.setClip(clip);
@@ -586,11 +756,65 @@ public class SeqCanvas extends JComponent
     }
   }
 
-  AnnotationPanel annotations;
+  /*
+   * Draw a selection group over a wrapped alignment
+   */
+  private void drawWrappedSelection(Graphics2D g, SequenceGroup group,
+          int canvasWidth,
+          int canvasHeight, int startRes)
+  {
+    // height gap above each panel
+    int hgap = charHeight;
+    if (av.getScaleAboveWrapped())
+    {
+      hgap += charHeight;
+    }
+
+    int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / charWidth;
+    int cHeight = av.getAlignment().getHeight() * charHeight;
+
+    int startx = startRes;
+    int endx;
+    int ypos = hgap; // vertical offset
+    int maxwidth = av.getAlignment().getWidth();
+
+    if (av.hasHiddenColumns())
+    {
+      maxwidth = av.getAlignment().getHiddenColumns()
+              .findColumnPosition(maxwidth);
+    }
+
+    // chop the wrapped alignment extent up into panel-sized blocks and treat
+    // each block as if it were a block from an unwrapped alignment
+    while ((ypos <= canvasHeight) && (startx < maxwidth))
+    {
+      // set end value to be start + width, or maxwidth, whichever is smaller
+      endx = startx + cWidth - 1;
+
+      if (endx > maxwidth)
+      {
+        endx = maxwidth;
+      }
+
+      g.translate(LABEL_WEST, 0);
+
+      drawUnwrappedSelection(g, group, startx, endx, 0,
+              av.getAlignment().getHeight() - 1,
+              ypos);
+
+      g.translate(-LABEL_WEST, 0);
+
+      // update vertical offset
+      ypos += cHeight + getAnnotationHeight() + hgap;
+
+      // update horizontal offset
+      startx += cWidth;
+    }
+  }
 
   int getAnnotationHeight()
   {
-    if (!av.showAnnotation)
+    if (!av.isShowAnnotation())
     {
       return 0;
     }
@@ -603,40 +827,39 @@ public class SeqCanvas extends JComponent
     return annotations.adjustPanelHeight();
   }
 
-  /**
-   * DOCUMENT ME!
+  /*
+   * Draw an alignment panel for printing
    * 
    * @param g1
-   *          DOCUMENT ME!
+   *          Graphics object to draw with
    * @param startRes
-   *          DOCUMENT ME!
+   *          start residue of print area
    * @param endRes
-   *          DOCUMENT ME!
+   *          end residue of print area
    * @param startSeq
-   *          DOCUMENT ME!
+   *          start sequence of print area
    * @param endSeq
-   *          DOCUMENT ME!
+   *          end sequence of print area
    * @param offset
-   *          DOCUMENT ME!
+   *          vertical offset
    */
-  void drawPanel(Graphics g1, int startRes, int endRes, int startSeq,
-          int endSeq, int offset)
+  private void drawPanel(Graphics g1, int startRes, int endRes,
+          int startSeq, int endSeq, int offset)
   {
+    updateViewport();
     if (!av.hasHiddenColumns())
     {
       draw(g1, startRes, endRes, startSeq, endSeq, offset);
     }
     else
     {
-      java.util.Vector regions = av.getColumnSelection().getHiddenColumns();
-
       int screenY = 0;
       int blockStart = startRes;
       int blockEnd = endRes;
 
-      for (int i = 0; regions != null && i < regions.size(); i++)
+      for (int[] region : av.getAlignment().getHiddenColumns()
+              .getHiddenColumnsCopy())
       {
-        int[] region = (int[]) regions.elementAt(i);
         int hideStart = region[0];
         int hideEnd = region[1];
 
@@ -648,7 +871,7 @@ public class SeqCanvas extends JComponent
 
         blockEnd = hideStart - 1;
 
-        g1.translate(screenY * av.charWidth, 0);
+        g1.translate(screenY * charWidth, 0);
 
         draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
 
@@ -656,41 +879,46 @@ public class SeqCanvas extends JComponent
         {
           g1.setColor(Color.blue);
 
-          g1.drawLine((blockEnd - blockStart + 1) * av.charWidth - 1,
-                  0 + offset, (blockEnd - blockStart + 1) * av.charWidth
-                          - 1, (endSeq - startSeq) * av.charHeight + offset);
+          g1.drawLine((blockEnd - blockStart + 1) * charWidth - 1,
+                  0 + offset, (blockEnd - blockStart + 1) * charWidth - 1,
+                  (endSeq - startSeq + 1) * charHeight + offset);
         }
 
-        g1.translate(-screenY * av.charWidth, 0);
+        g1.translate(-screenY * charWidth, 0);
         screenY += blockEnd - blockStart + 1;
         blockStart = hideEnd + 1;
+
+        if (screenY > (endRes - startRes))
+        {
+          // already rendered last block
+          return;
+        }
       }
 
       if (screenY <= (endRes - startRes))
       {
+        // remaining visible region to render
         blockEnd = blockStart + (endRes - startRes) - screenY;
-        g1.translate(screenY * av.charWidth, 0);
+        g1.translate(screenY * charWidth, 0);
         draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
 
-        g1.translate(-screenY * av.charWidth, 0);
+        g1.translate(-screenY * charWidth, 0);
       }
     }
 
   }
 
-  // int startRes, int endRes, int startSeq, int endSeq, int x, int y,
-  // int x1, int x2, int y1, int y2, int startx, int starty,
-  void draw(Graphics g, int startRes, int endRes, int startSeq, int endSeq,
-          int offset)
+  private void draw(Graphics g, int startRes, int endRes, int startSeq,
+          int endSeq, int offset)
   {
     g.setFont(av.getFont());
-    sr.prepare(g, av.renderGaps);
+    seqRdr.prepare(g, av.isRenderGaps());
 
     SequenceI nextSeq;
 
     // / First draw the sequences
     // ///////////////////////////
-    for (int i = startSeq; i < endSeq; i++)
+    for (int i = startSeq; i <= endSeq; i++)
     {
       nextSeq = av.getAlignment().getSequenceAt(i);
       if (nextSeq == null)
@@ -699,29 +927,29 @@ public class SeqCanvas extends JComponent
         // empty
         continue;
       }
-      sr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
-              startRes, endRes, offset + ((i - startSeq) * av.charHeight));
+      seqRdr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
+              startRes, endRes, offset + ((i - startSeq) * charHeight));
 
-      if (av.showSequenceFeatures)
+      if (av.isShowSequenceFeatures())
       {
-        fr.drawSequence(g, nextSeq, startRes, endRes, offset
-                + ((i - startSeq) * av.charHeight));
+        fr.drawSequence(g, nextSeq, startRes, endRes,
+                offset + ((i - startSeq) * charHeight), false);
       }
 
       // / Highlight search Results once all sequences have been drawn
       // ////////////////////////////////////////////////////////
-      if (searchResults != null)
+      if (av.hasSearchResults())
       {
-        int[] visibleResults = searchResults.getResults(nextSeq, startRes,
-                endRes);
+        int[] visibleResults = av.getSearchResults().getResults(nextSeq,
+                startRes, endRes);
         if (visibleResults != null)
         {
           for (int r = 0; r < visibleResults.length; r += 2)
           {
-            sr.drawHighlightedText(nextSeq, visibleResults[r],
+            seqRdr.drawHighlightedText(nextSeq, visibleResults[r],
                     visibleResults[r + 1], (visibleResults[r] - startRes)
-                            * av.charWidth, offset
-                            + ((i - startSeq) * av.charHeight));
+                            * charWidth, offset
+                            + ((i - startSeq) * charHeight));
           }
         }
       }
@@ -729,9 +957,8 @@ public class SeqCanvas extends JComponent
       if (av.cursorMode && cursorY == i && cursorX >= startRes
               && cursorX <= endRes)
       {
-        sr.drawCursor(nextSeq, cursorX,
-                (cursorX - startRes) * av.charWidth, offset
-                        + ((i - startSeq) * av.charHeight));
+        seqRdr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth,
+                offset + ((i - startSeq) * charHeight));
       }
     }
 
@@ -751,198 +978,388 @@ public class SeqCanvas extends JComponent
     // ///////////////////////////////////
     // Now outline any areas if necessary
     // ///////////////////////////////////
-    SequenceGroup group = av.getSelectionGroup();
 
-    int sx = -1;
-    int sy = -1;
-    int ex = -1;
+    SequenceGroup group = null;
     int groupIndex = -1;
-    int visWidth = (endRes - startRes + 1) * av.charWidth;
 
-    if ((group == null) && (av.getAlignment().getGroups().size() > 0))
+    if (av.getAlignment().getGroups().size() > 0)
     {
-      group = (SequenceGroup) av.getAlignment().getGroups().get(0);
+      group = av.getAlignment().getGroups().get(0);
       groupIndex = 0;
     }
 
     if (group != null)
     {
+      g.setStroke(new BasicStroke());
+      g.setColor(group.getOutlineColour());
+      
       do
       {
-        int oldY = -1;
-        int i = 0;
-        boolean inGroup = false;
-        int top = -1;
-        int bottom = -1;
+        drawPartialGroupOutline(g, group, startRes, endRes, startSeq,
+                endSeq, offset);
+
+        groupIndex++;
+
+        g.setStroke(new BasicStroke());
+
+        if (groupIndex >= av.getAlignment().getGroups().size())
+        {
+          break;
+        }
+
+        group = av.getAlignment().getGroups().get(groupIndex);
+
+      } while (groupIndex < av.getAlignment().getGroups().size());
+
+    }
+
+  }
+
+
+  /*
+   * 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();
+
+    setupSelectionGroup(g, selectionImage);
+
+    if (!av.getWrapAlignment())
+    {
+      drawUnwrappedSelection(g, group, startRes, endRes, startSeq, endSeq,
+              0);
+    }
+    else
+    {
+      drawWrappedSelection(g, group, getWidth(), getHeight(),
+              av.getRanges().getStartRes());
+    }
+
+    g.dispose();
+    return selectionImage;
+  }
+
+  /*
+   * Set up graphics for selection group
+   */
+  private void setupSelectionGroup(Graphics2D g,
+          BufferedImage selectionImage)
+  {
+    // set background to transparent
+    g.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
+    g.fillRect(0, 0, selectionImage.getWidth(), selectionImage.getHeight());
+
+    // set up foreground to draw red dashed line
+    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);
+  }
+
+  /*
+   * Draw a selection group over an unwrapped alignment
+   * @param g graphics object to draw with
+   * @param group selection group
+   * @param startRes start residue of area to draw
+   * @param endRes end residue of area to draw
+   * @param startSeq start sequence of area to draw
+   * @param endSeq end sequence of area to draw
+   * @param offset vertical offset (used when called from wrapped alignment code)
+   */
+  private void drawUnwrappedSelection(Graphics2D g, SequenceGroup group,
+          int startRes, int endRes, int startSeq, int endSeq, int offset)
+  {
+    if (!av.hasHiddenColumns())
+    {
+      drawPartialGroupOutline(g, group, startRes, endRes, startSeq, endSeq,
+              offset);
+    }
+    else
+    {
+      // package into blocks of visible columns
+      int screenY = 0;
+      int blockStart = startRes;
+      int blockEnd = endRes;
+
+      for (int[] region : av.getAlignment().getHiddenColumns()
+              .getHiddenColumnsCopy())
+      {
+        int hideStart = region[0];
+        int hideEnd = region[1];
 
-        for (i = startSeq; i < endSeq; i++)
+        if (hideStart <= blockStart)
         {
-          sx = (group.getStartRes() - startRes) * av.charWidth;
-          sy = offset + ((i - startSeq) * av.charHeight);
-          ex = (((group.getEndRes() + 1) - group.getStartRes()) * av.charWidth) - 1;
+          blockStart += (hideEnd - hideStart) + 1;
+          continue;
+        }
 
-          if (sx + ex < 0 || sx > visWidth)
-          {
-            continue;
-          }
+        blockEnd = hideStart - 1;
 
-          if ((sx <= (endRes - startRes) * av.charWidth)
-                  && group.getSequences(null).contains(
-                          av.getAlignment().getSequenceAt(i)))
-          {
-            if ((bottom == -1)
-                    && !group.getSequences(null).contains(
-                            av.getAlignment().getSequenceAt(i + 1)))
-            {
-              bottom = sy + av.charHeight;
-            }
-
-            if (!inGroup)
-            {
-              if (((top == -1) && (i == 0))
-                      || !group.getSequences(null).contains(
-                              av.getAlignment().getSequenceAt(i - 1)))
-              {
-                top = sy;
-              }
-
-              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());
-              }
-            }
-          }
-          else
+        g.translate(screenY * charWidth, 0);
+        drawPartialGroupOutline(g, group,
+                blockStart, blockEnd, startSeq, endSeq, offset);
+
+        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);
+        drawPartialGroupOutline(g, group,
+                blockStart, blockEnd, startSeq, endSeq, offset);
+        
+        g.translate(-screenY * charWidth, 0);
+      }
+    }
+  }
+
+  /*
+   * Draw the selection group as a separate image and overlay
+   */
+  private void drawPartialGroupOutline(Graphics2D g, SequenceGroup group,
+          int startRes, int endRes, int startSeq, int endSeq,
+          int verticalOffset)
+  {
+    int visWidth = (endRes - startRes + 1) * charWidth;
+
+    int oldY = -1;
+    int i = 0;
+    boolean inGroup = false;
+    int top = -1;
+    int bottom = -1;
+
+    int sx = -1;
+    int sy = -1;
+    int xwidth = -1;
+
+    for (i = startSeq; i <= endSeq; i++)
+    {
+      // position of start residue of group relative to startRes, in pixels
+      sx = (group.getStartRes() - startRes) * charWidth;
+
+      // width of group in pixels
+      xwidth = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth)
+              - 1;
+
+      sy = verticalOffset + (i - startSeq) * charHeight;
+
+      if (sx + xwidth < 0 || sx > visWidth)
+      {
+        continue;
+      }
+
+      if ((sx <= (endRes - startRes) * charWidth)
+              && 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)))
           {
-            if (inGroup)
-            {
-              if (sx >= 0 && sx < visWidth)
-              {
-                g.drawLine(sx, oldY, sx, sy);
-              }
-
-              if (sx + ex < visWidth)
-              {
-                g.drawLine(sx + ex, oldY, sx + ex, sy);
-              }
-
-              if (sx < 0)
-              {
-                ex += sx;
-                sx = 0;
-              }
-
-              if (sx + ex > visWidth)
-              {
-                ex = visWidth;
-              }
-
-              else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)
-              {
-                ex = (endRes - startRes + 1) * av.charWidth;
-              }
-
-              if (top != -1)
-              {
-                g.drawLine(sx, top, sx + ex, top);
-                top = -1;
-              }
-
-              if (bottom != -1)
-              {
-                g.drawLine(sx, bottom, sx + ex, bottom);
-                bottom = -1;
-              }
-
-              inGroup = false;
-            }
+            top = sy;
           }
-        }
 
+          oldY = sy;
+          inGroup = true;
+        }
+      }
+      else
+      {
         if (inGroup)
         {
-          sy = offset + ((i - startSeq) * av.charHeight);
+          // if start position is visible, draw vertical line to left of
+          // group
           if (sx >= 0 && sx < visWidth)
           {
             g.drawLine(sx, oldY, sx, sy);
           }
 
-          if (sx + ex < visWidth)
+          // if end position is visible, draw vertical line to right of
+          // group
+          if (sx + xwidth < visWidth)
           {
-            g.drawLine(sx + ex, oldY, sx + ex, sy);
+            g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
           }
 
           if (sx < 0)
           {
-            ex += sx;
+            xwidth += sx;
             sx = 0;
           }
 
-          if (sx + ex > visWidth)
-          {
-            ex = visWidth;
-          }
-          else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)
+          // don't let width extend beyond current block, or group extent
+          // fixes JAL-2672
+          if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
           {
-            ex = (endRes - startRes + 1) * av.charWidth;
+            xwidth = (endRes - startRes + 1) * charWidth - sx;
           }
-
+          
+          // draw horizontal line at top of group
           if (top != -1)
           {
-            g.drawLine(sx, top, sx + ex, top);
+            g.drawLine(sx, top, sx + xwidth, top);
             top = -1;
           }
 
+          // draw horizontal line at bottom of group
           if (bottom != -1)
           {
-            g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);
+            g.drawLine(sx, bottom, sx + xwidth, bottom);
             bottom = -1;
           }
 
           inGroup = false;
         }
+      }
+    }
 
-        groupIndex++;
+    if (inGroup)
+    {
+      sy = verticalOffset + ((i - startSeq) * charHeight);
+      if (sx >= 0 && sx < visWidth)
+      {
+        g.drawLine(sx, oldY, sx, sy);
+      }
 
-        g.setStroke(new BasicStroke());
+      if (sx + xwidth < visWidth)
+      {
+        g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
+      }
 
-        if (groupIndex >= av.getAlignment().getGroups().size())
-        {
-          break;
-        }
+      if (sx < 0)
+      {
+        xwidth += sx;
+        sx = 0;
+      }
 
-        group = (SequenceGroup) av.getAlignment().getGroups()
-                .get(groupIndex);
+      if (sx + xwidth > visWidth)
+      {
+        xwidth = visWidth;
+      }
+      else if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
+      {
+        xwidth = (endRes - startRes + 1) * charWidth;
+      }
 
-      } while (groupIndex < av.getAlignment().getGroups().size());
+      if (top != -1)
+      {
+        g.drawLine(sx, top, sx + xwidth, top);
+        top = -1;
+      }
 
-    }
+      if (bottom != -1)
+      {
+        g.drawLine(sx, bottom - 1, sx + xwidth, bottom - 1);
+        bottom = -1;
+      }
 
+      inGroup = false;
+    }
   }
-
+  
   /**
    * DOCUMENT ME!
    * 
    * @param results
    *          DOCUMENT ME!
    */
-  public void highlightSearchResults(SearchResults results)
+  public void highlightSearchResults(SearchResultsI results)
   {
     img = null;
 
-    searchResults = results;
+    av.setSearchResults(results);
 
     repaint();
   }
+
+  @Override
+  public void propertyChange(PropertyChangeEvent evt)
+  {
+    String eventName = evt.getPropertyName();
+
+    if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
+    {
+      fastPaint = true;
+      repaint();
+    }
+    else if (av.getWrapAlignment())
+    {
+      if (eventName.equals(ViewportRanges.STARTRES))
+      {
+        repaint();
+      }
+    }
+    else
+    {
+      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();
+        scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
+        int range = vpRanges.getEndRes() - vpRanges.getStartRes();
+        if (scrollX > range)
+        {
+          scrollX = range;
+        }
+        else if (scrollX < -range)
+        {
+          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 (eventName.equals(ViewportRanges.STARTSEQ))
+      {
+        // scroll
+        fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
+      }
+    }
+  }
 }