Merge remote-tracking branch 'origin/bug/JAL-2722' into portforward/JAL-2675_2102b1to2103
[jalview.git] / src / jalview / gui / SeqCanvas.java
index 318d74d..191a7d8 100755 (executable)
@@ -53,9 +53,11 @@ import javax.swing.JComponent;
  */
 public class SeqCanvas extends JComponent implements ViewportListenerI
 {
+  private static String ZEROS = "0000000000";
+
   final FeatureRenderer fr;
 
-  final SequenceRenderer sr;
+  final SequenceRenderer seqRdr;
 
   BufferedImage img;
 
@@ -65,14 +67,22 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   boolean fastPaint = false;
 
-  int LABEL_WEST;
+  int labelWidthWest;
 
-  int LABEL_EAST;
+  int labelWidthEast;
 
   int cursorX = 0;
 
   int cursorY = 0;
 
+  int charHeight = 0;
+
+  int charWidth = 0;
+
+  boolean fastpainting = false;
+
+  AnnotationPanel annotations;
+
   /**
    * Creates a new SeqCanvas object.
    * 
@@ -84,7 +94,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     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);
@@ -94,7 +104,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   public SequenceRenderer getSequenceRenderer()
   {
-    return sr;
+    return seqRdr;
   }
 
   public FeatureRenderer getFeatureRenderer()
@@ -102,8 +112,6 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     return fr;
   }
 
-  int charHeight = 0, charWidth = 0;
-
   private void updateViewport()
   {
     charHeight = av.getCharHeight();
@@ -141,9 +149,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         {
           g.drawString(mstring, mpos * charWidth, ypos - (charHeight / 2));
         }
-        g.drawLine((mpos * charWidth) + (charWidth / 2), (ypos + 2)
-                - (charHeight / 2), (mpos * charWidth) + (charWidth / 2),
-                ypos - 2);
+        g.drawLine((mpos * charWidth) + (charWidth / 2),
+                (ypos + 2) - (charHeight / 2),
+                (mpos * charWidth) + (charWidth / 2), ypos - 2);
       }
     }
   }
@@ -203,10 +211,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
       if (value != -1)
       {
-        int x = LABEL_WEST - fm.stringWidth(String.valueOf(value))
+        int x = labelWidthWest - fm.stringWidth(String.valueOf(value))
                 - charWidth / 2;
-        g.drawString(value + "", x, (ypos + (i * charHeight))
-                - (charHeight / 5));
+        g.drawString(value + "", x,
+                (ypos + (i * charHeight)) - (charHeight / 5));
       }
     }
   }
@@ -257,13 +265,12 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
       if (value != -1)
       {
-        g.drawString(String.valueOf(value), 0, (ypos + (i * charHeight))
-                - (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
@@ -285,10 +292,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     updateViewport();
 
     ViewportRanges ranges = av.getRanges();
-    int sr = ranges.getStartRes();
-    int er = ranges.getEndRes();
-    int ss = ranges.getStartSeq();
-    int es = ranges.getEndSeq();
+    int startRes = ranges.getStartRes();
+    int endRes = ranges.getEndRes();
+    int startSeq = ranges.getStartSeq();
+    int endSeq = ranges.getEndSeq();
     int transX = 0;
     int transY = 0;
 
@@ -298,20 +305,20 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
     if (horizontal > 0) // scrollbar pulled right, image to the left
     {
-      transX = (er - sr - horizontal) * charWidth;
-      sr = er - horizontal;
+      transX = (endRes - startRes - horizontal) * charWidth;
+      startRes = endRes - horizontal;
     }
     else if (horizontal < 0)
     {
-      er = sr - horizontal;
+      endRes = startRes - horizontal;
     }
     else if (vertical > 0) // scroll down
     {
-      ss = es - vertical;
+      startSeq = endSeq - vertical;
 
-      if (ss < ranges.getStartSeq())
+      if (startSeq < ranges.getStartSeq())
       { // ie scrolling too fast, more than a page at a time
-        ss = ranges.getStartSeq();
+        startSeq = ranges.getStartSeq();
       }
       else
       {
@@ -320,32 +327,22 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     }
     else if (vertical < 0)
     {
-      es = ss - vertical;
+      endSeq = startSeq - vertical;
 
-      if (es > ranges.getEndSeq())
+      if (endSeq > ranges.getEndSeq())
       {
-        es = ranges.getEndSeq();
+        endSeq = ranges.getEndSeq();
       }
     }
 
     gg.translate(transX, transY);
-    drawPanel(gg, sr, er, ss, es, 0);
+    drawPanel(gg, startRes, endRes, startSeq, endSeq, 0);
     gg.translate(-transX, -transY);
 
     repaint();
     fastpainting = false;
   }
 
-  /**
-   * Definitions of startx and endx (hopefully): SMJS This is what I'm working
-   * towards! startx is the first residue (starting at 0) to display. endx is
-   * the last residue to display (starting at 0). starty is the first sequence
-   * to display (starting at 0). endy is the last sequence to display (starting
-   * at 0). NOTE 1: The av limits are set in setFont in this class and in the
-   * adjustment listener in SeqPanel when the scrollbars move.
-   */
-
-  // Set this to false to force a full panel paint
   @Override
   public void paintComponent(Graphics g)
   {
@@ -353,69 +350,142 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
     updateViewport();
 
-    // img is a cached version of the last view we drew
-    // selectImage will hold any selection we have
-    // lcimg is a local *copy* of img which we'll draw selectImage on top of
-
     ViewportRanges ranges = av.getRanges();
+
+    int width = getWidth();
+    int height = getHeight();
+
+    width -= (width % charWidth);
+    height -= (height % charHeight);
+
+    // selectImage is the selection group outline image
     BufferedImage selectImage = drawSelectionGroup(
-            av.getRanges().getStartRes(), av.getRanges().getEndRes(),
+            ranges.getStartRes(), ranges.getEndRes(),
             ranges.getStartSeq(), ranges.getEndSeq());
 
-    if (fastPaint || (getVisibleRect().width != g.getClipBounds().width)
-            || (getVisibleRect().height != g.getClipBounds().height))
+    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());
+      }
 
