X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqCanvas.java;h=b3fcc542f3c0f6f7d2fc3899b172bf0fe3b551b3;hb=a3ca1aac6c00fc2240fa21be9df43adcc1b964ff;hp=46f2d84517f35412eb3ffbea302b1f875147a3ba;hpb=919cef3e2b8c066ab9fe5cbfe7f76fa54601b788;p=jalview.git

diff --git a/src/jalview/gui/SeqCanvas.java b/src/jalview/gui/SeqCanvas.java
index 46f2d84..b3fcc54 100755
--- a/src/jalview/gui/SeqCanvas.java
+++ b/src/jalview/gui/SeqCanvas.java
@@ -25,6 +25,7 @@ import jalview.datamodel.HiddenColumns;
 import jalview.datamodel.SearchResultsI;
 import jalview.datamodel.SequenceGroup;
 import jalview.datamodel.SequenceI;
+import jalview.datamodel.VisibleContigsIterator;
 import jalview.renderer.ScaleRenderer;
 import jalview.renderer.ScaleRenderer.ScaleMark;
 import jalview.util.Comparison;
@@ -41,73 +42,69 @@ import java.awt.RenderingHints;
 import java.awt.Shape;
 import java.awt.image.BufferedImage;
 import java.beans.PropertyChangeEvent;
+import java.util.Iterator;
 import java.util.List;
 
 import javax.swing.JComponent;
 
 /**
- * DOCUMENT ME!
+ * The Swing component on which the alignment sequences, and annotations (if
+ * shown), are drawn. This includes scales above, left and right (if shown) in
+ * Wrapped mode, but not the scale above in Unwrapped mode.
  * 
- * @author $author$
- * @version $Revision$
  */
 public class SeqCanvas extends JComponent implements ViewportListenerI
 {
-  private static String ZEROS = "0000000000";
+  /*
+   * pixels gap between sequences and annotations when in wrapped mode
+   */
+  static final int SEQS_ANNOTATION_GAP = 3;
 
-  final FeatureRenderer fr;
+  private static final String ZEROS = "0000000000";
 
-  final SequenceRenderer sr;
+  final FeatureRenderer fr;
 
   BufferedImage img;
 
-  Graphics2D gg;
-
-  int imgWidth;
-
-  int imgHeight;
-
   AlignViewport av;
 
-  boolean fastPaint = false;
-
-  boolean fastpainting = false;
-
   int cursorX = 0;
 
   int cursorY = 0;
 
-  int charHeight = 0;
+  private final SequenceRenderer seqRdr;
+
+  private boolean fastPaint = false;
 
-  int charWidth = 0;
+  private boolean fastpainting = false;
 
   private AnnotationPanel annotations;
 
   /*
    * measurements for drawing a wrapped alignment
    */
-  int labelWidthWest; // label left width in pixels if shown
-
   private int labelWidthEast; // label right width in pixels if shown
 
-  private int wrappedSpaceAboveAlignment; // gap between widths
+  private int labelWidthWest; // label left width in pixels if shown
+
+  int wrappedSpaceAboveAlignment; // gap between widths
 
-  private int wrappedRepeatHeightPx; // height in pixels of wrapped width
+  int wrappedRepeatHeightPx; // height in pixels of wrapped width
 
   private int wrappedVisibleWidths; // number of wrapped widths displayed
 
+  private Graphics2D gg;
+
   /**
    * Creates a new SeqCanvas object.
    * 
-   * @param av
-   *          DOCUMENT ME!
+   * @param ap
    */
   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);
@@ -117,7 +114,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   public SequenceRenderer getSequenceRenderer()
   {
-    return sr;
+    return seqRdr;
   }
 
   public FeatureRenderer getFeatureRenderer()
@@ -125,12 +122,6 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     return fr;
   }
 
