JAL-2690attemptedmerge partial merge
authorkiramt <k.mourao@dundee.ac.uk>
Tue, 10 Oct 2017 10:59:51 +0000 (11:59 +0100)
committerkiramt <k.mourao@dundee.ac.uk>
Tue, 10 Oct 2017 10:59:51 +0000 (11:59 +0100)
src/jalview/gui/SeqCanvas.java

index 4e896a0..8ad094f 100755 (executable)
@@ -27,10 +27,11 @@ import jalview.datamodel.SequenceGroup;
 import jalview.datamodel.SequenceI;
 import jalview.renderer.ScaleRenderer;
 import jalview.renderer.ScaleRenderer.ScaleMark;
+import jalview.util.Comparison;
 import jalview.viewmodel.ViewportListenerI;
 import jalview.viewmodel.ViewportRanges;
 
-import java.awt.AlphaComposite;
+import java.awt.AlphaComposite; // ok
 import java.awt.BasicStroke;
 import java.awt.BorderLayout;
 import java.awt.Color;
@@ -57,31 +58,40 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   final FeatureRenderer fr;
 
-  final SequenceRenderer seqRdr;
+  final SequenceRenderer seqRdr; //ok
 
   BufferedImage img;
 
   Graphics2D gg;
 
+  int imgWidth;
+
+  int imgHeight;
+
   AlignViewport av;
 
   boolean fastPaint = false;
 
-  int labelWidthWest;
-
-  int labelWidthEast;
+  boolean fastpainting = false;
 
   int cursorX = 0;
 
   int cursorY = 0;
 
-  int charHeight = 0;
+  private AnnotationPanel annotations;
 
-  int charWidth = 0;
+  /*
+   * measurements for drawing a wrapped alignment
+   */
+  int labelWidthWest; // label left width in pixels if shown
 
-  boolean fastpainting = false;
+  private int labelWidthEast; // label right width in pixels if shown
 
-  AnnotationPanel annotations;
+  private int wrappedSpaceAboveAlignment; // gap between widths
+
+  private int wrappedRepeatHeightPx; // height in pixels of wrapped width
+
+  private int wrappedVisibleWidths; // number of wrapped widths displayed
 
   /**
    * Creates a new SeqCanvas object.
@@ -92,9 +102,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   public SeqCanvas(AlignmentPanel ap)
   {
     this.av = ap.av;
-    updateViewport();
     fr = new FeatureRenderer(ap);
-    seqRdr = new SequenceRenderer(av);
+    seqRdr = new SequenceRenderer(av); //ok
     setLayout(new BorderLayout());
     PaintRefresher.Register(this, av.getSequenceSetId());
     setBackground(Color.white);
@@ -104,7 +113,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
 
   public SequenceRenderer getSequenceRenderer()
   {
-    return seqRdr;
+    return seqRdr; //ok
   }
 
   public FeatureRenderer getFeatureRenderer()
@@ -112,29 +121,36 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     return fr;
   }
 
-  private void updateViewport()
-  {
-    charHeight = av.getCharHeight();
-    charWidth = av.getCharWidth();
-  }
-
   /**
-   * DOCUMENT ME!
+   * Draws the scale above a region of a wrapped alignment, consisting of a
+   * column number every major interval (10 columns).
    * 
    * @param g
-   *          DOCUMENT ME!
+   *          the graphics context to draw on, positioned at the start (bottom
+   *          left) of the line on which to draw any scale marks
    * @param startx
-   *          DOCUMENT ME!
+   *          start alignment column (0..)
    * @param endx
-   *          DOCUMENT ME!
+   *          end alignment column (0..)
    * @param ypos
-   *          DOCUMENT ME!
+   *          y offset to draw at
    */
   private void drawNorthScale(Graphics g, int startx, int endx, int ypos)
   {
-    updateViewport();
-    for (ScaleMark mark : new ScaleRenderer().calculateMarks(av, startx,
-            endx))
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
+
+    /*
+     * white fill the scale space (for the fastPaint case)
+     */
+    g.setColor(Color.white);
+    g.fillRect(0, ypos - charHeight - charHeight / 2, getWidth(),
+            charHeight * 3 / 2 + 2);
+    g.setColor(Color.black);
+
+    List<ScaleMark> marks = new ScaleRenderer().calculateMarks(av, startx,
+            endx);
+    for (ScaleMark mark : marks)
     {
       int mpos = mark.column; // (i - startx - 1)
       if (mpos < 0)
@@ -149,155 +165,140 @@ 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);
+
+        /*
+         * draw a tick mark below the column number, centred on the column;
+         * height of tick mark is 4 pixels less than half a character
+         */
+        int xpos = (mpos * charWidth) + (charWidth / 2);
+        g.drawLine(xpos, (ypos + 2) - (charHeight / 2), xpos, ypos - 2);
       }
     }
   }
 
   /**
-   * DOCUMENT ME!
+   * Draw the scale to the left or right of a wrapped alignment
    * 
    * @param g
-   *          DOCUMENT ME!
+   *          graphics context, positioned at the start of the scale to be drawn
    * @param startx
-   *          DOCUMENT ME!
+   *          first column of wrapped width (0.. excluding any hidden columns)
    * @param endx
-   *          DOCUMENT ME!
+   *          last column of wrapped width (0.. excluding any hidden columns)
    * @param ypos
-   *          DOCUMENT ME!
+   *          vertical offset at which to begin the scale
+   * @param left
+   *          if true, scale is left of residues, if false, scale is right
    */