-    int width = getWidth();
-    int height = getHeight();
+      if (av.antiAlias)
+      {
+        gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                RenderingHints.VALUE_ANTIALIAS_ON);
+      }
 
-    width -= (width % charWidth);
-    height -= (height % charHeight);
+      gg.setColor(Color.white);
+      gg.fillRect(0, 0, img.getWidth(), img.getHeight());
 
-    if ((width < 1) || (height < 1))
-    {
-      return;
-    }
+      if (av.getWrapAlignment())
+      {
+        drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
+      }
+      else
+      {
+        drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
+                ranges.getStartSeq(), ranges.getEndSeq(), 0);
+      }
 
-    if (img == null || width != img.getWidth() || height != img.getHeight())
-    {
-      img = setupImage();
-      gg = (Graphics2D) img.getGraphics();
-      gg.setFont(av.getFont());
-    }
-    if (img == null)
-    {
-      return;
+      // 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 (av.antiAlias)
-    {
-      gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-              RenderingHints.VALUE_ANTIALIAS_ON);
-    }
-    
-    gg.setColor(Color.white);
-    gg.fillRect(0, 0, img.getWidth(), img.getHeight());
-    
-    if (av.getWrapAlignment())
+  /**
+   * 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);
+
+    BufferedImage selectImage = drawSelectionGroup(startRes, endRes,
+            startSeq, endSeq);
+    if (selectImage != null)
     {
-      drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
+      ((Graphics2D) g1).setComposite(AlphaComposite
+              .getInstance(AlphaComposite.SRC_OVER));
+      g1.drawImage(selectImage, 0, 0, this);
     }
-    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)
+  {
+    SequenceGroup group = av.getSelectionGroup();
+
+    drawWrappedPanel(g, canvasWidth, canvasHeight, startRes);
+
+    if (group != null)
     {
-      drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
-              ranges.getStartSeq(), ranges.getEndSeq(), 0);
+      BufferedImage selectImage = null;
+      try
+      {
+        selectImage = new BufferedImage(canvasWidth, canvasHeight,
+                BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
+      } catch (OutOfMemoryError er)
+      {
+        System.gc();
+        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();
+      }
     }
-
-    BufferedImage lcimg = buildLocalImage(selectImage);
-    g.drawImage(lcimg, 0, 0, this);
   }
 
   /*
@@ -442,12 +512,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     return lcimg;
   }
 
-  private void paintSeqGroup()
-  {
-    fastPaint = true;
-    repaint();
-  }
-
+  /*
+   * Set up a buffered image of the correct height and size for the sequence canvas
+   */
   private BufferedImage setupImage()
   {
     BufferedImage lcimg = null;
@@ -471,7 +538,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     {
       System.gc();
       System.err.println(
-              "Selection Group image OutOfMemory Redraw Error.\n" + er);
+              "Group image OutOfMemory Redraw Error.\n" + er);
       new OOMWarning("Creating alignment image for display", er);
 
       return null;
@@ -481,57 +548,63 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   }
 
   /**
-   * DOCUMENT ME!
+   * Returns the visible width of the canvas in residues, after allowing for
+   * East or West scales (if shown)
    * 
-   * @param cwidth
-   *          DOCUMENT ME!
+   * @param canvasWidth
+   *          the width in pixels (possibly including scales)
    * 
-   * @return DOCUMENT ME!
+   * @return
    */