-  private void updateViewport()
-  {
-    charHeight = av.getCharHeight();
-    charWidth = av.getCharWidth();
-  }
-
   /**
    * Draws the scale above a region of a wrapped alignment, consisting of a
    * column number every major interval (10 columns).
@@ -147,7 +138,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    */
   private void drawNorthScale(Graphics g, int startx, int endx, int ypos)
   {
-    updateViewport();
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
 
     /*
      * white fill the scale space (for the fastPaint case)
@@ -189,6 +181,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    * Draw the scale to the left or right of a wrapped alignment
    * 
    * @param g
+   *          graphics context, positioned at the start of the scale to be drawn
    * @param startx
    *          first column of wrapped width (0.. excluding any hidden columns)
    * @param endx
@@ -198,16 +191,21 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    * @param left
    *          if true, scale is left of residues, if false, scale is right
    */
-  void drawVerticalScale(Graphics g, int startx, int endx, int ypos,
-          boolean left)
+  void drawVerticalScale(Graphics g, final int startx, final int endx,
+          final int ypos, final boolean left)
   {
-    ypos += charHeight;
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
+
+    int yPos = ypos + charHeight;
+    int startX = startx;
+    int endX = endx;
 
     if (av.hasHiddenColumns())
     {
       HiddenColumns hiddenColumns = av.getAlignment().getHiddenColumns();
-      startx = hiddenColumns.adjustForHiddenColumns(startx);
-      endx = hiddenColumns.adjustForHiddenColumns(endx);
+      startX = hiddenColumns.visibleToAbsoluteColumn(startx);
+      endX = hiddenColumns.visibleToAbsoluteColumn(endx);
     }
     FontMetrics fm = getFontMetrics(av.getFont());
 
@@ -219,9 +217,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
        * find sequence position of first non-gapped position -
        * to the right if scale left, to the left if scale right
        */
-      int index = left ? startx : endx;
+      int index = left ? startX : endX;
       int value = -1;
-      while (index >= startx && index <= endx)
+      while (index >= startX && index <= endX)
       {
         if (!Comparison.isGap(seq.getCharAt(index)))
         {
@@ -242,28 +240,24 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
        * white fill the space for the scale
        */
       g.setColor(Color.white);
-      int y = (ypos + (i * charHeight)) - (charHeight / 5);
-      y -= charHeight; // fillRect: origin is top left of rectangle
-      int xpos = left ? 0 : labelWidthWest + charWidth
-              * av.getRanges().getViewportWidth();
-      g.fillRect(xpos, y, left ? labelWidthWest : labelWidthEast,
+      int y = (yPos + (i * charHeight)) - (charHeight / 5);
+      // fillRect origin is top left of rectangle
+      g.fillRect(0, y - charHeight, left ? labelWidthWest : labelWidthEast,
               charHeight + 1);
-      y += charHeight; // drawString: origin is bottom left of text
 
       if (value != -1)
       {
-
         /*
-         * draw scale value, right justified, with half a character width
-         * separation from the sequence data
+         * draw scale value, right justified within its width less half a
+         * character width padding on the right
          */
+        int labelSpace = left ? labelWidthWest : labelWidthEast;
+        labelSpace -= charWidth / 2; // leave space to the right
         String valueAsString = String.valueOf(value);
-        int justify = fm.stringWidth(valueAsString) + charWidth;
-        xpos = left ? labelWidthWest - justify + charWidth / 2
-                : getWidth() - justify - charWidth / 2;
-
+        int labelLength = fm.stringWidth(valueAsString);
+        int xOffset = labelSpace - labelLength;
         g.setColor(Color.black);
-        g.drawString(valueAsString, xpos, y);
+        g.drawString(valueAsString, xOffset, y);
       }
     }
   }
@@ -288,7 +282,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    */
   public void fastPaint(int horizontal, int vertical)
   {
-    if (fastpainting || gg == null)
+    if (fastpainting || gg == null || img == null)
     {
       return;
     }
@@ -297,8 +291,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
     try
     {
-      updateViewport();
-
+      int charHeight = av.getCharHeight();
+      int charWidth = av.getCharWidth();
+    
       ViewportRanges ranges = av.getRanges();
       int startRes = ranges.getStartRes();
       int endRes = ranges.getEndRes();
@@ -306,9 +301,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       int endSeq = ranges.getEndSeq();
       int transX = 0;
       int transY = 0;
-
-      gg.copyArea(horizontal * charWidth, vertical * charHeight, imgWidth,
-              imgHeight, -horizontal * charWidth, -vertical * charHeight);
+      
+      gg.copyArea(horizontal * charWidth, vertical * charHeight,
+              img.getWidth(), img.getHeight(), -horizontal * charWidth,
+              -vertical * charHeight);
 
       if (horizontal > 0) // scrollbar pulled right, image to the left
       {
@@ -319,7 +315,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       {
         endRes = startRes - horizontal;
       }
-      else if (vertical > 0) // scroll down
+
+      if (vertical > 0) // scroll down
       {
         startSeq = endSeq - vertical;
 
@@ -329,7 +326,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         }
         else
         {
-          transY = imgHeight - ((vertical + 1) * charHeight);
+          transY = img.getHeight() - ((vertical + 1) * charHeight);
         }
       }
       else if (vertical < 0)
@@ -346,7 +343,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       drawPanel(gg, startRes, endRes, startSeq, endSeq, 0);
       gg.translate(-transX, -transY);
 
-      repaint();
+      // Call repaint on alignment panel so that repaints from other alignment
+      // panel components can be aggregated. Otherwise performance of the
+      // overview window and others may be adversely affected.
+      av.getAlignPanel().repaint();
     } finally
     {
       fastpainting = false;
@@ -356,73 +356,122 @@ 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
+    super.paintComponent(g);    
+    
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
+    
+    ViewportRanges ranges = av.getRanges();
+    
+    int width = getWidth();
+    int height = getHeight();
+    
+    width -= (width % charWidth);
+    height -= (height % charHeight);
+    
+    if ((img != null) && (fastPaint
             || (getVisibleRect().width != g.getClipBounds().width)
             || (getVisibleRect().height != g.getClipBounds().height)))
     {
-      g.drawImage(lcimg, 0, 0, this);
-      fastPaint = false;
-      return;
-    }
-
-    // this draws the whole of the alignment
-    imgWidth = getWidth();
-    imgHeight = getHeight();
+      g.drawImage(img, 0, 0, this);
 
-    imgWidth -= (imgWidth % charWidth);
-    imgHeight -= (imgHeight % charHeight);
+      drawSelectionGroup((Graphics2D) g, ranges.getStartRes(),
+              ranges.getEndRes(), ranges.getStartSeq(), ranges.getEndSeq());
 
-    if ((imgWidth < 1) || (imgHeight < 1))
-    {
-      return;
+      fastPaint = false;
     }
-
-    if (lcimg == null || imgWidth != lcimg.getWidth()
-            || imgHeight != lcimg.getHeight())
+    else if (width > 0 && height > 0)
     {
-      try
+      /*
+       * 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())
       {
-        lcimg = img = new BufferedImage(imgWidth, imgHeight,
-                BufferedImage.TYPE_INT_RGB);
+        img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
         gg = (Graphics2D) img.getGraphics();
         gg.setFont(av.getFont());
-      } catch (OutOfMemoryError er)
+      }
+    
+      if (av.antiAlias)
       {
-        System.gc();
-        System.err.println("SeqCanvas OutOfMemory Redraw Error.\n" + er);
-        new OOMWarning("Creating alignment image for display", er);
-
-        return;
+        gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                RenderingHints.VALUE_ANTIALIAS_ON);
       }
+    
+      gg.setColor(Color.white);
+      gg.fillRect(0, 0, img.getWidth(), img.getHeight());
+    
+      if (av.getWrapAlignment())
+      {
+        drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
+      }
+      else
+      {
+        drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
+                ranges.getStartSeq(), ranges.getEndSeq(), 0);
+      }
+
+      drawSelectionGroup(gg, ranges.getStartRes(),
+              ranges.getEndRes(), ranges.getStartSeq(), ranges.getEndSeq());
+
+      g.drawImage(img, 0, 0, this);
     }
 
-    if (av.antiAlias)
+    if (av.cursorMode)
     {
-      gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-              RenderingHints.VALUE_ANTIALIAS_ON);
+      drawCursor(g, ranges.getStartRes(), ranges.getEndRes(),
+              ranges.getStartSeq(), ranges.getEndSeq());
     }
+  }
+  
+  /**
+   * 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)
+  {
+    drawPanel(g1, startRes, endRes, startSeq, endSeq, 0);
 
-    gg.setColor(Color.white);
-    gg.fillRect(0, 0, imgWidth, imgHeight);
+    drawSelectionGroup((Graphics2D) g1, startRes, endRes,
+            startSeq, endSeq);
+  }
 
-    ViewportRanges ranges = av.getRanges();
-    if (av.getWrapAlignment())
-    {
-      drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
-    }
-    else
+  /**
+   * 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)
+  {
+    drawWrappedPanel(g, canvasWidth, canvasHeight, startRes);
+
+    SequenceGroup group = av.getSelectionGroup();
+    if (group != null)
     {
-      drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
-              ranges.getStartSeq(), ranges.getEndSeq(), 0);
+      drawWrappedSelection((Graphics2D) g, group, canvasWidth, canvasHeight,
+                startRes);
     }
-
-    g.drawImage(lcimg, 0, 0, this);
-
   }
 
   /**
@@ -436,29 +485,30 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    */
   public int getWrappedCanvasWidth(int canvasWidth)
   {
-    FontMetrics fm = getFontMetrics(av.getFont());
+    int charWidth = av.getCharWidth();
 
-    labelWidthEast = 0;
-    labelWidthWest = 0;
+    FontMetrics fm = getFontMetrics(av.getFont());
 
-    if (av.getScaleRightWrapped())
+    int labelWidth = 0;
+    
+    if (av.getScaleRightWrapped() || av.getScaleLeftWrapped())
     {
-      labelWidthEast = getLabelWidth(fm);
+      labelWidth = getLabelWidth(fm);
     }
 
-    if (av.getScaleLeftWrapped())
-    {
-      labelWidthWest = labelWidthEast > 0 ? labelWidthEast
-              : getLabelWidth(fm);
-    }
+    labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0;
+
+    labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0;
 
     return (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
   }
 
   /**
-   * Returns a pixel width suitable for showing the largest sequence coordinate
-   * (end position) in the alignment. Returns 2 plus the number of decimal
-   * digits to be shown (3 for 1-10, 4 for 11-99 etc).
+   * Returns a pixel width sufficient to show the largest sequence coordinate
+   * (end position) in the alignment, calculated as the FontMetrics width of
+   * zeroes "0000000" limited to the number of decimal digits to be shown (3 for
+   * 1-10, 4 for 11-99 etc). One character width is added to this, to allow for
+   * half a character width space on either side.
    * 
    * @param fm
    * @return
@@ -476,13 +526,13 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       maxWidth = Math.max(maxWidth, alignment.getSequenceAt(i).getEnd());
     }
 
-    int length = 2;
+    int length = 0;
     for (int i = maxWidth; i > 0; i /= 10)
     {
       length++;
     }
 
-    return fm.stringWidth(ZEROS.substring(0, length));
+    return fm.stringWidth(ZEROS.substring(0, length)) + av.getCharWidth();
   }
 
   /**
@@ -500,8 +550,6 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   public void drawWrappedPanel(Graphics g, int canvasWidth,
           int canvasHeight, final int startColumn)
   {
-    updateViewport();
-
     int wrappedWidthInResidues = calculateWrappedGeometry(canvasWidth,
             canvasHeight);
 
@@ -510,24 +558,28 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     ViewportRanges ranges = av.getRanges();
     ranges.setViewportStartAndWidth(startColumn, wrappedWidthInResidues);
 
+    // we need to call this again to make sure the startColumn +
+    // wrappedWidthInResidues values are used to calculate wrappedVisibleWidths
+    // correctly.
+    calculateWrappedGeometry(canvasWidth, canvasHeight);
+
     /*
-     * draw one width at a time (including any scales or annotation shown),
+     * draw one width at a time (excluding any scales shown),
      * until we have run out of either alignment or vertical space available
      */
-    int yposMax = canvasHeight;
-    // ensure room for at least one sequence
-    yposMax -= wrappedSpaceAboveAlignment - charHeight;
     int ypos = wrappedSpaceAboveAlignment;
     int maxWidth = ranges.getVisibleAlignmentWidth();
 
     int start = startColumn;
-    while ((ypos <= yposMax) && (start < maxWidth))
+    int currentWidth = 0;
+    while ((currentWidth < wrappedVisibleWidths) && (start < maxWidth))
     {
       int endColumn = Math
               .min(maxWidth, start + wrappedWidthInResidues - 1);
       drawWrappedWidth(g, ypos, start, endColumn, canvasHeight);
       ypos += wrappedRepeatHeightPx;
       start += wrappedWidthInResidues;
+      currentWidth++;
     }
 
     drawWrappedDecorators(g, startColumn);
@@ -549,38 +601,38 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    */
   protected int calculateWrappedGeometry(int canvasWidth, int canvasHeight)
   {
-    /*
-     * width of labels in pixels left and right (if shown)
-     */
-    int labelWidth = 0;
-    if (av.getScaleRightWrapped() || av.getScaleLeftWrapped())
-    {
-      FontMetrics fm = getFontMetrics(av.getFont());
-      labelWidth = getLabelWidth(fm);
-    }
-    labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0;
-    labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0;
+    int charHeight = av.getCharHeight();
 
     /*
      * vertical space in pixels between wrapped widths of alignment
+     * - one character height, or two if scale above is drawn
      */
     wrappedSpaceAboveAlignment = charHeight
             * (av.getScaleAboveWrapped() ? 2 : 1);
 
     /*
-     * height in pixels of the wrapped widths
+     * compute height in pixels of the wrapped widths
+     * - start with space above plus sequences
      */
     wrappedRepeatHeightPx = wrappedSpaceAboveAlignment;
-    // add sequences
-    wrappedRepeatHeightPx += av.getRanges().getViewportHeight() * charHeight;
-    // add annotations panel height if shown
-    wrappedRepeatHeightPx += getAnnotationHeight();
+    wrappedRepeatHeightPx += av.getAlignment().getHeight()
+            * charHeight;
+
+    /*
+     * add annotations panel height if shown
+     * also gap between sequences and annotations
+     */
+    if (av.isShowAnnotation())
+    {
+      wrappedRepeatHeightPx += getAnnotationHeight();
+      wrappedRepeatHeightPx += SEQS_ANNOTATION_GAP; // 3px
+    }
 
     /*
-     * number of visible widths (the last one may be part height)
+     * number of visible widths (the last one may be part height),
+     * ensuring a part height includes at least one sequence
      */
     ViewportRanges ranges = av.getRanges();
-    int xMax = ranges.getVisibleAlignmentWidth();
     wrappedVisibleWidths = canvasHeight / wrappedRepeatHeightPx;
     int remainder = canvasHeight % wrappedRepeatHeightPx;
     if (remainder >= (wrappedSpaceAboveAlignment + charHeight))
@@ -589,21 +641,22 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     }
 
     /*
+     * compute width in residues; this also sets East and West label widths
+     */
+    int wrappedWidthInResidues = getWrappedCanvasWidth(canvasWidth);
+
+    /*
      *  limit visibleWidths to not exceed width of alignment
      */
-    int viewportWidth = ranges.getViewportWidth();
-    int maxWidths = (xMax - ranges.getStartRes()) / viewportWidth;
-    if (xMax % viewportWidth > 0)
+    int xMax = ranges.getVisibleAlignmentWidth();
+    int startToEnd = xMax - ranges.getStartRes();
+    int maxWidths = startToEnd / wrappedWidthInResidues;
+    if (startToEnd % wrappedWidthInResidues > 0)
     {
       maxWidths++;
     }
     wrappedVisibleWidths = Math.min(wrappedVisibleWidths, maxWidths);
 
-    /*
-     * number of whole width residue columns we can show in each row
-     */
-    int wrappedWidthInResidues = (canvasWidth - labelWidthEast - labelWidthWest)
-            / charWidth;
     return wrappedWidthInResidues;
   }
 
@@ -617,8 +670,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    * @param endColumn
    * @param canvasHeight
    */
-  protected void drawWrappedWidth(Graphics g, int ypos,
-          int startColumn, int endColumn, int canvasHeight)
+  protected void drawWrappedWidth(Graphics g, final int ypos,
+          final int startColumn, final int endColumn,
+          final int canvasHeight)
   {
     ViewportRanges ranges = av.getRanges();
     int viewportWidth = ranges.getViewportWidth();
@@ -630,6 +684,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
      * plus column offset from left margin (usually zero, but may be non-zero
      * when fast painting is drawing just a few columns)
      */
+    int charWidth = av.getCharWidth();
     int xOffset = labelWidthWest
             + ((startColumn - ranges.getStartRes()) % viewportWidth)
             * charWidth;
@@ -653,18 +708,19 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
      * white fill the region to be drawn (so incremental fast paint doesn't
      * scribble over an existing image)
      */
-    gg.setColor(Color.white);
-    gg.fillRect(0, ypos, (endx - startColumn + 1) * charWidth,
+    g.setColor(Color.white);
+    g.fillRect(0, ypos, (endx - startColumn + 1) * charWidth,
             wrappedRepeatHeightPx);
 
     drawPanel(g, startColumn, endx, 0, av.getAlignment().getHeight() - 1,
             ypos);
 
-    int cHeight = av.getAlignment().getHeight() * charHeight;
+    int cHeight = av.getAlignment().getHeight() * av.getCharHeight();
 
     if (av.isShowAnnotation())
     {
-      g.translate(0, cHeight + ypos + 3);
+      final int yShift = cHeight + ypos + SEQS_ANNOTATION_GAP;
+      g.translate(0, yShift);
       if (annotations == null)
       {
         annotations = new AnnotationPanel(av);
@@ -672,7 +728,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
       annotations.renderer.drawComponent(annotations, av, g, -1,
               startColumn, endx + 1);
-      g.translate(0, -cHeight - ypos - 3);
+      g.translate(0, -yShift);
     }
     g.setClip(clip);
     g.translate(-xOffset, 0);
@@ -685,8 +741,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    * @param g
    * @param startColumn
    */
-  protected void drawWrappedDecorators(Graphics g, int startColumn)
+  protected void drawWrappedDecorators(Graphics g, final int startColumn)
   {
+    int charWidth = av.getCharWidth();
+
     g.setFont(av.getFont());
     g.setColor(Color.black);
 
@@ -695,50 +753,60 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     int viewportWidth = ranges.getViewportWidth();
     int maxWidth = ranges.getVisibleAlignmentWidth();
     int widthsDrawn = 0;
+    int startCol = startColumn;
+
     while (widthsDrawn < wrappedVisibleWidths)
     {
-      int endColumn = Math.min(maxWidth, startColumn + viewportWidth - 1);
+      int endColumn = Math.min(maxWidth, startCol + viewportWidth - 1);
 
       if (av.getScaleLeftWrapped())
       {
-        drawVerticalScale(g, startColumn, endColumn - 1, ypos, true);
+        drawVerticalScale(g, startCol, endColumn - 1, ypos, true);
       }
 
       if (av.getScaleRightWrapped())
       {
-        drawVerticalScale(g, startColumn, endColumn, ypos, false);
+        int x = labelWidthWest + viewportWidth * charWidth;
+        g.translate(x, 0);
+        drawVerticalScale(g, startCol, endColumn, ypos, false);
+        g.translate(-x, 0);
       }
 
       /*
        * white fill region of scale above and hidden column markers
        * (to support incremental fast paint of image)
        */
+      g.translate(labelWidthWest, 0);
       g.setColor(Color.white);
       g.fillRect(0, ypos - wrappedSpaceAboveAlignment, viewportWidth
               * charWidth + labelWidthWest, wrappedSpaceAboveAlignment);
       g.setColor(Color.black);
+      g.translate(-labelWidthWest, 0);
 
       g.translate(labelWidthWest, 0);
 
       if (av.getScaleAboveWrapped())
       {
-        drawNorthScale(g, startColumn, endColumn, ypos);
+        drawNorthScale(g, startCol, endColumn, ypos);
       }
 
       if (av.hasHiddenColumns() && av.getShowHiddenMarkers())
       {
-        drawHiddenColumnMarkers(g, ypos, startColumn, endColumn);
+        drawHiddenColumnMarkers(g, ypos, startCol, endColumn);
       }
 
       g.translate(-labelWidthWest, 0);
 
       ypos += wrappedRepeatHeightPx;
-      startColumn += viewportWidth;
+      startCol += viewportWidth;
       widthsDrawn++;
     }
   }
 
   /**
+   * Draws markers (triangles) above hidden column positions between startColumn
+   * and endColumn.
+   * 
    * @param g
    * @param ypos
    * @param startColumn
@@ -747,14 +815,20 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   protected void drawHiddenColumnMarkers(Graphics g, int ypos,
           int startColumn, int endColumn)
   {
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
+
     g.setColor(Color.blue);
+    int res;
     HiddenColumns hidden = av.getAlignment().getHiddenColumns();
-    List<Integer> positions = hidden.findHiddenRegionPositions();
-    for (int pos : positions)
+
+    Iterator<Integer> it = hidden.getStartRegionIterator(startColumn,
+            endColumn);
+    while (it.hasNext())
     {
-      int res = pos - startColumn;
+      res = it.next() - startColumn;
 
-      if (res < 0 || res > endColumn - startColumn)
+      if (res < 0 || res > endColumn - startColumn + 1)
       {
         continue;
       }
@@ -768,10 +842,69 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
           xMiddle + charHeight / 4, xMiddle };
       int yTop = ypos - (charHeight / 2);
       int[] yPoints = new int[] { yTop, yTop, yTop + 8 };
-      gg.fillPolygon(xPoints, yPoints, 3);
+      g.fillPolygon(xPoints, yPoints, 3);
     }
   }
 
+  /*
+   * Draw a selection group over a wrapped alignment
+   */
+  private void drawWrappedSelection(Graphics2D g, SequenceGroup group,
+          int canvasWidth,
+          int canvasHeight, int startRes)
+  {
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
+      
+    // height gap above each panel
+    int hgap = charHeight;
+    if (av.getScaleAboveWrapped())
+    {
+      hgap += charHeight;
+    }
+
+    int cWidth = (canvasWidth - labelWidthEast - labelWidthWest)
+            / charWidth;
+    int cHeight = av.getAlignment().getHeight() * charHeight;
+
+    int startx = startRes;
+    int endx;
+    int ypos = hgap; // vertical offset
+    int maxwidth = av.getAlignment().getVisibleWidth();
+
+    // chop the wrapped alignment extent up into panel-sized blocks and treat
+    // each block as if it were a block from an unwrapped alignment
+    g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
+            BasicStroke.JOIN_ROUND, 3f, new float[]
+            { 5f, 3f }, 0f));
+    g.setColor(Color.RED);
+    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(labelWidthWest, 0);
+
+      drawUnwrappedSelection(g, group, startx, endx, 0,
+              av.getAlignment().getHeight() - 1,
+              ypos);
+
+      g.translate(-labelWidthWest, 0);
+
+      // update vertical offset
+      ypos += cHeight + getAnnotationHeight() + hgap;
+
+      // update horizontal offset
+      startx += cWidth;
+    }
+    g.setStroke(new BasicStroke());
+  }
+
   int getAnnotationHeight()
   {
     if (!av.isShowAnnotation())
@@ -809,7 +942,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   public void drawPanel(Graphics g1, final int startRes, final int endRes,
           final int startSeq, final int endSeq, final int yOffset)
   {
-    updateViewport();
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
+
     if (!av.hasHiddenColumns())
     {
       draw(g1, startRes, endRes, startSeq, endSeq, yOffset);
@@ -817,29 +952,23 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     else
     {
       int screenY = 0;
-      final int screenYMax = endRes - startRes;
-      int blockStart = startRes;
-      int blockEnd = endRes;
+      int blockStart;
+      int blockEnd;
 
-      for (int[] region : av.getAlignment().getHiddenColumns()
-              .getHiddenColumnsCopy())
-      {
-        int hideStart = region[0];
-        int hideEnd = region[1];
+      HiddenColumns hidden = av.getAlignment().getHiddenColumns();
+      VisibleContigsIterator regions = hidden
+              .getVisContigsIterator(startRes, endRes + 1, true);
 
-        if (hideStart <= blockStart)
-        {
-          blockStart += (hideEnd - hideStart) + 1;
-          continue;
-        }
+      while (regions.hasNext())
+      {
+        int[] region = regions.next();
+        blockEnd = region[1];
+        blockStart = region[0];
 
         /*
          * draw up to just before the next hidden region, or the end of
          * the visible region, whichever comes first
          */
-        blockEnd = Math.min(hideStart - 1, blockStart + screenYMax
-                - screenY);
-
         g1.translate(screenY * charWidth, 0);
 
         draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
@@ -848,7 +977,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
          * draw the downline of the hidden column marker (ScalePanel draws the
          * triangle on top) if we reached it
          */
-        if (av.getShowHiddenMarkers() && blockEnd == hideStart - 1)
+        if (av.getShowHiddenMarkers()
+                && (regions.hasNext() || regions.endsAtHidden()))
         {
           g1.setColor(Color.blue);
 
@@ -859,23 +989,6 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
         g1.translate(-screenY * charWidth, 0);
         screenY += blockEnd - blockStart + 1;
-        blockStart = hideEnd + 1;
-
-        if (screenY > screenYMax)
-        {
-          // already rendered last block
-          return;
-        }
-      }
-
-      if (screenY <= screenYMax)
-      {
-        // remaining visible region to render
-        blockEnd = blockStart + screenYMax - screenY;
-        g1.translate(screenY * charWidth, 0);
-        draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
-
-        g1.translate(-screenY * charWidth, 0);
       }
     }
 
@@ -899,8 +1012,11 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   private void draw(Graphics g, int startRes, int endRes, int startSeq,
           int endSeq, int offset)
   {
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
+
     g.setFont(av.getFont());
-    sr.prepare(g, av.isRenderGaps());
+    seqRdr.prepare(g, av.isRenderGaps());
 
     SequenceI nextSeq;
 
@@ -915,7 +1031,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         // empty
         continue;
       }
-      sr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
+      seqRdr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
               startRes, endRes, offset + ((i - startSeq) * charHeight));
 
       if (av.isShowSequenceFeatures())
@@ -930,26 +1046,19 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       if (av.hasSearchResults())
       {
         SearchResultsI searchResults = av.getSearchResults();
-        int[] visibleResults = searchResults.getResults(nextSeq,
-                startRes, endRes);
+        int[] visibleResults = searchResults.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) * charWidth,
                     offset + ((i - startSeq) * charHeight));
           }
         }
       }
-
-      if (av.cursorMode && cursorY == i && cursorX >= startRes
-              && cursorX <= endRes)
-      {
-        sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth,
-                offset + ((i - startSeq) * charHeight));
-      }
     }
 
     if (av.getSelectionGroup() != null
@@ -960,23 +1069,26 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   }
 
+  /**
+   * Draws the outlines of any groups defined on the alignment (excluding the
+   * current selection group, if any)
+   * 
+   * @param g1
+   * @param startRes
+   * @param endRes
+   * @param startSeq
+   * @param endSeq
+   * @param offset
+   */
   void drawGroupsBoundaries(Graphics g1, int startRes, int endRes,
           int startSeq, int endSeq, int offset)
   {
     Graphics2D g = (Graphics2D) g1;
-    //
-    // ///////////////////////////////////
-    // 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) * charWidth;
 
-    if ((group == null) && (av.getAlignment().getGroups().size() > 0))
+    if (av.getAlignment().getGroups().size() > 0)
     {
       group = av.getAlignment().getGroups().get(0);
       groupIndex = 0;
@@ -986,166 +1098,365 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     {
       do
       {
-        int oldY = -1;
-        int i = 0;
-        boolean inGroup = false;
-        int top = -1;
-        int bottom = -1;
+        g.setColor(group.getOutlineColour());
 
-        for (i = startSeq; i <= endSeq; i++)
-        {
-          sx = (group.getStartRes() - startRes) * charWidth;
-          sy = offset + ((i - startSeq) * charHeight);
-          ex = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth)
-                  - 1;
+        drawPartialGroupOutline(g, group, startRes, endRes, startSeq,
+                endSeq, offset);
 
-          if (sx + ex < 0 || sx > visWidth)
-          {
-            continue;
-          }
+        groupIndex++;
 
-          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 (groupIndex >= av.getAlignment().getGroups().size())
+        {
+          break;
+        }
 
-            if (!inGroup)
-            {
-              if (((top == -1) && (i == 0)) || !group.getSequences(null)
-                      .contains(av.getAlignment().getSequenceAt(i - 1)))
-              {
-                top = sy;
-              }
+        group = av.getAlignment().getGroups().get(groupIndex);
 
-              oldY = sy;
-              inGroup = true;
+      } while (groupIndex < av.getAlignment().getGroups().size());
 
-              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
-          {
-            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;
-              }
+  /**
+   * Draws the outline of the current selection group (if any)
+   * 
+   * @param g
+   * @param startRes
+   * @param endRes
+   * @param startSeq
+   * @param endSeq
+   */
+  private void drawSelectionGroup(Graphics2D g, int startRes, int endRes,
+          int startSeq, int endSeq)
+  {
+    SequenceGroup group = av.getSelectionGroup();
+    if (group == null)
+    {
+      return;
+    }
 
-              if (sx + ex > visWidth)
-              {
-                ex = visWidth;
-              }
+    g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
+            BasicStroke.JOIN_ROUND, 3f, new float[]
+            { 5f, 3f }, 0f));
+    g.setColor(Color.RED);
+    if (!av.getWrapAlignment())
+    {
+      drawUnwrappedSelection(g, group, startRes, endRes, startSeq, endSeq,
+              0);
+    }
+    else
+    {
+      drawWrappedSelection(g, group, getWidth(), getHeight(),
+              av.getRanges().getStartRes());
+    }
+    g.setStroke(new BasicStroke());
+  }
 
-              else if (sx + ex >= (endRes - startRes + 1) * charWidth)
-              {
-                ex = (endRes - startRes + 1) * charWidth;
-              }
+  /**
+   * Draw the cursor as a separate image and overlay
+   * 
+   * @param startRes
+   *          start residue of area to draw cursor in
+   * @param endRes
+   *          end residue of area to draw cursor in
+   * @param startSeq
+   *          start sequence of area to draw cursor in
+   * @param endSeq
+   *          end sequence of are to draw cursor in
+   * @return a transparent image of the same size as the sequence canvas, with
+   *         the cursor drawn on it, if any
+   */
+  private void drawCursor(Graphics g, int startRes, int endRes,
+          int startSeq,
+          int endSeq)
+  {
+    // convert the cursorY into a position on the visible alignment
+    int cursor_ypos = cursorY;
 
-              if (top != -1)
-              {
-                g.drawLine(sx, top, sx + ex, top);
-                top = -1;
-              }
+    // don't do work unless we have to
+    if (cursor_ypos >= startSeq && cursor_ypos <= endSeq)
+    {
+      int yoffset = 0;
+      int xoffset = 0;
+      int startx = startRes;
+      int endx = endRes;
 
-              if (bottom != -1)
-              {
-                g.drawLine(sx, bottom, sx + ex, bottom);
-                bottom = -1;
-              }
+      // convert the cursorX into a position on the visible alignment
+      int cursor_xpos = av.getAlignment().getHiddenColumns()
+              .absoluteToVisibleColumn(cursorX);
 
-              inGroup = false;
-            }
-          }
-        }
+      if (av.getAlignment().getHiddenColumns().isVisible(cursorX))
+      {
 
-        if (inGroup)
+        if (av.getWrapAlignment())
         {
-          sy = offset + ((i - startSeq) * charHeight);
-          if (sx >= 0 && sx < visWidth)
+          // work out the correct offsets for the cursor
+          int charHeight = av.getCharHeight();
+          int charWidth = av.getCharWidth();
+          int canvasWidth = getWidth();
+          int canvasHeight = getHeight();
+
+          // height gap above each panel
+          int hgap = charHeight;
+          if (av.getScaleAboveWrapped())
           {
-            g.drawLine(sx, oldY, sx, sy);
+            hgap += charHeight;
           }
 
-          if (sx + ex < visWidth)
-          {
-            g.drawLine(sx + ex, oldY, sx + ex, sy);
-          }
+          int cWidth = (canvasWidth - labelWidthEast - labelWidthWest)
+                  / charWidth;
+          int cHeight = av.getAlignment().getHeight() * charHeight;
 
-          if (sx < 0)
-          {
-            ex += sx;
-            sx = 0;
-          }
+          endx = startx + cWidth - 1;
+          int ypos = hgap; // vertical offset
 
-          if (sx + ex > visWidth)
-          {
-            ex = visWidth;
-          }
-          else if (sx + ex >= (endRes - startRes + 1) * charWidth)
+          // iterate down the wrapped panels
+          while ((ypos <= canvasHeight) && (endx < cursor_xpos))
           {
-            ex = (endRes - startRes + 1) * charWidth;
+            // update vertical offset
+            ypos += cHeight + getAnnotationHeight() + hgap;
+
+            // update horizontal offset
+            startx += cWidth;
+            endx = startx + cWidth - 1;
           }
+          yoffset = ypos;
+          xoffset = labelWidthWest;
+        }
+
+        // now check if cursor is within range for x values
+        if (cursor_xpos >= startx && cursor_xpos <= endx)
+        {
+          // get the character the cursor is drawn at
+          SequenceI seq = av.getAlignment().getSequenceAt(cursorY);
+          char s = seq.getCharAt(cursorX);
+
+          seqRdr.drawCursor(g, s,
+                  xoffset + (cursor_xpos - startx) * av.getCharWidth(),
+                  yoffset + (cursor_ypos - startSeq) * av.getCharHeight());
+        }
+      }
+    }
+  }
+
+
+  /**
+   * 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)
+  {
+    int charWidth = av.getCharWidth();
+          
+    if (!av.hasHiddenColumns())
+    {
+      drawPartialGroupOutline(g, group, startRes, endRes, startSeq, endSeq,
+              offset);
+    }
+    else
+    {
+      // package into blocks of visible columns
+      int screenY = 0;
+      int blockStart;
+      int blockEnd;
+
+      HiddenColumns hidden = av.getAlignment().getHiddenColumns();
+      VisibleContigsIterator regions = hidden
+              .getVisContigsIterator(startRes, endRes + 1, true);
+      while (regions.hasNext())
+      {
+        int[] region = regions.next();
+        blockEnd = region[1];
+        blockStart = region[0];
+
+        g.translate(screenY * charWidth, 0);
+        drawPartialGroupOutline(g, group,
+                blockStart, blockEnd, startSeq, endSeq, offset);
+
+        g.translate(-screenY * charWidth, 0);
+        screenY += blockEnd - blockStart + 1;
+      }
+    }
+  }
+
+  /**
+   * Draws part of a selection group outline
+   * 
+   * @param g
+   * @param group
+   * @param startRes
+   * @param endRes
+   * @param startSeq
+   * @param endSeq
+   * @param verticalOffset
+   */
+  private void drawPartialGroupOutline(Graphics2D g, SequenceGroup group,
+          int startRes, int endRes, int startSeq, int endSeq,
+          int verticalOffset)
+  {
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
+    int visWidth = (endRes - startRes + 1) * charWidth;
+
+    int oldY = -1;
+    int i = 0;
+    boolean inGroup = false;
+    int top = -1;
+    int bottom = -1;
+    int sy = -1;
 
-          if (top != -1)
+    List<SequenceI> seqs = group.getSequences(null);
+
+    // position of start residue of group relative to startRes, in pixels
+    int sx = (group.getStartRes() - startRes) * charWidth;
+
+    // width of group in pixels
+    int xwidth = (((group.getEndRes() + 1) - group.getStartRes())
+            * charWidth) - 1;
+
+    if (!(sx + xwidth < 0 || sx > visWidth))
+    {
+      for (i = startSeq; i <= endSeq; i++)
+      {
+        sy = verticalOffset + (i - startSeq) * charHeight;
+
+        if ((sx <= (endRes - startRes) * charWidth)
+                && seqs.contains(av.getAlignment().getSequenceAt(i)))
+        {
+          if ((bottom == -1)
+                  && !seqs.contains(av.getAlignment().getSequenceAt(i + 1)))
           {
-            g.drawLine(sx, top, sx + ex, top);
-            top = -1;
+            bottom = sy + charHeight;
           }
 
-          if (bottom != -1)
+          if (!inGroup)
           {
-            g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);
-            bottom = -1;
+            if (((top == -1) && (i == 0)) || !seqs
+                    .contains(av.getAlignment().getSequenceAt(i - 1)))
+            {
+              top = sy;
+            }
+
+            oldY = sy;
+            inGroup = true;
           }
+        }
+        else if (inGroup)
+        {
+          drawVerticals(g, sx, xwidth, visWidth, oldY, sy);
+          drawHorizontals(g, sx, xwidth, visWidth, top, bottom);
 
+          // reset top and bottom
+          top = -1;
+          bottom = -1;
           inGroup = false;
         }
+      }
+      if (inGroup)
+      {
+        sy = verticalOffset + ((i - startSeq) * charHeight);
+        drawVerticals(g, sx, xwidth, visWidth, oldY, sy);
+        drawHorizontals(g, sx, xwidth, visWidth, top, bottom);
+      }
+    }
+  }
 
-        groupIndex++;
-
-        g.setStroke(new BasicStroke());
+  /**
+   * Draw horizontal selection group boundaries at top and bottom positions
+   * 
+   * @param g
+   *          graphics object to draw on
+   * @param sx
+   *          start x position
+   * @param xwidth
+   *          width of gap
+   * @param visWidth
+   *          visWidth maximum available width
+   * @param top
+   *          position to draw top of group at
+   * @param bottom
+   *          position to draw bottom of group at
+   */
+  private void drawHorizontals(Graphics2D g, int sx, int xwidth,
+          int visWidth, int top, int bottom)
+  {
+    int width = xwidth;
+    int startx = sx;
+    if (startx < 0)
+    {
+      width += startx;
+      startx = 0;
+    }
 
-        if (groupIndex >= av.getAlignment().getGroups().size())
-        {
-          break;
-        }
+    // don't let width extend beyond current block, or group extent
+    // fixes JAL-2672
+    if (startx + width >= visWidth)
+    {
+      width = visWidth - startx;
+    }
 
-        group = av.getAlignment().getGroups().get(groupIndex);
+    if (top != -1)
+    {
+      g.drawLine(startx, top, startx + width, top);
+    }
 
-      } while (groupIndex < av.getAlignment().getGroups().size());
+    if (bottom != -1)
+    {
+      g.drawLine(startx, bottom - 1, startx + width, bottom - 1);
+    }
+  }
 
+  /**
+   * Draw vertical lines at sx and sx+xwidth providing they lie within
+   * [0,visWidth)
+   * 
+   * @param g
+   *          graphics object to draw on
+   * @param sx
+   *          start x position
+   * @param xwidth
+   *          width of gap
+   * @param visWidth
+   *          visWidth maximum available width
+   * @param oldY
+   *          top y value
+   * @param sy
+   *          bottom y value
+   */
+  private void drawVerticals(Graphics2D g, int sx, int xwidth, int visWidth,
+          int oldY, int sy)
+  {
+    // 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 + xwidth < visWidth)
+    {
+      g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
+    }
   }
-
+  
   /**
    * Highlights search results in the visible region by rendering as white text
    * on a black background. Any previous highlighting is removed. Answers true
@@ -1170,14 +1481,11 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       return false;
     }
     boolean wrapped = av.getWrapAlignment();
-
     try
     {
       fastPaint = !noFastPaint;
       fastpainting = fastPaint;
 
-      updateViewport();
-
       /*
        * to avoid redrawing the whole visible region, we instead
        * redraw just the minimal regions to remove previous highlights
@@ -1232,7 +1540,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    */
   protected boolean drawMappedPositions(SearchResultsI results)
   {
-    if (results == null)
+    if ((results == null) || (gg == null)) // JAL-2784 check gg is not null
     {
       return false;
     }
@@ -1254,9 +1562,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     if (av.hasHiddenColumns())
     {
       firstVisibleColumn = alignment.getHiddenColumns()
-              .adjustForHiddenColumns(firstVisibleColumn);
+              .visibleToAbsoluteColumn(firstVisibleColumn);
       lastVisibleColumn = alignment.getHiddenColumns()
-              .adjustForHiddenColumns(lastVisibleColumn);
+              .visibleToAbsoluteColumn(lastVisibleColumn);
     }
 
     for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
@@ -1299,8 +1607,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       if (av.hasHiddenColumns())
       {
         firstCol = alignment.getHiddenColumns()
-                .findColumnPosition(firstCol);
-        lastCol = alignment.getHiddenColumns().findColumnPosition(lastCol);
+                .absoluteToVisibleColumn(firstCol);
+        lastCol = alignment.getHiddenColumns().absoluteToVisibleColumn(lastCol);
       }
       int transX = (firstCol - ranges.getStartRes()) * av.getCharWidth();
       int transY = (firstSeq - ranges.getStartSeq()) * av.getCharHeight();
@@ -1317,14 +1625,37 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   {
     String eventName = evt.getPropertyName();
 
+    if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
+    {
+      fastPaint = true;
+      repaint();
+      return;
+    }
+    else if (eventName.equals(ViewportRanges.MOVE_VIEWPORT))
+    {
+      fastPaint = false;
+      repaint();
+      return;
+    }
+
     int scrollX = 0;
-    if (eventName.equals(ViewportRanges.STARTRES))
+    if (eventName.equals(ViewportRanges.STARTRES)
+            || eventName.equals(ViewportRanges.STARTRESANDSEQ))
     {
       // Make sure we're not trying to draw a panel
       // larger than the visible window
+      if (eventName.equals(ViewportRanges.STARTRES))
+      {
+        scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
+      }
+      else
+      {
+        scrollX = ((int[]) evt.getNewValue())[0]
+                - ((int[]) evt.getOldValue())[0];
+      }
       ViewportRanges vpRanges = av.getRanges();
-      scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
-      int range = vpRanges.getEndRes() - vpRanges.getStartRes();
+
+      int range = vpRanges.getEndRes() - vpRanges.getStartRes() + 1;
       if (scrollX > range)
       {
         scrollX = range;
@@ -1334,28 +1665,50 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         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
-      if (av.getWrapAlignment())
+      // 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))
       {
-        fastPaintWrapped(scrollX);
+    	  if (av.getWrapAlignment())
+          {
+            fastPaintWrapped(scrollX);
+          }
+          else
+          {
+            fastPaint(scrollX, 0);
+          }
       }
-      else
+      else if (eventName.equals(ViewportRanges.STARTSEQ))
       {
-        fastPaint(scrollX, 0);
+        // scroll
+        fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
       }
+      else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
+      {
+        if (av.getWrapAlignment())
+        {
+          fastPaintWrapped(scrollX);
+        }
+        else
+        {
+          fastPaint(scrollX, 0);
+        }
     }
     else if (eventName.equals(ViewportRanges.STARTSEQ))
     {
+      // scroll
       fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
     }
+    else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
+    {
+      if (av.getWrapAlignment())
+      {
+        fastPaintWrapped(scrollX);
+      }
+    }
   }
 
   /**
@@ -1371,10 +1724,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   {
     ViewportRanges ranges = av.getRanges();
 
-    if (Math.abs(scrollX) > ranges.getViewportWidth())
+    if (Math.abs(scrollX) >= ranges.getViewportWidth())
     {
       /*
-       * shift of more than one view width is 
+       * shift of one view width or more is 
        * overcomplicated to handle in this method
        */
       fastPaint = false;
@@ -1445,6 +1798,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
     ViewportRanges ranges = av.getRanges();
     int viewportWidth = ranges.getViewportWidth();
+    int charWidth = av.getCharWidth();
 
     /**
      * draw full height alignment in the second last row, last columns, if the
@@ -1478,6 +1832,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     }
 
     /*
+     * draw newly visible columns in last wrapped width (none if we
+     * have reached the end of the alignment)
      * y-offset for drawing last width is height of widths above,
      * plus one gap row
      */
@@ -1486,7 +1842,6 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
             + wrappedSpaceAboveAlignment;
     int endRes = ranges.getEndRes();
     endRes += widthsAbove * viewportWidth;
-    endRes = Math.min(endRes, ranges.getVisibleAlignmentWidth());
     int startRes = endRes - columns + 1;
 
     /*
@@ -1503,7 +1858,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     gg.setFont(av.getFont());
     gg.setColor(Color.black);
 
-    drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight);
+    if (startRes < ranges.getVisibleAlignmentWidth())
+    {
+      drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight);
+    }
 
     /*
      * and finally, white fill any space below the visible alignment
@@ -1530,6 +1888,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     {
       return;
     }
+    int charWidth = av.getCharWidth();
 
     int canvasHeight = getHeight();
     ViewportRanges ranges = av.getRanges();
@@ -1559,10 +1918,17 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
       while (y >= 0)
       {
+        /*
+         * shift 'widthToCopy' residues by 'positions' places to the right
+         */
         gg.copyArea(copyFromLeftStart, y, widthToCopy, heightToCopy,
                 positions * charWidth, 0);
         if (y > 0)
         {
+          /*
+           * copy 'positions' residue from the row above (right hand end)
+           * to this row's left hand end
+           */
           gg.copyArea(copyFromRightStart, y - wrappedRepeatHeightPx,
                   positions * charWidth, heightToCopy, -widthToCopy,
                   wrappedRepeatHeightPx);
@@ -1602,6 +1968,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     }
   }
 
+  
   /**
    * Redraws any positions in the search results in the visible region of a
    * wrapped alignment. Any highlights are drawn depending on the search results
@@ -1614,15 +1981,17 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    */
   protected boolean drawMappedPositionsWrapped(SearchResultsI results)
   {
-    if (results == null)
+    if ((results == null) || (gg == null)) // JAL-2784 check gg is not null
     {
       return false;
     }
-  
+    int charHeight = av.getCharHeight();
+
     boolean matchFound = false;
 
+    calculateWrappedGeometry(getWidth(), getHeight());
     int wrappedWidth = av.getWrappedWidth();
-    int wrappedHeight = getRepeatHeightWrapped();
+    int wrappedHeight = wrappedRepeatHeightPx;
 
     ViewportRanges ranges = av.getRanges();
     int canvasHeight = getHeight();
@@ -1640,9 +2009,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     if (av.hasHiddenColumns())
     {
       firstVisibleColumn = alignment.getHiddenColumns()
-              .adjustForHiddenColumns(firstVisibleColumn);
+              .visibleToAbsoluteColumn(firstVisibleColumn);
       lastVisibleColumn = alignment.getHiddenColumns()
-              .adjustForHiddenColumns(lastVisibleColumn);
+              .visibleToAbsoluteColumn(lastVisibleColumn);
     }
 
     int gapHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
@@ -1681,7 +2050,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
               if (av.hasHiddenColumns())
               {
                 displayColumn = alignment.getHiddenColumns()
-                        .findColumnPosition(displayColumn);
+                        .absoluteToVisibleColumn(displayColumn);
               }
 
               /*
@@ -1721,23 +2090,12 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   }
 
   /**
-   * Answers the height in pixels of a repeating section of the wrapped
-   * alignment, including space above, scale above if shown, sequences, and
-   * annotation panel if shown
+   * Answers the width in pixels of the left scale labels (0 if not shown)
    * 
    * @return
    */
-  protected int getRepeatHeightWrapped()
+  int getLabelWidthWest()
   {
-    // gap (and maybe scale) above
-    int repeatHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
-
-    // add sequences
-    repeatHeight += av.getRanges().getViewportHeight() * charHeight;
-
-    // add annotations panel height if shown
-    repeatHeight += getAnnotationHeight();
-
-    return repeatHeight;
+    return labelWidthWest;
   }
 }