X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqCanvas.java;h=bd2862a3b8affddc0858182222080e86f83011fd;hb=875193c17720b95fa13a38703b1dd63949e12ca9;hp=5796b633b1ba1596d0aca8e142409deb5e16b71e;hpb=0afdd9e523ca69ab2ce00611e5f3dcb0e57f72ae;p=jalview.git diff --git a/src/jalview/gui/SeqCanvas.java b/src/jalview/gui/SeqCanvas.java index 5796b63..bd2862a 100755 --- a/src/jalview/gui/SeqCanvas.java +++ b/src/jalview/gui/SeqCanvas.java @@ -31,6 +31,7 @@ import jalview.util.Comparison; import jalview.viewmodel.ViewportListenerI; import jalview.viewmodel.ViewportRanges; +import java.awt.AlphaComposite; import java.awt.BasicStroke; import java.awt.BorderLayout; import java.awt.Color; @@ -46,53 +47,58 @@ 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"; + private static final String ZEROS = "0000000000"; final FeatureRenderer fr; - final SequenceRenderer sr; - BufferedImage img; - Graphics2D gg; + AlignViewport av; + + int cursorX = 0; - int imgWidth; + int cursorY = 0; - int imgHeight; + private final SequenceRenderer seqRdr; - AlignViewport av; + private boolean fastPaint = false; - boolean fastPaint = false; + private boolean fastpainting = false; - boolean fastpainting = false; + private AnnotationPanel annotations; - int labelWidthWest; + /* + * measurements for drawing a wrapped alignment + */ + private int labelWidthEast; // label right width in pixels if shown - int labelWidthEast; + private int labelWidthWest; // label left width in pixels if shown - int cursorX = 0; + private int wrappedSpaceAboveAlignment; // gap between widths - int cursorY = 0; + private 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); @@ -102,7 +108,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI public SequenceRenderer getSequenceRenderer() { - return sr; + return seqRdr; } public FeatureRenderer getFeatureRenderer() @@ -110,31 +116,33 @@ public class SeqCanvas extends JComponent implements ViewportListenerI return fr; } - int charHeight = 0, charWidth = 0; - - 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 10 columns. + * column number every major interval (10 columns). * * @param g * the graphics context to draw on, positioned at the start (bottom - * left) of the + * 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(); + 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 marks = new ScaleRenderer().calculateMarks(av, startx, endx); for (ScaleMark mark : marks) @@ -167,6 +175,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 @@ -176,16 +185,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.adjustForHiddenColumns(startx); + endX = hiddenColumns.adjustForHiddenColumns(endx); } FontMetrics fm = getFontMetrics(av.getFont()); @@ -197,9 +211,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))) { @@ -216,24 +230,28 @@ 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); + // fillRect origin is top left of rectangle + g.fillRect(0, y - charHeight, left ? labelWidthWest : labelWidthEast, + charHeight + 1); + if (value != -1) { /* - * draw scale value, 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; - int xpos = left ? labelWidthWest - justify + charWidth / 2 - : getWidth() - justify - charWidth / 2; - - g.setColor(Color.white); - int y = (ypos + (i * charHeight)) - (charHeight / 5); - y -= charHeight; // fillRect starts from top right of rectangle - g.fillRect(xpos, y, justify - charWidth, charHeight + 1); - y += charHeight; // drawString starts from bottom right of text + int labelLength = fm.stringWidth(valueAsString); + int xOffset = labelSpace - labelLength; g.setColor(Color.black); - g.drawString(valueAsString, xpos, y); + g.drawString(valueAsString, xOffset, y); } } } @@ -258,24 +276,29 @@ 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; } 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; - gg.copyArea(horizontal * charWidth, vertical * charHeight, imgWidth, - imgHeight, -horizontal * charWidth, -vertical * charHeight); + 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, + -vertical * charHeight); if (horizontal > 0) // scrollbar pulled right, image to the left { @@ -296,7 +319,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI } else { - transY = imgHeight - ((vertical + 1) * charHeight); + transY = img.getHeight() - ((vertical + 1) * charHeight); } } else if (vertical < 0) @@ -314,80 +337,228 @@ public class SeqCanvas extends JComponent implements ViewportListenerI gg.translate(-transX, -transY); repaint(); - fastpainting = false; + } finally + { + fastpainting = false; + } } @Override public void paintComponent(Graphics g) { - updateViewport(); - BufferedImage lcimg = img; // take reference since other threads may null - // img and call later. - super.paintComponent(g); + super.paintComponent(g); + + int charHeight = av.getCharHeight(); + int charWidth = av.getCharWidth(); - if (lcimg != null - && (fastPaint - || (getVisibleRect().width != g.getClipBounds().width) || (getVisibleRect().height != g - .getClipBounds().height))) + ViewportRanges ranges = av.getRanges(); + + int width = getWidth(); + int height = getHeight(); + + width -= (width % charWidth); + height -= (height % charHeight); + + // selectImage is the selection group outline image + BufferedImage selectImage = drawSelectionGroup( + ranges.getStartRes(), ranges.getEndRes(), + ranges.getStartSeq(), ranges.getEndSeq()); + + BufferedImage cursorImage = drawCursor(ranges.getStartRes(), + ranges.getEndRes(), ranges.getStartSeq(), ranges.getEndSeq()); + + if ((img != null) && (fastPaint + || (getVisibleRect().width != g.getClipBounds().width) + || (getVisibleRect().height != g.getClipBounds().height))) { + BufferedImage lcimg = buildLocalImage(selectImage, cursorImage); 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()); + } + + if (av.antiAlias) + { + gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_ON); + } - // this draws the whole of the alignment - imgWidth = getWidth(); - imgHeight = getHeight(); + gg.setColor(Color.white); + gg.fillRect(0, 0, img.getWidth(), img.getHeight()); - imgWidth -= (imgWidth % charWidth); - imgHeight -= (imgHeight % charHeight); + if (av.getWrapAlignment()) + { + drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes()); + } + else + { + drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(), + ranges.getStartSeq(), ranges.getEndSeq(), 0); + } - if ((imgWidth < 1) || (imgHeight < 1)) + // lcimg is a local *copy* of img which we'll draw selectImage on top of + BufferedImage lcimg = buildLocalImage(selectImage, cursorImage); + g.drawImage(lcimg, 0, 0, this); + } + } + + /** + * 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) { - return; + ((Graphics2D) g1).setComposite(AlphaComposite + .getInstance(AlphaComposite.SRC_OVER)); + g1.drawImage(selectImage, 0, 0, this); } + } + + /** + * Draw a wrapped alignment panel for printing + * + * @param g + * Graphics object to draw with + * @param canvasWidth + * width of drawing area + * @param canvasHeight + * height of drawing area + * @param startRes + * start residue of print area + */ + public void drawWrappedPanelForPrinting(Graphics g, int canvasWidth, + int canvasHeight, int startRes) + { + SequenceGroup group = av.getSelectionGroup(); + + drawWrappedPanel(g, canvasWidth, canvasHeight, startRes); - if (lcimg == null || imgWidth != lcimg.getWidth() - || imgHeight != lcimg.getHeight()) + if (group != null) { + BufferedImage selectImage = null; try { - lcimg = img = new BufferedImage(imgWidth, imgHeight, - BufferedImage.TYPE_INT_RGB); - gg = (Graphics2D) img.getGraphics(); - gg.setFont(av.getFont()); + selectImage = new BufferedImage(canvasWidth, canvasHeight, + BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works } catch (OutOfMemoryError er) { System.gc(); - System.err.println("SeqCanvas OutOfMemory Redraw Error.\n" + er); - new OOMWarning("Creating alignment image for display", er); - - return; + System.err.println("Print image OutOfMemory Error.\n" + er); + new OOMWarning("Creating wrapped alignment image for printing", er); + } + if (selectImage != null) + { + Graphics2D g2 = selectImage.createGraphics(); + setupSelectionGroup(g2, selectImage); + drawWrappedSelection(g2, group, canvasWidth, canvasHeight, + startRes); + + g2.setComposite( + AlphaComposite.getInstance(AlphaComposite.SRC_OVER)); + g.drawImage(selectImage, 0, 0, this); + g2.dispose(); } } + } - if (av.antiAlias) + /* + * Make a local image by combining the cached image img + * with any selection + */ + private BufferedImage buildLocalImage(BufferedImage selectImage, + BufferedImage cursorImage) + { + // clone the cached image + BufferedImage lcimg = new BufferedImage(img.getWidth(), img.getHeight(), + img.getType()); + Graphics2D g2d = lcimg.createGraphics(); + g2d.drawImage(img, 0, 0, null); + + // overlay selection group on lcimg + if (selectImage != null) { - gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING, - RenderingHints.VALUE_ANTIALIAS_ON); + g2d.setComposite( + AlphaComposite.getInstance(AlphaComposite.SRC_OVER)); + g2d.drawImage(selectImage, 0, 0, this); } + // overlay cursor on lcimg + if (cursorImage != null) + { + g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER)); + g2d.drawImage(cursorImage, 0, 0, this); + } + g2d.dispose(); - gg.setColor(Color.white); - gg.fillRect(0, 0, imgWidth, imgHeight); + return lcimg; + } - ViewportRanges ranges = av.getRanges(); - if (av.getWrapAlignment()) + /* + * Set up a buffered image of the correct height and size for the sequence canvas + */ + private BufferedImage setupImage() + { + BufferedImage lcimg = null; + + int charWidth = av.getCharWidth(); + int charHeight = av.getCharHeight(); + + int width = getWidth(); + int height = getHeight(); + + width -= (width % charWidth); + height -= (height % charHeight); + + if ((width < 1) || (height < 1)) { - drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes()); + return null; } - else + + try { - drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(), - ranges.getStartSeq(), ranges.getEndSeq(), 0); - } + lcimg = new BufferedImage(width, height, + BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works + } catch (OutOfMemoryError er) + { + System.gc(); + System.err.println( + "Group image OutOfMemory Redraw Error.\n" + er); + new OOMWarning("Creating alignment image for display", er); - g.drawImage(lcimg, 0, 0, this); + return null; + } + return lcimg; } /** @@ -401,29 +572,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 @@ -441,13 +613,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(); } /** @@ -459,175 +631,350 @@ public class SeqCanvas extends JComponent implements ViewportListenerI * available width in pixels * @param canvasHeight * available height in pixels - * @param startRes - * the first visible column (0...) of the alignment to draw + * @param startColumn + * the first column (0...) of the alignment to draw */ public void drawWrappedPanel(Graphics g, int canvasWidth, - int canvasHeight, int startRes) + int canvasHeight, final int startColumn) { - updateViewport(); - int labelWidth = 0; - if (av.getScaleRightWrapped() || av.getScaleLeftWrapped()) - { - FontMetrics fm = getFontMetrics(av.getFont()); - labelWidth = getLabelWidth(fm); - } + int wrappedWidthInResidues = calculateWrappedGeometry(canvasWidth, + canvasHeight); - labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0; - labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0; + av.setWrappedWidth(wrappedWidthInResidues); - int hgap = charHeight; - if (av.getScaleAboveWrapped()) + 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)) { - hgap += charHeight; + int endColumn = Math + .min(maxWidth, start + wrappedWidthInResidues - 1); + drawWrappedWidth(g, ypos, start, endColumn, canvasHeight); + ypos += wrappedRepeatHeightPx; + start += wrappedWidthInResidues; + currentWidth++; } - int cWidth = (canvasWidth - labelWidthEast - labelWidthWest) / charWidth; + drawWrappedDecorators(g, startColumn); + } - av.setWrappedWidth(cWidth); + /** + * Calculates and saves values needed when rendering a wrapped alignment. + * These depend on many factors, including + * + * + * @param canvasWidth + * @param canvasHeight + * @return the number of residue columns in each width + */ + protected int calculateWrappedGeometry(int canvasWidth, int canvasHeight) + { + int charHeight = av.getCharHeight(); - av.getRanges().setViewportStartAndWidth(startRes, cWidth); + /* + * 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); - int ypos = hgap; - int maxwidth = av.getAlignment().getWidth(); + /* + * height in pixels of the wrapped widths + */ + wrappedRepeatHeightPx = wrappedSpaceAboveAlignment; + // add sequences + wrappedRepeatHeightPx += av.getRanges().getViewportHeight() + * charHeight; + // add annotations panel height if shown + wrappedRepeatHeightPx += getAnnotationHeight(); - if (av.hasHiddenColumns()) + /* + * number of visible widths (the last one may be part height), + * ensuring a part height includes at least one sequence + */ + ViewportRanges ranges = av.getRanges(); + wrappedVisibleWidths = canvasHeight / wrappedRepeatHeightPx; + int remainder = canvasHeight % wrappedRepeatHeightPx; + if (remainder >= (wrappedSpaceAboveAlignment + charHeight)) { - maxwidth = av.getAlignment().getHiddenColumns() - .findColumnPosition(maxwidth); + wrappedVisibleWidths++; } - int annotationHeight = getAnnotationHeight(); - int sequencesHeight = av.getAlignment().getHeight() * charHeight; + /* + * compute width in residues; this also sets East and West label widths + */ + int wrappedWidthInResidues = getWrappedCanvasWidth(canvasWidth); /* - * draw one width at a time (including any scales or annotation shown), - * until we have run out of alignment or vertical space available + * limit visibleWidths to not exceed width of alignment */ - while ((ypos <= canvasHeight) && (startRes < maxwidth)) + int xMax = ranges.getVisibleAlignmentWidth(); + int startToEnd = xMax - ranges.getStartRes(); + int maxWidths = startToEnd / wrappedWidthInResidues; + if (startToEnd % wrappedWidthInResidues > 0) { - drawWrappedWidth(g, startRes, canvasHeight, cWidth, maxwidth, ypos); - - ypos += sequencesHeight + annotationHeight + hgap; - - startRes += cWidth; + 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 startRes - * @param canvasHeight - * @param canvasWidth - * @param maxWidth * @param ypos + * @param startColumn + * @param endColumn + * @param canvasHeight */ - protected void drawWrappedWidth(Graphics g, int startRes, - int canvasHeight, int canvasWidth, int maxWidth, int ypos) + protected void drawWrappedWidth(Graphics g, int ypos, int startColumn, + int endColumn, int canvasHeight) { - int endx; - endx = startRes + canvasWidth - 1; + ViewportRanges ranges = av.getRanges(); + int viewportWidth = ranges.getViewportWidth(); - if (endx > maxWidth) - { - endx = maxWidth; - } + int endx = Math.min(startColumn + viewportWidth - 1, endColumn); - g.setFont(av.getFont()); - g.setColor(Color.black); + /* + * 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 charWidth = av.getCharWidth(); + int xOffset = labelWidthWest + + ((startColumn - ranges.getStartRes()) % viewportWidth) + * charWidth; + g.translate(xOffset, 0); + + // When printing we have an extra clipped region, + // the Printable page which we need to account for here + Shape clip = g.getClip(); - if (av.getScaleLeftWrapped()) + if (clip == null) { - drawVerticalScale(g, startRes, endx, ypos, true); + g.setClip(0, 0, viewportWidth * charWidth, canvasHeight); } - - if (av.getScaleRightWrapped()) + else { - drawVerticalScale(g, startRes, endx, ypos, false); + g.setClip(0, (int) clip.getBounds().getY(), + viewportWidth * charWidth, (int) clip.getBounds().getHeight()); } - drawWrappedRegion(g, startRes, endx, canvasHeight, canvasWidth, ypos); + /* + * 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); + + drawPanel(g, startColumn, endx, 0, av.getAlignment().getHeight() - 1, + ypos); + + int cHeight = av.getAlignment().getHeight() * av.getCharHeight(); + + if (av.isShowAnnotation()) + { + g.translate(0, cHeight + ypos + 3); + if (annotations == null) + { + annotations = new AnnotationPanel(av); + } + + annotations.renderer.drawComponent(annotations, av, g, -1, + startColumn, endx + 1); + g.translate(0, -cHeight - ypos - 3); + } + g.setClip(clip); + g.translate(-xOffset, 0); } /** - * Draws columns of a wrapped alignment from startRes to endRes, including - * scale above and annotations if shown, but not scale left or right. + * Draws scales left, right and above (if shown), and any hidden column + * markers, on all widths of the wrapped alignment * * @param g - * @param startRes - * @param endRes - * @param canvasHeight - * @param canvasWidth - * @param ypos + * @param startColumn */ - protected void drawWrappedRegion(Graphics g, int startRes, int endRes, - int canvasHeight, int canvasWidth, int ypos) + protected void drawWrappedDecorators(Graphics g, final int startColumn) { - g.translate(labelWidthWest, 0); + int charWidth = av.getCharWidth(); - if (av.getScaleAboveWrapped()) - { - drawNorthScale(g, startRes, endRes, ypos); - } + g.setFont(av.getFont()); + g.setColor(Color.black); - // todo can we let drawPanel() handle this? - if (av.hasHiddenColumns() && av.getShowHiddenMarkers()) + int ypos = wrappedSpaceAboveAlignment; + ViewportRanges ranges = av.getRanges(); + int viewportWidth = ranges.getViewportWidth(); + int maxWidth = ranges.getVisibleAlignmentWidth(); + int widthsDrawn = 0; + int startCol = startColumn; + + while (widthsDrawn < wrappedVisibleWidths) { - g.setColor(Color.blue); - HiddenColumns hidden = av.getAlignment().getHiddenColumns(); - List positions = hidden.findHiddenRegionPositions(); - for (int pos : positions) + int endColumn = Math.min(maxWidth, startCol + viewportWidth - 1); + + if (av.getScaleLeftWrapped()) { - int res = pos - startRes; + drawVerticalScale(g, startCol, endColumn - 1, ypos, true); + } - if (res < 0 || res > endRes - startRes) - { - continue; - } + if (av.getScaleRightWrapped()) + { + 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); - 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); + g.translate(labelWidthWest, 0); + + if (av.getScaleAboveWrapped()) + { + drawNorthScale(g, startCol, endColumn, ypos); + } + + if (av.hasHiddenColumns() && av.getShowHiddenMarkers()) + { + drawHiddenColumnMarkers(g, ypos, startCol, endColumn); } + + g.translate(-labelWidthWest, 0); + + ypos += wrappedRepeatHeightPx; + startCol += viewportWidth; + widthsDrawn++; } + } - // When printing we have an extra clipped region, - // the Printable page which we need to account for here - Shape clip = g.getClip(); + /** + * Draws markers (triangles) above hidden column positions between startColumn + * and endColumn. + * + * @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(); - if (clip == null) + g.setColor(Color.blue); + HiddenColumns hidden = av.getAlignment().getHiddenColumns(); + List positions = hidden.findHiddenRegionPositions(); + for (int pos : positions) { - g.setClip(0, 0, canvasWidth * charWidth, canvasHeight); + int res = pos - startColumn; + + if (res < 0 || res > endColumn - startColumn + 1) + { + continue; + } + + /* + * 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); } - else + } + + /* + * 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()) { - g.setClip(0, (int) clip.getBounds().getY(), canvasWidth * charWidth, - (int) clip.getBounds().getHeight()); + hgap += charHeight; } - drawPanel(g, startRes, endRes, 0, av.getAlignment().getHeight() - 1, ypos); - + int cWidth = (canvasWidth - labelWidthEast - labelWidthWest) + / charWidth; int cHeight = av.getAlignment().getHeight() * charHeight; - if (av.isShowAnnotation()) + int startx = startRes; + int endx; + int ypos = hgap; // vertical offset + int maxwidth = av.getAlignment().getWidth(); + + if (av.hasHiddenColumns()) { - g.translate(0, cHeight + ypos + 3); - if (annotations == null) + 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) { - annotations = new AnnotationPanel(av); + endx = maxwidth; } - annotations.renderer.drawComponent(annotations, av, g, -1, startRes, - endRes + 1); - g.translate(0, -cHeight - ypos - 3); + 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.setClip(clip); - g.translate(-labelWidthWest, 0); } - AnnotationPanel annotations; - int getAnnotationHeight() { if (!av.isShowAnnotation()) @@ -665,7 +1012,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); @@ -755,8 +1104,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; @@ -771,13 +1123,13 @@ 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); } /* @@ -792,7 +1144,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI { 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)); @@ -800,209 +1152,404 @@ public class SeqCanvas extends JComponent implements ViewportListenerI } } - if (av.cursorMode && cursorY == i && cursorX >= startRes - && cursorX <= endRes) + /* if (av.cursorMode && cursorY == i && cursorX >= startRes + && cursorX <= endRes) + { + seqRdr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth, + offset + ((i - startSeq) * charHeight)); + }*/ + } + + if (av.getSelectionGroup() != null + || av.getAlignment().getGroups().size() > 0) + { + drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, 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 = null; + int groupIndex = -1; + + if (av.getAlignment().getGroups().size() > 0) + { + group = av.getAlignment().getGroups().get(0); + groupIndex = 0; + } + + if (group != null) + { + g.setStroke(new BasicStroke()); + g.setColor(group.getOutlineColour()); + + do + { + drawPartialGroupOutline(g, group, startRes, endRes, startSeq, + endSeq, offset); + + groupIndex++; + + g.setStroke(new BasicStroke()); + + if (groupIndex >= av.getAlignment().getGroups().size()) + { + break; + } + + group = av.getAlignment().getGroups().get(groupIndex); + + } while (groupIndex < av.getAlignment().getGroups().size()); + + } + + } + + + /* + * Draw the selection group as a separate image and overlay + */ + private BufferedImage drawSelectionGroup(int startRes, int endRes, + int startSeq, int endSeq) + { + // get a new image of the correct size + BufferedImage selectionImage = setupImage(); + + if (selectionImage == null) + { + return null; + } + + SequenceGroup group = av.getSelectionGroup(); + if (group == null) + { + // nothing to draw + return null; + } + + // set up drawing colour + Graphics2D g = (Graphics2D) selectionImage.getGraphics(); + + setupSelectionGroup(g, selectionImage); + + if (!av.getWrapAlignment()) + { + drawUnwrappedSelection(g, group, startRes, endRes, startSeq, endSeq, + 0); + } + else + { + drawWrappedSelection(g, group, getWidth(), getHeight(), + av.getRanges().getStartRes()); + } + + g.dispose(); + return selectionImage; + } + + /** + * 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 BufferedImage drawCursor(int startRes, int endRes, int startSeq, + int endSeq) + { + // define our cursor image + BufferedImage cursorImage = null; + + if (av.cursorMode && cursorY >= startSeq && cursorY <= endSeq + && cursorX >= startRes && cursorX <= endRes) + { + // get a new image of the correct size + cursorImage = setupImage(); + Graphics2D g = (Graphics2D) cursorImage.getGraphics(); + + // get the character the cursor is drawn at + SequenceI seq = av.getAlignment().getSequenceAt(cursorY); + char s = seq.getCharAt(cursorX); + + int offset = 0; + if (av.getWrapAlignment()) { - sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth, - offset + ((i - startSeq) * charHeight)); + // work out the correct offset for the cursor + offset = wrappedSpaceAboveAlignment; + int currentWidth = 0; + while ((currentWidth < wrappedVisibleWidths) + && (currentWidth < cursorX)) + { + offset += wrappedRepeatHeightPx; + currentWidth++; + } } - } - if (av.getSelectionGroup() != null - || av.getAlignment().getGroups().size() > 0) - { - drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset); + seqRdr.drawCursor(g, s, + (cursorX - startRes) * av.getCharWidth(), + offset + ((cursorY - startSeq) * av.getCharHeight())); + g.dispose(); } + return cursorImage; } - void drawGroupsBoundaries(Graphics g1, int startRes, int endRes, - int startSeq, int endSeq, int offset) + /* + * Set up graphics for selection group + */ + private void setupSelectionGroup(Graphics2D g, + BufferedImage selectionImage) { - Graphics2D g = (Graphics2D) g1; - // - // /////////////////////////////////// - // Now outline any areas if necessary - // /////////////////////////////////// - SequenceGroup group = av.getSelectionGroup(); - - int sx = -1; - int sy = -1; - int ex = -1; - int groupIndex = -1; - int visWidth = (endRes - startRes + 1) * charWidth; + // 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); + } - if ((group == null) && (av.getAlignment().getGroups().size() > 0)) + /* + * 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()) { - group = av.getAlignment().getGroups().get(0); - groupIndex = 0; + drawPartialGroupOutline(g, group, startRes, endRes, startSeq, endSeq, + offset); } - - if (group != null) + else { - do + // package into blocks of visible columns + int screenY = 0; + int blockStart = startRes; + int blockEnd = endRes; + + for (int[] region : av.getAlignment().getHiddenColumns() + .getHiddenColumnsCopy()) { - int oldY = -1; - int i = 0; - boolean inGroup = false; - int top = -1; - int bottom = -1; + int hideStart = region[0]; + int hideEnd = region[1]; - for (i = startSeq; i <= endSeq; i++) + if (hideStart <= blockStart) { - sx = (group.getStartRes() - startRes) * charWidth; - sy = offset + ((i - startSeq) * charHeight); - ex = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth) - 1; + blockStart += (hideEnd - hideStart) + 1; + continue; + } - if (sx + ex < 0 || sx > visWidth) - { - continue; - } + blockEnd = hideStart - 1; - 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; - } + g.translate(screenY * charWidth, 0); + drawPartialGroupOutline(g, group, + blockStart, blockEnd, startSeq, endSeq, offset); - if (!inGroup) - { - if (((top == -1) && (i == 0)) - || !group.getSequences(null).contains( - av.getAlignment().getSequenceAt(i - 1))) - { - top = sy; - } + g.translate(-screenY * charWidth, 0); + screenY += blockEnd - blockStart + 1; + blockStart = hideEnd + 1; + + if (screenY > (endRes - startRes)) + { + // already rendered last block + break; + } + } - oldY = sy; - inGroup = true; + if (screenY <= (endRes - startRes)) + { + // remaining visible region to render + blockEnd = blockStart + (endRes - startRes) - screenY; + g.translate(screenY * charWidth, 0); + drawPartialGroupOutline(g, group, + blockStart, blockEnd, startSeq, endSeq, offset); + + g.translate(-screenY * charWidth, 0); + } + } + } - 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); - } + /* + * Draw the selection group as a separate image and overlay + */ + private void drawPartialGroupOutline(Graphics2D g, SequenceGroup group, + int startRes, int endRes, int startSeq, int endSeq, + int verticalOffset) + { + int charHeight = av.getCharHeight(); + int charWidth = av.getCharWidth(); + + int visWidth = (endRes - startRes + 1) * charWidth; - if (sx + ex < visWidth) - { - g.drawLine(sx + ex, oldY, sx + ex, sy); - } + int oldY = -1; + int i = 0; + boolean inGroup = false; + int top = -1; + int bottom = -1; - if (sx < 0) - { - ex += sx; - sx = 0; - } + int sx = -1; + int sy = -1; + int xwidth = -1; - if (sx + ex > visWidth) - { - ex = visWidth; - } + for (i = startSeq; i <= endSeq; i++) + { + // position of start residue of group relative to startRes, in pixels + sx = (group.getStartRes() - startRes) * charWidth; - else if (sx + ex >= (endRes - startRes + 1) * charWidth) - { - ex = (endRes - startRes + 1) * charWidth; - } + // width of group in pixels + xwidth = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth) + - 1; - if (top != -1) - { - g.drawLine(sx, top, sx + ex, top); - top = -1; - } + sy = verticalOffset + (i - startSeq) * charHeight; - if (bottom != -1) - { - g.drawLine(sx, bottom, sx + ex, bottom); - bottom = -1; - } + if (sx + xwidth < 0 || sx > visWidth) + { + continue; + } - inGroup = false; - } - } + 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; + } + } + else + { if (inGroup) { - sy = offset + ((i - startSeq) * charHeight); + // if start position is visible, draw vertical line to left of + // group if (sx >= 0 && sx < visWidth) { g.drawLine(sx, oldY, sx, sy); } - if (sx + ex < visWidth) + // if end position is visible, draw vertical line to right of + // group + if (sx + xwidth < visWidth) { - g.drawLine(sx + ex, oldY, sx + ex, sy); + g.drawLine(sx + xwidth, oldY, sx + xwidth, sy); } if (sx < 0) { - ex += sx; + xwidth += sx; sx = 0; } - if (sx + ex > visWidth) - { - ex = visWidth; - } - else if (sx + ex >= (endRes - startRes + 1) * charWidth) + // don't let width extend beyond current block, or group extent + // fixes JAL-2672 + if (sx + xwidth >= (endRes - startRes + 1) * charWidth) { - ex = (endRes - startRes + 1) * charWidth; + xwidth = (endRes - startRes + 1) * charWidth - sx; } - + + // draw horizontal line at top of group if (top != -1) { - g.drawLine(sx, top, sx + ex, top); + g.drawLine(sx, top, sx + xwidth, top); top = -1; } + // draw horizontal line at bottom of group if (bottom != -1) { - g.drawLine(sx, bottom - 1, sx + ex, bottom - 1); + g.drawLine(sx, bottom, sx + xwidth, bottom); bottom = -1; } inGroup = false; } + } + } - groupIndex++; + if (inGroup) + { + sy = verticalOffset + ((i - startSeq) * charHeight); + if (sx >= 0 && sx < visWidth) + { + g.drawLine(sx, oldY, sx, sy); + } - g.setStroke(new BasicStroke()); + if (sx + xwidth < visWidth) + { + g.drawLine(sx + xwidth, oldY, sx + xwidth, sy); + } - if (groupIndex >= av.getAlignment().getGroups().size()) - { - break; - } + if (sx < 0) + { + xwidth += sx; + sx = 0; + } - group = av.getAlignment().getGroups().get(groupIndex); + if (sx + xwidth > visWidth) + { + xwidth = visWidth; + } + else if (sx + xwidth >= (endRes - startRes + 1) * charWidth) + { + xwidth = (endRes - startRes + 1) * charWidth; + } - } while (groupIndex < av.getAlignment().getGroups().size()); + if (top != -1) + { + g.drawLine(sx, top, sx + xwidth, top); + top = -1; + } - } + if (bottom != -1) + { + g.drawLine(sx, bottom - 1, sx + xwidth, bottom - 1); + bottom = -1; + } + inGroup = false; + } } - + /** * Highlights search results in the visible region by rendering as white text * on a black background. Any previous highlighting is removed. Answers true @@ -1027,14 +1574,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 @@ -1174,56 +1718,54 @@ public class SeqCanvas extends JComponent implements ViewportListenerI { String eventName = evt.getPropertyName(); - // if (av.getWrapAlignment()) - // { - // if (eventName.equals(ViewportRanges.STARTRES)) - // { - // repaint(); - // } - // } - // else - { - int scrollX = 0; - if (eventName.equals(ViewportRanges.STARTRES)) + if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED)) + { + fastPaint = true; + repaint(); + return; + } + + int scrollX = 0; + if (eventName.equals(ViewportRanges.STARTRES)) + { + // Make sure we're not trying to draw a panel + // larger than the visible window + ViewportRanges vpRanges = av.getRanges(); + scrollX = (int) evt.getNewValue() - (int) evt.getOldValue(); + int range = vpRanges.getViewportWidth(); + if (scrollX > range) { - // Make sure we're not trying to draw a panel - // larger than the visible window - ViewportRanges vpRanges = av.getRanges(); - scrollX = (int) evt.getNewValue() - (int) evt.getOldValue(); - int range = vpRanges.getEndRes() - vpRanges.getStartRes(); - if (scrollX > range) - { - scrollX = range; - } - else if (scrollX < -range) - { - scrollX = -range; - } + scrollX = range; + } + else if (scrollX < -range) + { + scrollX = -range; } + } - // Both scrolling and resizing change viewport ranges: scrolling changes - // both start and end points, but resize only changes end values. - // Here we only want to fastpaint on a scroll, with resize using a normal - // paint, so scroll events are identified as changes to the horizontal or - // vertical start value. - if (eventName.equals(ViewportRanges.STARTRES)) + // 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 + if (eventName.equals(ViewportRanges.STARTRES)) + { + if (av.getWrapAlignment()) { - // scroll - startres and endres both change - if (av.getWrapAlignment()) - { - fastPaintWrapped(scrollX); - // fastPaintWrapped(scrollX > 0 ? 1 : -1); // to debug: 1 at a time - } - else - { - fastPaint(scrollX, 0); - } + fastPaintWrapped(scrollX); } - else if (eventName.equals(ViewportRanges.STARTSEQ)) + else { - fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue()); + fastPaint(scrollX, 0); } } + else if (eventName.equals(ViewportRanges.STARTSEQ)) + { + // scroll + fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue()); + } } /** @@ -1237,126 +1779,163 @@ public class SeqCanvas extends JComponent implements ViewportListenerI */ protected void fastPaintWrapped(int scrollX) { - if (Math.abs(scrollX) > av.getRanges().getViewportWidth()) + ViewportRanges ranges = av.getRanges(); + + if (Math.abs(scrollX) > ranges.getViewportWidth()) { /* * shift of more than one view width is - * too complicated to handle in this method + * overcomplicated to handle in this method */ fastPaint = false; repaint(); return; } - fastPaint = true; + if (fastpainting || gg == null) + { + return; + } - /* - * relocate the regions of the alignment that are still visible - */ - shiftWrappedAlignment(-scrollX); + fastPaint = true; + fastpainting = true; - /* - * add new columns (scale above, sequence, annotation) - * at top left if scrollX < 0 or bottom right if scrollX > 0 - * also West scale top left or East scale bottom right if shown - */ - if (scrollX < 0) + try { - fastPaintWrappedTopLeft(-scrollX); - } - else + 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 { - // fastPaintWrappedBottomRight(scrollX); + fastpainting = false; } - - repaint(); } /** * Draws the specified number of columns at the 'end' (bottom right) of a - * wrapped alignment view, including scale above and right and annotations if - * shown + * 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 fastPaintWrappedBottomRight(int columns) + protected void fastPaintWrappedAddRight(int columns) { if (columns == 0) { return; } - int repeatHeight = getRepeatHeightWrapped(); ViewportRanges ranges = av.getRanges(); - int visibleWidths = getHeight() / repeatHeight; - if (getHeight() % repeatHeight > 0) - { - visibleWidths++; - } int viewportWidth = ranges.getViewportWidth(); - int hgap = charHeight * (av.getScaleAboveWrapped() ? 2 : 1); + int charWidth = av.getCharWidth(); - int startRes = av.getRanges().getStartRes(); - int endx = startRes + columns - 1; - int ypos = charHeight * (av.getScaleAboveWrapped() ? 2 : 1); - ypos += repeatHeight * (visibleWidths - 1); - - gg.setFont(av.getFont()); - gg.setColor(Color.black); + /** + * 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; - int cWidth = (getWidth() - labelWidthEast - labelWidthWest) / charWidth; + 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; - drawWrappedRegion(gg, startRes, endx, getHeight(), cWidth, ypos); + /* + * 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); - if (av.getScaleRightWrapped()) - { - drawVerticalScale(gg, startRes, endx, ypos, false); + drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight); } - } - - /** - * Draws the specified number of columns at the 'start' (top left) of a - * wrapped alignment view, including scale above and left and annotations if - * shown - * - * @param columns - */ - protected void fastPaintWrappedTopLeft(int columns) - { - int startRes = av.getRanges().getStartRes(); /* - * draw one extra column than strictly needed - this is a (harmless) - * fudge to ensure scale marks get drawn (JAL-2636) + * 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 endx = startRes + columns; - int ypos = 0; + int widthsAbove = visibleWidths - 1; + int ypos = wrappedRepeatHeightPx * widthsAbove + + wrappedSpaceAboveAlignment; + int endRes = ranges.getEndRes(); + endRes += widthsAbove * viewportWidth; + int startRes = endRes - columns + 1; /* - * white fill the region to be drawn including scale left or above + * white fill first to erase annotations */ + int xOffset = ((startRes - ranges.getStartRes()) % viewportWidth) + * charWidth; + gg.translate(xOffset, 0); gg.setColor(Color.white); - int height = getRepeatHeightWrapped(); - gg.fillRect(0, ypos, labelWidthWest + columns * charWidth, height); - ypos += charHeight * (av.getScaleAboveWrapped() ? 2 : 1); + int width = viewportWidth * charWidth - xOffset; + gg.fillRect(labelWidthWest, ypos, width, wrappedRepeatHeightPx); + gg.translate(-xOffset, 0); gg.setFont(av.getFont()); gg.setColor(Color.black); - if (av.getScaleLeftWrapped()) + if (startRes < ranges.getVisibleAlignmentWidth()) { - drawVerticalScale(gg, startRes, endx, ypos, true); + drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight); } - int cWidth = (getWidth() - labelWidthEast - labelWidthWest) / charWidth; - - drawWrappedRegion(gg, startRes, endx, getHeight(), cWidth, ypos); + /* + * 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. Includes scale above, left or right and - * annotations (if shown). Does not draw newly visible columns. + * 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 */ @@ -1366,18 +1945,15 @@ public class SeqCanvas extends JComponent implements ViewportListenerI { return; } + int charWidth = av.getCharWidth(); - int repeatHeight = getRepeatHeightWrapped(); + int canvasHeight = getHeight(); ViewportRanges ranges = av.getRanges(); + int viewportWidth = ranges.getViewportWidth(); int widthToCopy = (ranges.getViewportWidth() - Math.abs(positions)) * charWidth; - int visibleWidths = getHeight() / repeatHeight; - if (getHeight() % repeatHeight > 0) - { - visibleWidths++; - } - int viewportWidth = ranges.getViewportWidth(); - int hgap = charHeight * (av.getScaleAboveWrapped() ? 2 : 1); + int heightToCopy = wrappedRepeatHeightPx - wrappedSpaceAboveAlignment; + int xMax = ranges.getVisibleAlignmentWidth(); if (positions > 0) { @@ -1388,37 +1964,27 @@ public class SeqCanvas extends JComponent implements ViewportListenerI * columns from the right margin of the row above (if any) to the * left margin of the current row */ - int xpos = ranges.getStartRes() + (visibleWidths - 1) * viewportWidth; /* - * get y-offset of last wrapped width + * get y-offset of last wrapped width, first row of sequences */ - int y = getHeight() / repeatHeight * repeatHeight; + int y = canvasHeight / wrappedRepeatHeightPx * wrappedRepeatHeightPx; + y += wrappedSpaceAboveAlignment; int copyFromLeftStart = labelWidthWest; int copyFromRightStart = copyFromLeftStart + widthToCopy; while (y >= 0) { - // todo limit repeatHeight for a last part height width? - gg.copyArea(copyFromLeftStart, y, widthToCopy, repeatHeight, + gg.copyArea(copyFromLeftStart, y, widthToCopy, heightToCopy, positions * charWidth, 0); if (y > 0) { - gg.copyArea(copyFromRightStart, y - repeatHeight, positions - * charWidth, repeatHeight, -widthToCopy, repeatHeight); - } - - if (av.getScaleLeftWrapped()) - { - drawVerticalScale(gg, xpos, xpos + viewportWidth, y + hgap, true); - } - if (av.getScaleRightWrapped()) - { - drawVerticalScale(gg, xpos, xpos + viewportWidth, y + hgap, false); + gg.copyArea(copyFromRightStart, y - wrappedRepeatHeightPx, + positions * charWidth, heightToCopy, -widthToCopy, + wrappedRepeatHeightPx); } - y -= repeatHeight; - xpos -= viewportWidth; + y -= wrappedRepeatHeightPx; } } else @@ -1430,36 +1996,29 @@ public class SeqCanvas extends JComponent implements ViewportListenerI * columns from the left margin of the row below (if any) to the * right margin of the current row */ - int xpos = ranges.getStartRes(); - int y = 0; + int xpos = av.getRanges().getStartRes(); + int y = wrappedSpaceAboveAlignment; int copyFromRightStart = labelWidthWest - positions * charWidth; - while (y < getHeight()) + while (y < canvasHeight) { - // todo limit repeatHeight for a last part height width? - gg.copyArea(copyFromRightStart, y, widthToCopy, repeatHeight, + gg.copyArea(copyFromRightStart, y, widthToCopy, heightToCopy, positions * charWidth, 0); - if (y + repeatHeight < getHeight()) - { - gg.copyArea(labelWidthWest, y + repeatHeight, -positions - * charWidth, repeatHeight, widthToCopy, -repeatHeight); - } - - if (av.getScaleLeftWrapped()) - { - drawVerticalScale(gg, xpos, xpos + viewportWidth, y + hgap, true); - } - if (av.getScaleRightWrapped()) + if (y + wrappedRepeatHeightPx < canvasHeight - wrappedRepeatHeightPx + && (xpos + viewportWidth <= xMax)) { - drawVerticalScale(gg, xpos, xpos + viewportWidth, y + hgap, false); + gg.copyArea(labelWidthWest, y + wrappedRepeatHeightPx, -positions + * charWidth, heightToCopy, widthToCopy, + -wrappedRepeatHeightPx); } - y += repeatHeight; - xpos += ranges.getViewportWidth(); + 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 @@ -1476,11 +2035,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(); @@ -1579,23 +2140,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; } }