-  public int getWrappedCanvasWidth(int cwidth)
+  public int getWrappedCanvasWidth(int canvasWidth)
   {
     FontMetrics fm = getFontMetrics(av.getFont());
 
-    LABEL_EAST = 0;
-    LABEL_WEST = 0;
+    labelWidthEast = 0;
+    labelWidthWest = 0;
 
     if (av.getScaleRightWrapped())
     {
-      LABEL_EAST = fm.stringWidth(getMask());
+      labelWidthEast = getLabelWidth(fm);
     }
 
     if (av.getScaleLeftWrapped())
     {
-      LABEL_WEST = fm.stringWidth(getMask());
+      labelWidthWest = labelWidthEast > 0 ? labelWidthEast
+              : getLabelWidth(fm);
     }
 
-    return (cwidth - LABEL_EAST - LABEL_WEST) / charWidth;
+    return (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
   }
 
   /**
-   * Generates a string of zeroes.
+   * 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).
    * 
-   * @return String
+   * @param fm
+   * @return
    */
-  String getMask()
+  protected int getLabelWidth(FontMetrics fm)
   {
-    String mask = "00";
+    /*
+     * find the biggest sequence end position we need to show
+     * (note this is not necessarily the sequence length)
+     */
     int maxWidth = 0;
-    int tmp;
-    for (int i = 0; i < av.getAlignment().getHeight(); i++)
+    AlignmentI alignment = av.getAlignment();
+    for (int i = 0; i < alignment.getHeight(); i++)
     {
-      tmp = av.getAlignment().getSequenceAt(i).getEnd();
-      if (tmp > maxWidth)
-      {
-        maxWidth = tmp;
-      }
+      maxWidth = Math.max(maxWidth, alignment.getSequenceAt(i).getEnd());
     }
 
+    int length = 2;
     for (int i = maxWidth; i > 0; i /= 10)
     {
-      mask += "0";
+      length++;
     }
-    return mask;
+
+    return fm.stringWidth(ZEROS.substring(0, length));
   }
 
   /**
@@ -546,26 +619,21 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    * @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());
-
-    LABEL_EAST = 0;
-    LABEL_WEST = 0;
-
-    if (av.getScaleRightWrapped())
+    int labelWidth = 0;
+    if (av.getScaleRightWrapped() || av.getScaleLeftWrapped())
     {
-      LABEL_EAST = fm.stringWidth(getMask());
+      FontMetrics fm = getFontMetrics(av.getFont());
+      labelWidth = getLabelWidth(fm);
     }
 
-    if (av.getScaleLeftWrapped())
-    {
-      LABEL_WEST = fm.stringWidth(getMask());
-    }
+    labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0;
+    labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0;
 
     int hgap = charHeight;
     if (av.getScaleAboveWrapped())
@@ -573,7 +641,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       hgap += charHeight;
     }
 
-    int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / charWidth;
+    int cWidth = (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
     int cHeight = av.getAlignment().getHeight() * charHeight;
 
     av.setWrappedWidth(cWidth);
@@ -590,6 +658,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
               .findColumnPosition(maxwidth);
     }
 
+    int annotationHeight = getAnnotationHeight();
+
     while ((ypos <= canvasHeight) && (startRes < maxwidth))
     {
       endx = startRes + cWidth - 1;
@@ -609,12 +679,12 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
       if (av.getScaleRightWrapped())
       {
-        g.translate(canvasWidth - LABEL_EAST, 0);
+        g.translate(canvasWidth - labelWidthEast, 0);
         drawEastScale(g, startRes, endx, ypos);
-        g.translate(-(canvasWidth - LABEL_EAST), 0);
+        g.translate(-(canvasWidth - labelWidthEast), 0);
       }
 
-      g.translate(LABEL_WEST, 0);
+      g.translate(labelWidthWest, 0);
 
       if (av.getScaleAboveWrapped())
       {
@@ -637,10 +707,12 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
           }
 
           gg.fillPolygon(
-                  new int[] { res * charWidth - charHeight / 4,
+                  new int[]
+                  { res * charWidth - charHeight / 4,
                       res * charWidth + charHeight / 4, res * charWidth },
-                  new int[] { ypos - (charHeight / 2),
-                      ypos - (charHeight / 2), ypos - (charHeight / 2) + 8 },
+                  new int[]
+                  { ypos - (charHeight / 2), ypos - (charHeight / 2),
+                      ypos - (charHeight / 2) + 8 },
                   3);
 
         }
@@ -670,20 +742,75 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
           annotations = new AnnotationPanel(av);
         }
 
-        annotations.renderer.drawComponent(annotations, av, g, -1,
-                startRes, endx + 1);
+        annotations.renderer.drawComponent(annotations, av, g, -1, startRes,
+                endx + 1);
         g.translate(0, -cHeight - ypos - 3);
       }
       g.setClip(clip);
-      g.translate(-LABEL_WEST, 0);
+      g.translate(-labelWidthWest, 0);
 
-      ypos += cHeight + getAnnotationHeight() + hgap;
+      ypos += cHeight + annotationHeight + hgap;
 
       startRes += cWidth;
     }
   }
 
-  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 - labelWidthEast - labelWidthWest)
+            / 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(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;
+    }
+  }
 
   int getAnnotationHeight()
   {
@@ -701,32 +828,36 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   }
 
   /**
-   * DOCUMENT ME!
+   * Draws the visible region of the alignment on the graphics context. If there
+   * are hidden column markers in the visible region, then each sub-region
+   * between the markers is drawn separately, followed by the hidden column
+   * marker.
    * 
    * @param g1
-   *          DOCUMENT ME!
+   *          Graphics object to draw with
    * @param startRes
-   *          DOCUMENT ME!
+   *          offset of the first column in the visible region (0..)
    * @param endRes
-   *          DOCUMENT ME!
+   *          offset of the last column in the visible region (0..)
    * @param startSeq
-   *          DOCUMENT ME!
+   *          offset of the first sequence in the visible region (0..)
    * @param endSeq
-   *          DOCUMENT ME!
-   * @param offset
-   *          DOCUMENT ME!
+   *          offset of the last sequence in the visible region (0..)
+   * @param yOffset
+   *          vertical offset at which to draw (for wrapped alignments)
    */
-  public void drawPanel(Graphics g1, int startRes, int endRes,
-          int startSeq, int endSeq, int offset)
+  public void drawPanel(Graphics g1, final int startRes, final int endRes,
+          final int startSeq, final int endSeq, final int yOffset)
   {
     updateViewport();
     if (!av.hasHiddenColumns())
     {
-      draw(g1, startRes, endRes, startSeq, endSeq, offset);
+      draw(g1, startRes, endRes, startSeq, endSeq, yOffset);
     }
     else
     {
       int screenY = 0;
+      final int screenYMax = endRes - startRes;
       int blockStart = startRes;
       int blockEnd = endRes;
 
@@ -742,38 +873,47 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
           continue;
         }
 
-        blockEnd = hideStart - 1;
+        /*
+         * 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, offset);
+        draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
 
-        if (av.getShowHiddenMarkers())
+        /*
+         * draw the downline of the hidden column marker (ScalePanel draws the
+         * triangle on top) if we reached it
+         */
+        if (av.getShowHiddenMarkers() && blockEnd == hideStart - 1)
         {
           g1.setColor(Color.blue);
 
           g1.drawLine((blockEnd - blockStart + 1) * charWidth - 1,
-                  0 + offset, (blockEnd - blockStart + 1) * charWidth - 1,
-                  (endSeq - startSeq + 1) * charHeight + offset);
+                  0 + yOffset, (blockEnd - blockStart + 1) * charWidth - 1,
+                  (endSeq - startSeq + 1) * charHeight + yOffset);
         }
 
         g1.translate(-screenY * charWidth, 0);
         screenY += blockEnd - blockStart + 1;
         blockStart = hideEnd + 1;
 
-        if (screenY > (endRes - startRes))
+        if (screenY > screenYMax)
         {
           // already rendered last block
           return;
         }
       }
 