-  void drawWestScale(Graphics g, int startx, int endx, int ypos)
+  void drawVerticalScale(Graphics g, int startx, int endx, int ypos,
+          boolean left)
   {
-    FontMetrics fm = getFontMetrics(av.getFont());
-    ypos += charHeight;
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
 
-    if (av.hasHiddenColumns())
-    {
-      startx = av.getAlignment().getHiddenColumns()
-              .adjustForHiddenColumns(startx);
-      endx = av.getAlignment().getHiddenColumns()
-              .adjustForHiddenColumns(endx);
-    }
+    ypos += charHeight;
 
-    int maxwidth = av.getAlignment().getWidth();
     if (av.hasHiddenColumns())
     {
-      maxwidth = av.getAlignment().getHiddenColumns()
-              .findColumnPosition(maxwidth) - 1;
+      HiddenColumns hiddenColumns = av.getAlignment().getHiddenColumns();
+      startx = hiddenColumns.adjustForHiddenColumns(startx);
+      endx = hiddenColumns.adjustForHiddenColumns(endx);
     }
+    FontMetrics fm = getFontMetrics(av.getFont());
 
-    // WEST SCALE
     for (int i = 0; i < av.getAlignment().getHeight(); i++)
     {
       SequenceI seq = av.getAlignment().getSequenceAt(i);
-      int index = startx;
-      int value = -1;
 
-      while (index < endx)
+      /*
+       * 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 value = -1;
+      while (index >= startx && index <= endx)
       {
-        if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
+        if (!Comparison.isGap(seq.getCharAt(index)))
+        {
+          value = seq.findPosition(index);
+          break;
+        }
+        if (left)
         {
           index++;
-
-          continue;
         }
-
-        value = av.getAlignment().getSequenceAt(i).findPosition(index);
-
-        break;
-      }
-
-      if (value != -1)
-      {
-        int x = labelWidthWest - fm.stringWidth(String.valueOf(value))
-                - charWidth / 2;
-        g.drawString(value + "", x,
-                (ypos + (i * charHeight)) - (charHeight / 5));
-      }
-    }
-  }
-
-  /**
-   * DOCUMENT ME!
-   * 
-   * @param g
-   *          DOCUMENT ME!
-   * @param startx
-   *          DOCUMENT ME!
-   * @param endx
-   *          DOCUMENT ME!
-   * @param ypos
-   *          DOCUMENT ME!
-   */
-  void drawEastScale(Graphics g, int startx, int endx, int ypos)
-  {
-    ypos += charHeight;
-
-    if (av.hasHiddenColumns())
-    {
-      endx = av.getAlignment().getHiddenColumns()
-              .adjustForHiddenColumns(endx);
-    }
-
-    SequenceI seq;
-    // EAST SCALE
-    for (int i = 0; i < av.getAlignment().getHeight(); i++)
-    {
-      seq = av.getAlignment().getSequenceAt(i);
-      int index = endx;
-      int value = -1;
-
-      while (index > startx)
-      {
-        if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
+        else
         {
           index--;
-
-          continue;
         }
-
-        value = seq.findPosition(index);
-
-        break;
       }
 
+      /*
+       * white fill the space for the scale
+       */
+      g.setColor(Color.white);
+      int y = (ypos + (i * charHeight)) - (charHeight / 5);
+      // fillRect origin is top left of rectangle
+      g.fillRect(0, y - charHeight, left ? labelWidthWest : labelWidthEast,
+              charHeight + 1);
+
       if (value != -1)
       {
-        g.drawString(String.valueOf(value), 0,
-                (ypos + (i * charHeight)) - (charHeight / 5));
+
+        /*
+         * draw scale value, right justified, with half a character width
+         * separation from the sequence data
+         */
+        String valueAsString = String.valueOf(value);
+        int justify = fm.stringWidth(valueAsString) + charWidth;
+        int xpos = left ? labelWidthWest - justify + charWidth / 2
+                : labelWidthEast - justify + charWidth / 2;
+        g.setColor(Color.black);
+        g.drawString(valueAsString, xpos, y);
       }
     }
   }
 
-
+  //ok
   /**
-   * need to make this thread safe move alignment rendering in response to
-   * slider adjustment
+   * Does a fast paint of an alignment in response to a scroll. Most of the
+   * visible region is simply copied and shifted, and then any newly visible
+   * columns or rows are drawn. The scroll may be horizontal or vertical, but
+   * not both at once. Scrolling may be the result of
+   * <ul>
+   * <li>dragging a scroll bar</li>
+   * <li>clicking in the scroll bar</li>
+   * <li>scrolling by trackpad, middle mouse button, or other device</li>
+   * <li>by moving the box in the Overview window</li>
+   * <li>programmatically to make a highlighted position visible</li>
+   * </ul>
    * 
    * @param horizontal
-   *          shift along
+   *          columns to shift right (positive) or left (negative)
    * @param vertical
-   *          shift up or down in repaint
+   *          rows to shift down (positive) or up (negative)
    */
   public void fastPaint(int horizontal, int vertical)
   {
-    if (fastpainting || gg == null || img == null)
+    if (fastpainting || gg == null || img == null) //ok
     {
       return;
     }
     fastpainting = true;
     fastPaint = true;
-    updateViewport();
 
-    ViewportRanges ranges = av.getRanges();
-    int startRes = ranges.getStartRes();
-    int endRes = ranges.getEndRes();
-    int startSeq = ranges.getStartSeq();
-    int endSeq = ranges.getEndSeq();
-    int transX = 0;
-    int transY = 0;
+    try
+    {
+      int charHeight = av.getCharHeight();
+      int charWidth = av.getCharWidth();
+    
+      ViewportRanges ranges = av.getRanges();
+      int startRes = ranges.getStartRes();
+      int endRes = ranges.getEndRes();
+      int startSeq = ranges.getStartSeq();
+      int endSeq = ranges.getEndSeq();
+      int transX = 0;
+      int transY = 0;
 
     gg.copyArea(horizontal * charWidth, vertical * charHeight,
             img.getWidth(), img.getHeight(), -horizontal * charWidth,
@@ -340,15 +341,21 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     gg.translate(-transX, -transY);
 
     repaint();
-    fastpainting = false;
+    } finally
+    {
+      fastpainting = false;
+    }
   }
+  //ok
 
+  //ok
   @Override
   public void paintComponent(Graphics g)
   {
-    super.paintComponent(g);
-
-    updateViewport();
+    super.paintComponent(g);    
+    
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
 
     ViewportRanges ranges = av.getRanges();
 
@@ -411,7 +418,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       g.drawImage(lcimg, 0, 0, this);
     }
   }
-
+//ok
+  
   /**
    * Draw an alignment panel for printing
    * 
@@ -558,6 +566,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    */
   public int getWrappedCanvasWidth(int canvasWidth)
   {
+    int charWidth = av.getCharWidth();
+
     FontMetrics fm = getFontMetrics(av.getFont());
 
     labelWidthEast = 0;
@@ -608,150 +618,306 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   }
 
   /**
-   * DOCUMENT ME!
+   * Draws as many widths of a wrapped alignment as can fit in the visible
+   * window
    * 
    * @param g
-   *          DOCUMENT ME!
    * @param canvasWidth
-   *          DOCUMENT ME!
+   *          available width in pixels
    * @param canvasHeight
-   *          DOCUMENT ME!
-   * @param startRes
-   *          DOCUMENT ME!
+   *          available height in pixels
+   * @param startColumn
+   *          the first column (0...) of the alignment to draw
    */
-  private void drawWrappedPanel(Graphics g, int canvasWidth,
-          int canvasHeight, int startRes)
+  public void drawWrappedPanel(Graphics g, int canvasWidth,
+          int canvasHeight, final int startColumn)
+  {
+    int wrappedWidthInResidues = calculateWrappedGeometry(canvasWidth,
+            canvasHeight);
+
+    av.setWrappedWidth(wrappedWidthInResidues);
+
+    ViewportRanges ranges = av.getRanges();
+    ranges.setViewportStartAndWidth(startColumn, wrappedWidthInResidues);
+
+    /*
+     * draw one width at a time (including any scales or annotation shown),
+     * until we have run out of either alignment or vertical space available
+     */
+    int ypos = wrappedSpaceAboveAlignment;
+    int maxWidth = ranges.getVisibleAlignmentWidth();
+
+    int start = startColumn;
+    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);
+  }
+
+  /**
+   * Calculates and saves values needed when rendering a wrapped alignment.
+   * These depend on many factors, including
+   * <ul>
+   * <li>canvas width and height</li>
+   * <li>number of visible sequences, and height of annotations if shown</li>
+   * <li>font and character width</li>
+   * <li>whether scales are shown left, right or above the alignment</li>
+   * </ul>
+   * 
+   * @param canvasWidth
+   * @param canvasHeight
+   * @return the number of residue columns in each width
+   */
+  protected int calculateWrappedGeometry(int canvasWidth, int canvasHeight)
   {
-    updateViewport();
-    AlignmentI al = av.getAlignment();
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
 
+    /*
+     * 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 hgap = charHeight;
-    if (av.getScaleAboveWrapped())
+    /*
+     * 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
+     */
+    wrappedRepeatHeightPx = wrappedSpaceAboveAlignment;
+    // add sequences
+    wrappedRepeatHeightPx += av.getRanges().getViewportHeight()
+            * charHeight;
+    // add annotations panel height if shown
+    wrappedRepeatHeightPx += getAnnotationHeight();
+
+    /*
+     * number of residue columns we can show in each row;
+     * this is just canvas width less scale left and right (if shown), 
+     * as a whole multiple of character widths 
+     */
+    int wrappedWidthInResidues = (canvasWidth - labelWidthEast
+            - labelWidthWest) / charWidth;
+
+    /*
+     * 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))
     {
-      hgap += charHeight;
+      wrappedVisibleWidths++;
     }
 
-    int cWidth = (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
-    int cHeight = av.getAlignment().getHeight() * charHeight;
+    /*
+     *  limit visibleWidths to not exceed width of alignment
+     */
+    int maxWidths = (xMax - ranges.getStartRes()) / wrappedWidthInResidues;
+    if (xMax % wrappedWidthInResidues > 0)
+    {
+      maxWidths++;
+    }
+    wrappedVisibleWidths = Math.min(wrappedVisibleWidths, maxWidths);
+
+    return wrappedWidthInResidues;
+  }
+
+  /**
+   * Draws one width of a wrapped alignment, including sequences and
+   * annnotations, if shown, but not scales or hidden column markers
+   * 
+   * @param g
+   * @param ypos
+   * @param startColumn
+   * @param endColumn
+   * @param canvasHeight
+   */
+  protected void drawWrappedWidth(Graphics g, int ypos, int startColumn,
+          int endColumn, int canvasHeight)
+  {
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
 
-    av.setWrappedWidth(cWidth);
+    ViewportRanges ranges = av.getRanges();
+    int viewportWidth = ranges.getViewportWidth();
 
-    av.getRanges().setViewportStartAndWidth(startRes, cWidth);
+    int endx = Math.min(startColumn + viewportWidth - 1, endColumn);
 
-    int endx;
-    int ypos = hgap;
-    int maxwidth = av.getAlignment().getWidth();
+    /*
+     * move right before drawing by the width of the scale left (if any)
+     * plus column offset from left margin (usually zero, but may be non-zero
+     * when fast painting is drawing just a few columns)
+     */
+    int xOffset = labelWidthWest
+            + ((startColumn - ranges.getStartRes()) % viewportWidth)
+                    * charWidth;
+    g.translate(xOffset, 0);
 
-    if (av.hasHiddenColumns())
+    // When printing we have an extra clipped region,
+    // the Printable page which we need to account for here
+    Shape clip = g.getClip();
+
+    if (clip == null)
     {
-      maxwidth = av.getAlignment().getHiddenColumns()
-              .findColumnPosition(maxwidth);
+      g.setClip(0, 0, viewportWidth * charWidth, canvasHeight);
+    }
+    else
+    {
+      g.setClip(0, (int) clip.getBounds().getY(), viewportWidth * charWidth,
+              (int) clip.getBounds().getHeight());
     }
 
-    int annotationHeight = getAnnotationHeight();
+    /*
+     * 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,
+            wrappedRepeatHeightPx);
 
-    while ((ypos <= canvasHeight) && (startRes < maxwidth))
-    {
-      endx = startRes + cWidth - 1;
+    drawPanel(g, startColumn, endx, 0, av.getAlignment().getHeight() - 1,
+            ypos);
 
-      if (endx > maxwidth)
+    int cHeight = av.getAlignment().getHeight() * charHeight;
+
+    if (av.isShowAnnotation())
+    {
+      g.translate(0, cHeight + ypos + 3);
+      if (annotations == null)
       {
-        endx = maxwidth;
+        annotations = new AnnotationPanel(av);
       }
 
-      g.setFont(av.getFont());
-      g.setColor(Color.black);
+      annotations.renderer.drawComponent(annotations, av, g, -1,
+              startColumn, endx + 1);
+      g.translate(0, -cHeight - ypos - 3);
+    }
+    g.setClip(clip);
+    g.translate(-xOffset, 0);
+  }
+
+  /**
+   * Draws scales left, right and above (if shown), and any hidden column
+   * markers, on all widths of the wrapped alignment
+   * 
+   * @param g
+   * @param startColumn
+   */
+  protected void drawWrappedDecorators(Graphics g, int startColumn)
+  {
+    int charWidth = av.getCharWidth();
+
+    g.setFont(av.getFont());
+    g.setColor(Color.black);
+
+    int ypos = wrappedSpaceAboveAlignment;
+    ViewportRanges ranges = av.getRanges();
+    int viewportWidth = ranges.getViewportWidth();
+    int maxWidth = ranges.getVisibleAlignmentWidth();
+    int widthsDrawn = 0;
+    while (widthsDrawn < wrappedVisibleWidths)
+    {
+      int endColumn = Math.min(maxWidth, startColumn + viewportWidth - 1);
 
       if (av.getScaleLeftWrapped())
       {
-        drawWestScale(g, startRes, endx, ypos);
+        drawVerticalScale(g, startColumn, endColumn - 1, ypos, true);
       }
 
       if (av.getScaleRightWrapped())
       {
-        g.translate(canvasWidth - labelWidthEast, 0);
-        drawEastScale(g, startRes, endx, ypos);
-        g.translate(-(canvasWidth - labelWidthEast), 0);
+        int x = labelWidthWest + viewportWidth * charWidth;
+        g.translate(x, 0);
+        drawVerticalScale(g, startColumn, 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.setColor(Color.white);
+      g.fillRect(0, ypos - wrappedSpaceAboveAlignment,
+              viewportWidth * charWidth + labelWidthWest,
+              wrappedSpaceAboveAlignment);
+      g.setColor(Color.black);
+
       g.translate(labelWidthWest, 0);
 
       if (av.getScaleAboveWrapped())
       {
-        drawNorthScale(g, startRes, endx, ypos);
+        drawNorthScale(g, startColumn, endColumn, ypos);
       }
 
       if (av.hasHiddenColumns() && av.getShowHiddenMarkers())
       {
-        g.setColor(Color.blue);
-        int res;
-        HiddenColumns hidden = av.getAlignment().getHiddenColumns();
-        List<Integer> positions = hidden.findHiddenRegionPositions();
-        for (int pos : positions)
-        {
-          res = pos - startRes;
-
-          if (res < 0 || res > endx - startRes)
-          {
-            continue;
-          }
-
-          gg.fillPolygon(
-                  new int[]
-                  { res * charWidth - charHeight / 4,
-                      res * charWidth + charHeight / 4, res * charWidth },
-                  new int[]
-                  { ypos - (charHeight / 2), ypos - (charHeight / 2),
-                      ypos - (charHeight / 2) + 8 },
-                  3);
-
-        }
+        drawHiddenColumnMarkers(g, ypos, startColumn, endColumn);
       }
 
-      // When printing we have an extra clipped region,
-      // the Printable page which we need to account for here
-      Shape clip = g.getClip();
+      g.translate(-labelWidthWest, 0);
+
+      ypos += wrappedRepeatHeightPx;
+      startColumn += viewportWidth;
+      widthsDrawn++;
+    }
+  }
 
-      if (clip == null)
-      {
-        g.setClip(0, 0, cWidth * charWidth, canvasHeight);
-      }
-      else
-      {
-        g.setClip(0, (int) clip.getBounds().getY(), cWidth * charWidth,
-                (int) clip.getBounds().getHeight());
-      }
+  /**
+   * @param g
+   * @param ypos
+   * @param startColumn
+   * @param endColumn
+   */
+  protected void drawHiddenColumnMarkers(Graphics g, int ypos,
+          int startColumn, int endColumn)
+  {
+    int charHeight = av.getCharHeight();
+    int charWidth = av.getCharWidth();
 
-      drawPanel(g, startRes, endx, 0, al.getHeight() - 1, ypos);
+    g.setColor(Color.blue);
+    HiddenColumns hidden = av.getAlignment().getHiddenColumns();
+    List<Integer> positions = hidden.findHiddenRegionPositions();
+    for (int pos : positions)
+    {
+      int res = pos - startColumn;
 
-      if (av.isShowAnnotation())
+      if (res < 0 || res > endColumn - startColumn)
       {
-        g.translate(0, cHeight + ypos + 3);
-        if (annotations == null)
-        {
-          annotations = new AnnotationPanel(av);
-        }
-
-        annotations.renderer.drawComponent(annotations, av, g, -1, startRes,
-                endx + 1);
-        g.translate(0, -cHeight - ypos - 3);
+        continue;
       }
-      g.setClip(clip);
-      g.translate(-labelWidthWest, 0);
-
-      ypos += cHeight + annotationHeight + hgap;
 
-      startRes += cWidth;
+      /*
+       * draw a downward-pointing triangle at the hidden columns location
+       * (before the following visible column)
+       */
+      int xMiddle = res * charWidth;
+      int[] xPoints = new int[] { xMiddle - charHeight / 4,
+          xMiddle + charHeight / 4, xMiddle };
+      int yTop = ypos - (charHeight / 2);
+      int[] yPoints = new int[] { yTop, yTop, yTop + 8 };
+      g.fillPolygon(xPoints, yPoints, 3);
     }
   }
 
@@ -834,22 +1000,24 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
    * marker.
    * 
    * @param g1
-   *          Graphics object to draw with
+   *          the graphics context, positioned at the first residue to be drawn
    * @param startRes
-   *          offset of the first column in the visible region (0..)
+   *          offset of the first column to draw (0..)
    * @param endRes
-   *          offset of the last column in the visible region (0..)
+   *          offset of the last column to draw (0..)
    * @param startSeq
-   *          offset of the first sequence in the visible region (0..)
+   *          offset of the first sequence to draw (0..)
    * @param endSeq
-   *          offset of the last sequence in the visible region (0..)
+   *          offset of the last sequence to draw (0..)
    * @param yOffset
    *          vertical offset at which to draw (for wrapped alignments)
    */
   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);
@@ -939,6 +1107,9 @@ 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());
     seqRdr.prepare(g, av.isRenderGaps());
 
@@ -1118,6 +1289,8 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   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,
@@ -1179,6 +1352,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
           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;
@@ -1347,14 +1523,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
@@ -1499,14 +1672,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
       fastPaint = true;
       repaint();
     }
-    else if (av.getWrapAlignment())
-    {
-      if (eventName.equals(ViewportRanges.STARTRES))
-      {
-        repaint();
-      }
-    }
-    else
+    else if (eventName.equals(ViewportRanges.STARTRES))
     {
       int scrollX = 0;
       if (eventName.equals(ViewportRanges.STARTRES))
@@ -1524,17 +1690,22 @@ 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))
-      {
+        // 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.
+        
         // scroll - startres and endres both change
-        fastPaint(scrollX, 0);
+         if (av.getWrapAlignment())
+        {
+          fastPaintWrapped(scrollX);
+        }
+        else
+        {
+          fastPaint(scrollX, 0);
+        }
       }
       else if (eventName.equals(ViewportRanges.STARTSEQ))
       {
@@ -1545,6 +1716,257 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   }
 
   /**
+   * Does a minimal update of the image for a scroll movement. This method
+   * handles scroll movements of up to one width of the wrapped alignment (one
+   * click in the vertical scrollbar). Larger movements (for example after a
+   * scroll to highlight a mapped position) trigger a full redraw instead.
+   * 
+   * @param scrollX
+   *          number of positions scrolled (right if positive, left if negative)
+   */
+  protected void fastPaintWrapped(int scrollX)
+  {
+    ViewportRanges ranges = av.getRanges();
+
+    if (Math.abs(scrollX) > ranges.getViewportWidth())
+    {
+      /*
+       * shift of more than one view width is 
+       * overcomplicated to handle in this method
+       */
+      fastPaint = false;
+      repaint();
+      return;
+    }
+
+    if (fastpainting || gg == null)
+    {
+      return;
+    }
+
+    fastPaint = true;
+    fastpainting = true;
+
+    try
+    {
+      calculateWrappedGeometry(getWidth(), getHeight());
+
+      /*
+       * relocate the regions of the alignment that are still visible
+       */
+      shiftWrappedAlignment(-scrollX);
+
+      /*
+       * add new columns (sequence, annotation)
+       * - at top left if scrollX < 0 
+       * - at right of last two widths if scrollX > 0
+       */
+      if (scrollX < 0)
+      {
+        int startRes = ranges.getStartRes();
+        drawWrappedWidth(gg, wrappedSpaceAboveAlignment, startRes, startRes
+                - scrollX - 1, getHeight());
+      }
+      else
+      {
+        fastPaintWrappedAddRight(scrollX);
+      }
+
+      /*
+       * draw all scales (if  shown) and hidden column markers
+       */
+      drawWrappedDecorators(gg, ranges.getStartRes());
+
+      repaint();
+    } finally
+    {
+      fastpainting = false;
+    }
+  }
+
+  /**
+   * Draws the specified number of columns at the 'end' (bottom right) of a
+   * wrapped alignment view, including sequences and annotations if shown, but
+   * not scales. Also draws the same number of columns at the right hand end of
+   * the second last width shown, if the last width is not full height (so
+   * cannot simply be copied from the graphics image).
+   * 
+   * @param columns
+   */
+  protected void fastPaintWrappedAddRight(int columns)
+  {
+    if (columns == 0)
+    {
+      return;
+    }
+
+    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
+     * last row was not full height
+     */
+    int visibleWidths = wrappedVisibleWidths;
+    int canvasHeight = getHeight();
+    boolean lastWidthPartHeight = (wrappedVisibleWidths * wrappedRepeatHeightPx) > canvasHeight;
+
+    if (lastWidthPartHeight)
+    {
+      int widthsAbove = Math.max(0, visibleWidths - 2);
+      int ypos = wrappedRepeatHeightPx * widthsAbove
+              + wrappedSpaceAboveAlignment;
+      int endRes = ranges.getEndRes();
+      endRes += widthsAbove * viewportWidth;
+      int startRes = endRes - columns;
+      int xOffset = ((startRes - ranges.getStartRes()) % viewportWidth)
+              * charWidth;
+
+      /*
+       * white fill first to erase annotations
+       */
+      gg.translate(xOffset, 0);
+      gg.setColor(Color.white);
+      gg.fillRect(labelWidthWest, ypos,
+              (endRes - startRes + 1) * charWidth, wrappedRepeatHeightPx);
+      gg.translate(-xOffset, 0);
+
+      drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight);
+    }
+
+    /*
+     * 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
+     */
+    int widthsAbove = visibleWidths - 1;
+    int ypos = wrappedRepeatHeightPx * widthsAbove
+            + wrappedSpaceAboveAlignment;
+    int endRes = ranges.getEndRes();
+    endRes += widthsAbove * viewportWidth;
+    int startRes = endRes - columns + 1;
+
+    /*
+     * white fill first to erase annotations
+     */
+    int xOffset = ((startRes - ranges.getStartRes()) % viewportWidth)
+            * charWidth;
+    gg.translate(xOffset, 0);
+    gg.setColor(Color.white);
+    int width = viewportWidth * charWidth - xOffset;
+    gg.fillRect(labelWidthWest, ypos, width, wrappedRepeatHeightPx);
+    gg.translate(-xOffset, 0);
+
+    gg.setFont(av.getFont());
+    gg.setColor(Color.black);
+
+    if (startRes < ranges.getVisibleAlignmentWidth())
+    {
+      drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight);
+    }
+
+    /*
+     * and finally, white fill any space below the visible alignment
+     */
+    int heightBelow = canvasHeight - visibleWidths * wrappedRepeatHeightPx;
+    if (heightBelow > 0)
+    {
+      gg.setColor(Color.white);
+      gg.fillRect(0, canvasHeight - heightBelow, getWidth(), heightBelow);
+    }
+  }
+
+  /**
+   * Shifts the visible alignment by the specified number of columns - left if
+   * negative, right if positive. Copies and moves sequences and annotations (if
+   * shown). Scales, hidden column markers and any newly visible columns must be
+   * drawn separately.
+   * 
+   * @param positions
+   */
+  protected void shiftWrappedAlignment(int positions)
+  {
+    if (positions == 0)
+    {
+      return;
+    }
+    int charWidth = av.getCharWidth();
+
+    int canvasHeight = getHeight();
+    ViewportRanges ranges = av.getRanges();
+    int viewportWidth = ranges.getViewportWidth();
+    int widthToCopy = (ranges.getViewportWidth() - Math.abs(positions))
+            * charWidth;
+    int heightToCopy = wrappedRepeatHeightPx - wrappedSpaceAboveAlignment;
+    int xMax = ranges.getVisibleAlignmentWidth();
+
+    if (positions > 0)
+    {
+      /*
+       * shift right (after scroll left)
+       * for each wrapped width (starting with the last), copy (width-positions) 
+       * columns from the left margin to the right margin, and copy positions 
+       * columns from the right margin of the row above (if any) to the 
+       * left margin of the current row
+       */
+
+      /*
+       * get y-offset of last wrapped width, first row of sequences
+       */
+      int y = canvasHeight / wrappedRepeatHeightPx * wrappedRepeatHeightPx;
+      y += wrappedSpaceAboveAlignment;
+      int copyFromLeftStart = labelWidthWest;
+      int copyFromRightStart = copyFromLeftStart + widthToCopy;
+
+      while (y >= 0)
+      {
+        gg.copyArea(copyFromLeftStart, y, widthToCopy, heightToCopy,
+                positions * charWidth, 0);
+        if (y > 0)
+        {
+          gg.copyArea(copyFromRightStart, y - wrappedRepeatHeightPx,
+                  positions * charWidth, heightToCopy, -widthToCopy,
+                  wrappedRepeatHeightPx);
+        }
+
+        y -= wrappedRepeatHeightPx;
+      }
+    }
+    else
+    {
+      /*
+       * shift left (after scroll right)
+       * for each wrapped width (starting with the first), copy (width-positions) 
+       * columns from the right margin to the left margin, and copy positions 
+       * columns from the left margin of the row below (if any) to the 
+       * right margin of the current row
+       */
+      int xpos = av.getRanges().getStartRes();
+      int y = wrappedSpaceAboveAlignment;
+      int copyFromRightStart = labelWidthWest - positions * charWidth;
+
+      while (y < canvasHeight)
+      {
+        gg.copyArea(copyFromRightStart, y, widthToCopy, heightToCopy,
+                positions * charWidth, 0);
+        if (y + wrappedRepeatHeightPx < canvasHeight - wrappedRepeatHeightPx
+                && (xpos + viewportWidth <= xMax))
+        {
+          gg.copyArea(labelWidthWest, y + wrappedRepeatHeightPx, -positions
+                  * charWidth, heightToCopy, widthToCopy,
+                  -wrappedRepeatHeightPx);
+        }
+
+        y += wrappedRepeatHeightPx;
+        xpos += viewportWidth;
+      }
+    }
+  }
+
+  
+  /**
    * 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
@@ -1560,11 +1982,13 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
     {
       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();
@@ -1661,25 +2085,4 @@ public class SeqCanvas extends JComponent implements ViewportListenerI
   
     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;
-  }
 }