-      if (screenY <= (endRes - startRes))
+      if (screenY <= screenYMax)
       {
         // remaining visible region to render
-        blockEnd = blockStart + (endRes - startRes) - screenY;
+        blockEnd = blockStart + screenYMax - screenY;
         g1.translate(screenY * charWidth, 0);
-        draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
+        draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
 
         g1.translate(-screenY * charWidth, 0);
       }
@@ -781,13 +921,26 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   }
 
-  // int startRes, int endRes, int startSeq, int endSeq, int x, int y,
-  // int x1, int x2, int y1, int y2, int startx, int starty,
+  /**
+   * Draws a region of the visible alignment
+   * 
+   * @param g1
+   * @param startRes
+   *          offset of the first column in the visible region (0..)
+   * @param endRes
+   *          offset of the last column in the visible region (0..)
+   * @param startSeq
+   *          offset of the first sequence in the visible region (0..)
+   * @param endSeq
+   *          offset of the last sequence in the visible region (0..)
+   * @param yOffset
+   *          vertical offset at which to draw (for wrapped alignments)
+   */
   private void draw(Graphics g, int startRes, int endRes, int startSeq,
           int endSeq, int offset)
   {
     g.setFont(av.getFont());
-    sr.prepare(g, av.isRenderGaps());
+    seqRdr.prepare(g, av.isRenderGaps());
 
     SequenceI nextSeq;
 
@@ -802,26 +955,28 @@ 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())
       {
-        fr.drawSequence(g, nextSeq, startRes, endRes, offset
-                + ((i - startSeq) * charHeight), false);
+        fr.drawSequence(g, nextSeq, startRes, endRes,
+                offset + ((i - startSeq) * charHeight), false);
       }
 
-      // / Highlight search Results once all sequences have been drawn
-      // ////////////////////////////////////////////////////////
+      /*
+       * highlight search Results once sequence has been drawn
+       */
       if (av.hasSearchResults())
       {
-        int[] visibleResults = av.getSearchResults().getResults(nextSeq,
+        SearchResultsI searchResults = av.getSearchResults();
+        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));
@@ -832,7 +987,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       if (av.cursorMode && cursorY == i && cursorX >= startRes
               && cursorX <= endRes)
       {
-        sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth,
+        seqRdr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth,
                 offset + ((i - startSeq) * charHeight));
       }
     }
@@ -855,12 +1010,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     // ///////////////////////////////////
 
     SequenceGroup group = null;
-
-    int sx = -1;
-    int sy = -1;
-    int ex = -1;
     int groupIndex = -1;
-    int visWidth = (endRes - startRes + 1) * charWidth;
 
     if (av.getAlignment().getGroups().size() > 0)
     {
@@ -870,149 +1020,13 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
     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;
-
-        for (i = startSeq; i <= endSeq; i++)
-        {
-          // position of start residue of group relative to startRes, in pixels
-          sx = (group.getStartRes() - startRes) * charWidth;
-          sy = offset + ((i - startSeq) * charHeight);
-          // width of group in pixels
-          ex = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth) - 1;
-
-          if (sx + ex < 0 || sx > visWidth)
-          {
-            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)))
-              {
-                top = sy;
-              }
-
-              oldY = sy;
-              inGroup = true;
-
-              g.setStroke(new BasicStroke());
-              g.setColor(group.getOutlineColour());
-            }
-          }
-          else
-          {
-            if (inGroup)
-            {
-              // if start position is visible, draw vertical line to left of
-              // group
-              if (sx >= 0 && sx < visWidth)
-              {
-                g.drawLine(sx, oldY, sx, sy);
-              }
-
-              // if end position is visible, draw vertical line to right of
-              // group
-              if (sx + ex < visWidth)
-              {
-                g.drawLine(sx + ex, oldY, sx + ex, sy);
-              }
-
-              if (sx < 0)
-              {
-                ex += sx;
-                sx = 0;
-              }
-
-              if (sx + ex > visWidth)
-              {
-                ex = visWidth;
-              }
-
-              else if (sx + ex >= (endRes - startRes + 1) * charWidth)
-              {
-                ex = (endRes - startRes + 1) * charWidth;
-              }
-
-              // draw horizontal line at top of group
-              if (top != -1)
-              {
-                g.drawLine(sx, top, sx + ex, top);
-                top = -1;
-              }
-
-              // draw horizontal line at bottom of group
-              if (bottom != -1)
-              {
-                g.drawLine(sx, bottom, sx + ex, bottom);
-                bottom = -1;
-              }
-
-              inGroup = false;
-            }
-          }
-        }
-
-        if (inGroup)
-        {
-          sy = offset + ((i - startSeq) * charHeight);
-          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) * charWidth)
-          {
-            ex = (endRes - startRes + 1) * charWidth;
-          }
-
-          if (top != -1)
-          {
-            g.drawLine(sx, top, sx + ex, top);
-            top = -1;
-          }
-
-          if (bottom != -1)
-          {
-            g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);
-            bottom = -1;
-          }
-
-          inGroup = false;
-        }
+        drawPartialGroupOutline(g, group, startRes, endRes, startSeq,
+                endSeq, offset);
 
         groupIndex++;
 
@@ -1052,30 +1066,66 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       // nothing to draw
       return null;
     }
-    
+
     // set up drawing colour
     Graphics2D g = (Graphics2D) selectionImage.getGraphics();
-    g.translate(LABEL_WEST, 0);
+
+    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())
     {
-      drawSelectionGroupPart(g, group, startRes, endRes, startSeq, endSeq);
+      drawPartialGroupOutline(g, group, startRes, endRes, startSeq, endSeq,
+              offset);
     }
     else
     {
       // package into blocks of visible columns
-      // Graphics2D g = (Graphics2D) selectionImage.getGraphics();
-      // Graphics g1 = selectionImage.getGraphics();
-
       int screenY = 0;
       int blockStart = startRes;
       int blockEnd = endRes;
@@ -1095,9 +1145,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         blockEnd = hideStart - 1;
 
         g.translate(screenY * charWidth, 0);
-
-        drawSelectionGroupPart(g, group,
-                blockStart, blockEnd, startSeq, endSeq);
+        drawPartialGroupOutline(g, group,
+                blockStart, blockEnd, startSeq, endSeq, offset);
 
         g.translate(-screenY * charWidth, 0);
         screenY += blockEnd - blockStart + 1;
@@ -1115,55 +1164,22 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         // remaining visible region to render
         blockEnd = blockStart + (endRes - startRes) - screenY;
         g.translate(screenY * charWidth, 0);
-        drawSelectionGroupPart(g, group,
-                blockStart, blockEnd, startSeq, endSeq);
-
+        drawPartialGroupOutline(g, group,
+                blockStart, blockEnd, startSeq, endSeq, offset);
+        
         g.translate(-screenY * charWidth, 0);
       }
     }
-    g.translate(-LABEL_WEST, 0);
-    return selectionImage;
   }
 
   /*
    * Draw the selection group as a separate image and overlay
    */
-  private void drawSelectionGroupPart(Graphics2D g, SequenceGroup group,
-          int startRes, int endRes, int startSeq, int endSeq)
+  private void drawPartialGroupOutline(Graphics2D g, SequenceGroup group,
+          int startRes, int endRes, int startSeq, int endSeq,
+          int verticalOffset)
   {
-    // set up values in case the alignment is wrapped
-    int verticalOffset = 0;
-    int horizontalOffset = 0;
-    if (av.getWrapAlignment())
-    {
-      int hgap = charHeight;
-      if (av.getScaleAboveWrapped())
-      {
-        hgap += charHeight;
-      }
-      
-      // get the start res of the group and work out the offsets for it in the wrapped alignment
-      int groupstart = group.getStartRes();
-      int cWidth = (getWidth() - LABEL_EAST - LABEL_WEST) / charWidth;
-      
-      // group is in which slice of alignment? res position / width in residues
-      int slice = groupstart / cWidth;
-      // vertical offset is increased by slice number * number of sequences * height of each sequence
-      verticalOffset = slice * (av.getAlignment().getHeight() * charHeight
-              + getAnnotationHeight() + hgap) + hgap;
-
-      // horizontal offset is number of residues to subtract from group residue
-      // position
-      horizontalOffset = (slice * cWidth);
-    }
-
-    int visWidth = av.getRanges().getViewportWidth() * charWidth;
-
-    // set x start and end positions of group
-    int startx = (group.getStartRes() - startRes - horizontalOffset)
-            * charWidth;
-    int endx = (group.getEndRes() - startRes + 1 - horizontalOffset)
-            * charWidth;
+    int visWidth = (endRes - startRes + 1) * charWidth;
 
     int oldY = -1;
     int i = 0;
@@ -1171,13 +1187,29 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     int top = -1;
     int bottom = -1;
 
-    // get sequences to determine y positions of group
-    for (i = startSeq; i <= endSeq; ++i)
+    int sx = -1;
+    int sy = -1;
+    int xwidth = -1;
+
+    for (i = startSeq; i <= endSeq; i++)
     {
-      int sy = verticalOffset + (i - startSeq) * charHeight;
+      // 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 (group.getSequences(null)
-              .contains(av.getAlignment().getSequenceAt(i)))
+      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)))
@@ -1203,34 +1235,42 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         {
           // if start position is visible, draw vertical line to left of
           // group
-          if (startx >= 0 && startx < visWidth * charWidth)
+          if (sx >= 0 && sx < visWidth)
           {
-            g.drawLine(startx, oldY, startx, sy);
+            g.drawLine(sx, oldY, sx, sy);
           }
 
           // if end position is visible, draw vertical line to right of
           // group
-          if (endx <= visWidth * charWidth)
+          if (sx + xwidth < visWidth)
           {
-            g.drawLine(endx, oldY, endx, sy);
+            g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
           }
 
-          if (endx > visWidth * charWidth)
+          if (sx < 0)
           {
-            endx = visWidth * charWidth;
+            xwidth += sx;
+            sx = 0;
           }
 
+          // don't let width extend beyond current block, or group extent
+          // fixes JAL-2672
+          if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
+          {
+            xwidth = (endRes - startRes + 1) * charWidth - sx;
+          }
+          
           // draw horizontal line at top of group
           if (top != -1)
           {
-            g.drawLine(startx, top, endx, top);
+            g.drawLine(sx, top, sx + xwidth, top);
             top = -1;
           }
 
           // draw horizontal line at bottom of group
           if (bottom != -1)
           {
-            g.drawLine(startx, bottom, endx, bottom);
+            g.drawLine(sx, bottom, sx + xwidth, bottom);
             bottom = -1;
           }
 
@@ -1238,53 +1278,215 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
         }
       }
     }
+
     if (inGroup)
     {
-      int sy = verticalOffset + (i - startSeq) * charHeight;
-      if (startx >= 0 && startx < visWidth)
+      sy = verticalOffset + ((i - startSeq) * charHeight);
+      if (sx >= 0 && sx < visWidth)
+      {
+        g.drawLine(sx, oldY, sx, sy);
+      }
+
+      if (sx + xwidth < visWidth)
       {
-        g.drawLine(startx, oldY, startx, sy);
+        g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
       }
 
-      if (endx < visWidth)
+      if (sx < 0)
       {
-        g.drawLine(endx, oldY, endx, sy);
+        xwidth += sx;
+        sx = 0;
       }
 
-      if (endx > visWidth)
+      if (sx + xwidth > visWidth)
+      {
+        xwidth = visWidth;
+      }
+      else if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
       {
-        endx = visWidth;
+        xwidth = (endRes - startRes + 1) * charWidth;
       }
 
       if (top != -1)
       {
-        g.drawLine(startx, top, endx, top);
+        g.drawLine(sx, top, sx + xwidth, top);
         top = -1;
       }
 
       if (bottom != -1)
       {
-        g.drawLine(startx, bottom - 1, endx, bottom - 1);
+        g.drawLine(sx, bottom - 1, sx + xwidth, bottom - 1);
         bottom = -1;
       }
 
       inGroup = false;
     }
   }
+  
+  /**
+   * Highlights search results in the visible region by rendering as white text
+   * on a black background. Any previous highlighting is removed. Answers true
+   * if any highlight was left on the visible alignment (so status bar should be
+   * set to match), else false.
+   * <p>
+   * Currently fastPaint is not implemented for wrapped alignments. If a wrapped
+   * alignment had to be scrolled to show the highlighted region, then it should
+   * be fully redrawn, otherwise a fast paint can be performed. This argument
+   * could be removed if fast paint of scrolled wrapped alignment is coded in
+   * future (JAL-2609).
+   * 
+   * @param results
+   * @param noFastPaint
+   * @return
+   */
+  public boolean highlightSearchResults(SearchResultsI results,
+          boolean noFastPaint)
+  {
+    if (fastpainting)
+    {
+      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
+       * and add new ones
+       */
+      SearchResultsI previous = av.getSearchResults();
+      av.setSearchResults(results);
+      boolean redrawn = false;
+      boolean drawn = false;
+      if (wrapped)
+      {
+        redrawn = drawMappedPositionsWrapped(previous);
+        drawn = drawMappedPositionsWrapped(results);
+        redrawn |= drawn;
+      }
+      else
+      {
+        redrawn = drawMappedPositions(previous);
+        drawn = drawMappedPositions(results);
+        redrawn |= drawn;
+      }
+
+      /*
+       * if highlights were either removed or added, repaint
+       */
+      if (redrawn)
+      {
+        repaint();
+      }
+
+      /*
+       * return true only if highlights were added
+       */
+      return drawn;
+
+    } finally
+    {
+      fastpainting = false;
+    }
+  }
 
   /**
-   * DOCUMENT ME!
+   * Redraws the minimal rectangle in the visible region (if any) that includes
+   * mapped positions of the given search results. Whether or not positions are
+   * highlighted depends on the SearchResults set on the Viewport. This allows
+   * this method to be called to either clear or set highlighting. Answers true
+   * if any positions were drawn (in which case a repaint is still required),
+   * else false.
    * 
    * @param results
-   *          DOCUMENT ME!
+   * @return
    */
-  public void highlightSearchResults(SearchResultsI results)
+  protected boolean drawMappedPositions(SearchResultsI results)
   {
-    img = null;
+    if (results == null)
+    {
+      return false;
+    }
 
-    av.setSearchResults(results);
+    /*
+     * calculate the minimal rectangle to redraw that 
+     * includes both new and existing search results
+     */
+    int firstSeq = Integer.MAX_VALUE;
+    int lastSeq = -1;
+    int firstCol = Integer.MAX_VALUE;
+    int lastCol = -1;
+    boolean matchFound = false;
 
-    repaint();
+    ViewportRanges ranges = av.getRanges();
+    int firstVisibleColumn = ranges.getStartRes();
+    int lastVisibleColumn = ranges.getEndRes();
+    AlignmentI alignment = av.getAlignment();
+    if (av.hasHiddenColumns())
+    {
+      firstVisibleColumn = alignment.getHiddenColumns()
+              .adjustForHiddenColumns(firstVisibleColumn);
+      lastVisibleColumn = alignment.getHiddenColumns()
+              .adjustForHiddenColumns(lastVisibleColumn);
+    }
+
+    for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
+            .getEndSeq(); seqNo++)
+    {
+      SequenceI seq = alignment.getSequenceAt(seqNo);
+
+      int[] visibleResults = results.getResults(seq, firstVisibleColumn,
+              lastVisibleColumn);
+      if (visibleResults != null)
+      {
+        for (int i = 0; i < visibleResults.length - 1; i += 2)
+        {
+          int firstMatchedColumn = visibleResults[i];
+          int lastMatchedColumn = visibleResults[i + 1];
+          if (firstMatchedColumn <= lastVisibleColumn
+                  && lastMatchedColumn >= firstVisibleColumn)
+          {
+            /*
+             * found a search results match in the visible region - 
+             * remember the first and last sequence matched, and the first
+             * and last visible columns in the matched positions
+             */
+            matchFound = true;
+            firstSeq = Math.min(firstSeq, seqNo);
+            lastSeq = Math.max(lastSeq, seqNo);
+            firstMatchedColumn = Math.max(firstMatchedColumn,
+                    firstVisibleColumn);
+            lastMatchedColumn = Math.min(lastMatchedColumn,
+                    lastVisibleColumn);
+            firstCol = Math.min(firstCol, firstMatchedColumn);
+            lastCol = Math.max(lastCol, lastMatchedColumn);
+          }
+        }
+      }
+    }
+
+    if (matchFound)
+    {
+      if (av.hasHiddenColumns())
+      {
+        firstCol = alignment.getHiddenColumns()
+                .findColumnPosition(firstCol);
+        lastCol = alignment.getHiddenColumns().findColumnPosition(lastCol);
+      }
+      int transX = (firstCol - ranges.getStartRes()) * av.getCharWidth();
+      int transY = (firstSeq - ranges.getStartSeq()) * av.getCharHeight();
+      gg.translate(transX, transY);
+      drawPanel(gg, firstCol, lastCol, firstSeq, lastSeq, 0);
+      gg.translate(-transX, -transY);
+    }
+
+    return matchFound;
   }
 
   @Override
@@ -1294,7 +1496,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
     if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
     {
-      paintSeqGroup();
+      fastPaint = true;
+      repaint();
     }
     else if (av.getWrapAlignment())
     {
@@ -1340,4 +1543,143 @@ 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
+   * set on the Viewport, not the <code>results</code> argument. This allows
+   * this method to be called either to clear highlights (passing the previous
+   * search results), or to draw new highlights.
+   * 
+   * @param results
+   * @return
+   */
+  protected boolean drawMappedPositionsWrapped(SearchResultsI results)
+  {
+    if (results == null)
+    {
+      return false;
+    }
+  
+    boolean matchFound = false;
+
+    int wrappedWidth = av.getWrappedWidth();
+    int wrappedHeight = getRepeatHeightWrapped();
+
+    ViewportRanges ranges = av.getRanges();
+    int canvasHeight = getHeight();
+    int repeats = canvasHeight / wrappedHeight;
+    if (canvasHeight / wrappedHeight > 0)
+    {
+      repeats++;
+    }
+
+    int firstVisibleColumn = ranges.getStartRes();
+    int lastVisibleColumn = ranges.getStartRes() + repeats
+            * ranges.getViewportWidth() - 1;
+
+    AlignmentI alignment = av.getAlignment();
+    if (av.hasHiddenColumns())
+    {
+      firstVisibleColumn = alignment.getHiddenColumns()
+              .adjustForHiddenColumns(firstVisibleColumn);
+      lastVisibleColumn = alignment.getHiddenColumns()
+              .adjustForHiddenColumns(lastVisibleColumn);
+    }
+
+    int gapHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
+
+    for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
+            .getEndSeq(); seqNo++)
+    {
+      SequenceI seq = alignment.getSequenceAt(seqNo);
+
+      int[] visibleResults = results.getResults(seq, firstVisibleColumn,
+              lastVisibleColumn);
+      if (visibleResults != null)
+      {
+        for (int i = 0; i < visibleResults.length - 1; i += 2)
+        {
+          int firstMatchedColumn = visibleResults[i];
+          int lastMatchedColumn = visibleResults[i + 1];
+          if (firstMatchedColumn <= lastVisibleColumn
+                  && lastMatchedColumn >= firstVisibleColumn)
+          {
+            /*
+             * found a search results match in the visible region
+             */
+            firstMatchedColumn = Math.max(firstMatchedColumn,
+                    firstVisibleColumn);
+            lastMatchedColumn = Math.min(lastMatchedColumn,
+                    lastVisibleColumn);
+
+            /*
+             * draw each mapped position separately (as contiguous positions may
+             * wrap across lines)
+             */
+            for (int mappedPos = firstMatchedColumn; mappedPos <= lastMatchedColumn; mappedPos++)
+            {
+              int displayColumn = mappedPos;
+              if (av.hasHiddenColumns())
+              {
+                displayColumn = alignment.getHiddenColumns()
+                        .findColumnPosition(displayColumn);
+              }
+
+              /*
+               * transX: offset from left edge of canvas to residue position
+               */
+              int transX = labelWidthWest
+                      + ((displayColumn - ranges.getStartRes()) % wrappedWidth)
+                      * av.getCharWidth();
+
+              /*
+               * transY: offset from top edge of canvas to residue position
+               */
+              int transY = gapHeight;
+              transY += (displayColumn - ranges.getStartRes())
+                      / wrappedWidth * wrappedHeight;
+              transY += (seqNo - ranges.getStartSeq()) * av.getCharHeight();
+
+              /*
+               * yOffset is from graphics origin to start of visible region
+               */
+              int yOffset = 0;// (displayColumn / wrappedWidth) * wrappedHeight;
+              if (transY < getHeight())
+              {
+                matchFound = true;
+                gg.translate(transX, transY);
+                drawPanel(gg, displayColumn, displayColumn, seqNo, seqNo,
+                        yOffset);
+                gg.translate(-transX, -transY);
+              }
+            }
+          }
+        }
+      }
+    }
+  
+    return matchFound;
+  }
+
+  /**
+   * 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
+   * 
+   * @return
+   */
+  protected int getRepeatHeightWrapped()
+  {
+    // 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;
+  }
 }