X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqCanvas.java;h=fb6a10b0205de2701d59ae3d3ba8cc447b72cb18;hb=8bad895e6c09890ad9676c5f6d77645d3774195d;hp=54abcc2b88c8dd4917ffd80a3d4525a69cda9b9e;hpb=cca50cb3aee94f3ed1a5e504d45b8d8b665f8c5b;p=jalview.git diff --git a/src/jalview/gui/SeqCanvas.java b/src/jalview/gui/SeqCanvas.java index 54abcc2..fb6a10b 100755 --- a/src/jalview/gui/SeqCanvas.java +++ b/src/jalview/gui/SeqCanvas.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2) - * Copyright (C) 2014 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -21,10 +21,16 @@ package jalview.gui; import jalview.datamodel.AlignmentI; -import jalview.datamodel.SearchResults; +import jalview.datamodel.HiddenColumns; +import jalview.datamodel.SearchResultsI; import jalview.datamodel.SequenceGroup; import jalview.datamodel.SequenceI; +import jalview.renderer.ScaleRenderer; +import jalview.renderer.ScaleRenderer.ScaleMark; +import jalview.viewmodel.ViewportListenerI; +import jalview.viewmodel.ViewportRanges; +import java.awt.AlphaComposite; import java.awt.BasicStroke; import java.awt.BorderLayout; import java.awt.Color; @@ -34,6 +40,8 @@ import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.Shape; import java.awt.image.BufferedImage; +import java.beans.PropertyChangeEvent; +import java.util.List; import javax.swing.JComponent; @@ -43,24 +51,18 @@ import javax.swing.JComponent; * @author $author$ * @version $Revision$ */ -public class SeqCanvas extends JComponent +public class SeqCanvas extends JComponent implements ViewportListenerI { final FeatureRenderer fr; - final SequenceRenderer sr; + final SequenceRenderer seqRdr; BufferedImage img; Graphics2D gg; - int imgWidth; - - int imgHeight; - AlignViewport av; - SearchResults searchResults = null; - boolean fastPaint = false; int LABEL_WEST; @@ -71,6 +73,12 @@ public class SeqCanvas extends JComponent int cursorY = 0; + int charHeight = 0; + + int charWidth = 0; + + boolean fastpainting = false; + /** * Creates a new SeqCanvas object. * @@ -80,16 +88,19 @@ public class SeqCanvas extends JComponent public SeqCanvas(AlignmentPanel ap) { this.av = ap.av; + updateViewport(); fr = new FeatureRenderer(ap); - sr = new SequenceRenderer(av); + seqRdr = new SequenceRenderer(av); setLayout(new BorderLayout()); PaintRefresher.Register(this, av.getSequenceSetId()); setBackground(Color.white); + + av.getRanges().addPropertyChangeListener(this); } public SequenceRenderer getSequenceRenderer() { - return sr; + return seqRdr; } public FeatureRenderer getFeatureRenderer() @@ -97,6 +108,12 @@ public class SeqCanvas extends JComponent return fr; } + private void updateViewport() + { + charHeight = av.getCharHeight(); + charWidth = av.getCharWidth(); + } + /** * DOCUMENT ME! * @@ -109,28 +126,29 @@ public class SeqCanvas extends JComponent * @param ypos * DOCUMENT ME! */ - void drawNorthScale(Graphics g, int startx, int endx, int ypos) + private void drawNorthScale(Graphics g, int startx, int endx, int ypos) { - int scalestartx = startx - (startx % 10) + 10; - - g.setColor(Color.black); - - // NORTH SCALE - for (int i = scalestartx; i < endx; i += 10) + updateViewport(); + for (ScaleMark mark : new ScaleRenderer().calculateMarks(av, startx, + endx)) { - int value = i; - if (av.hasHiddenColumns()) + int mpos = mark.column; // (i - startx - 1) + if (mpos < 0) { - value = av.getColumnSelection().adjustForHiddenColumns(value); + continue; } + String mstring = mark.text; - g.drawString(String.valueOf(value), (i - startx - 1) * av.charWidth, - ypos - (av.charHeight / 2)); - - g.drawLine(((i - startx - 1) * av.charWidth) + (av.charWidth / 2), - (ypos + 2) - (av.charHeight / 2), - ((i - startx - 1) * av.charWidth) + (av.charWidth / 2), - ypos - 2); + if (mark.major) + { + if (mstring != null) + { + g.drawString(mstring, mpos * charWidth, ypos - (charHeight / 2)); + } + g.drawLine((mpos * charWidth) + (charWidth / 2), (ypos + 2) + - (charHeight / 2), (mpos * charWidth) + (charWidth / 2), + ypos - 2); + } } } @@ -149,18 +167,21 @@ public class SeqCanvas extends JComponent void drawWestScale(Graphics g, int startx, int endx, int ypos) { FontMetrics fm = getFontMetrics(av.getFont()); - ypos += av.charHeight; + ypos += charHeight; if (av.hasHiddenColumns()) { - startx = av.getColumnSelection().adjustForHiddenColumns(startx); - endx = av.getColumnSelection().adjustForHiddenColumns(endx); + startx = av.getAlignment().getHiddenColumns() + .adjustForHiddenColumns(startx); + endx = av.getAlignment().getHiddenColumns() + .adjustForHiddenColumns(endx); } int maxwidth = av.getAlignment().getWidth(); if (av.hasHiddenColumns()) { - maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1; + maxwidth = av.getAlignment().getHiddenColumns() + .findColumnPosition(maxwidth) - 1; } // WEST SCALE @@ -187,9 +208,9 @@ public class SeqCanvas extends JComponent if (value != -1) { int x = LABEL_WEST - fm.stringWidth(String.valueOf(value)) - - av.charWidth / 2; - g.drawString(value + "", x, (ypos + (i * av.charHeight)) - - (av.charHeight / 5)); + - charWidth / 2; + g.drawString(value + "", x, (ypos + (i * charHeight)) + - (charHeight / 5)); } } } @@ -208,11 +229,12 @@ public class SeqCanvas extends JComponent */ void drawEastScale(Graphics g, int startx, int endx, int ypos) { - ypos += av.charHeight; + ypos += charHeight; if (av.hasHiddenColumns()) { - endx = av.getColumnSelection().adjustForHiddenColumns(endx); + endx = av.getAlignment().getHiddenColumns() + .adjustForHiddenColumns(endx); } SequenceI seq; @@ -239,13 +261,12 @@ public class SeqCanvas extends JComponent if (value != -1) { - g.drawString(String.valueOf(value), 0, (ypos + (i * av.charHeight)) - - (av.charHeight / 5)); + g.drawString(String.valueOf(value), 0, (ypos + (i * charHeight)) + - (charHeight / 5)); } } } - boolean fastpainting = false; /** * need to make this thread safe move alignment rendering in response to @@ -264,48 +285,49 @@ public class SeqCanvas extends JComponent } fastpainting = true; fastPaint = true; + updateViewport(); - gg.copyArea(horizontal * av.charWidth, vertical * av.charHeight, - imgWidth, imgHeight, -horizontal * av.charWidth, -vertical - * av.charHeight); - - int sr = av.startRes; - int er = av.endRes; - int ss = av.startSeq; - int es = av.endSeq; + ViewportRanges ranges = av.getRanges(); + int sr = ranges.getStartRes(); + int er = ranges.getEndRes(); + int ss = ranges.getStartSeq(); + int es = ranges.getEndSeq(); int transX = 0; int transY = 0; + gg.copyArea(horizontal * charWidth, vertical * charHeight, + img.getWidth(), img.getHeight(), -horizontal * charWidth, + -vertical * charHeight); + if (horizontal > 0) // scrollbar pulled right, image to the left { - er++; - transX = (er - sr - horizontal) * av.charWidth; + transX = (er - sr - horizontal) * charWidth; sr = er - horizontal; } else if (horizontal < 0) { - er = sr - horizontal - 1; + er = sr - horizontal; } else if (vertical > 0) // scroll down { ss = es - vertical; - if (ss < av.startSeq) + if (ss < ranges.getStartSeq()) { // ie scrolling too fast, more than a page at a time - ss = av.startSeq; + ss = ranges.getStartSeq(); } else { - transY = imgHeight - (vertical * av.charHeight); + transY = img.getHeight() - ((vertical + 1) * charHeight); } } else if (vertical < 0) { es = ss - vertical; - if (es > av.endSeq) + if (es > ranges.getEndSeq()) { - es = av.endSeq; + es = ranges.getEndSeq(); } } @@ -327,73 +349,134 @@ public class SeqCanvas extends JComponent */ // Set this to false to force a full panel paint + @Override public void paintComponent(Graphics g) { - BufferedImage lcimg = img; // take reference since other threads may null - // img and call later. super.paintComponent(g); - if (lcimg != null - && (fastPaint - || (getVisibleRect().width != g.getClipBounds().width) || (getVisibleRect().height != g - .getClipBounds().height))) - { - g.drawImage(lcimg, 0, 0, this); - fastPaint = false; - return; - } + updateViewport(); - // this draws the whole of the alignment - imgWidth = getWidth(); - imgHeight = getHeight(); + ViewportRanges ranges = av.getRanges(); - imgWidth -= (imgWidth % av.charWidth); - imgHeight -= (imgHeight % av.charHeight); + int width = getWidth(); + int height = getHeight(); - if ((imgWidth < 1) || (imgHeight < 1)) + width -= (width % charWidth); + height -= (height % charHeight); + + // selectImage is the selection group outline image + BufferedImage selectImage = drawSelectionGroup( + ranges.getStartRes(), ranges.getEndRes(), + ranges.getStartSeq(), ranges.getEndSeq()); + + if (fastPaint || (getVisibleRect().width != g.getClipBounds().width) + || (getVisibleRect().height != g.getClipBounds().height)) { - return; + BufferedImage lcimg = buildLocalImage(selectImage); + g.drawImage(lcimg, 0, 0, this); + fastPaint = false; } - - if (lcimg == null || imgWidth != lcimg.getWidth() - || imgHeight != lcimg.getHeight()) + else if ((width > 0) && (height > 0)) { - try + // img is a cached version of the last view we drew, if any + // if we have no img or the size has changed, make a new one + if (img == null || width != img.getWidth() + || height != img.getHeight()) { - lcimg = img = new BufferedImage(imgWidth, imgHeight, - BufferedImage.TYPE_INT_RGB); + img = setupImage(); + if (img == null) + { + return; + } gg = (Graphics2D) img.getGraphics(); gg.setFont(av.getFont()); - } catch (OutOfMemoryError er) + } + + if (av.antiAlias) { - System.gc(); - System.err.println("SeqCanvas OutOfMemory Redraw Error.\n" + er); - new OOMWarning("Creating alignment image for display", er); + gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_ON); + } - return; + gg.setColor(Color.white); + gg.fillRect(0, 0, img.getWidth(), img.getHeight()); + + if (av.getWrapAlignment()) + { + drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes()); } + else + { + drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(), + ranges.getStartSeq(), ranges.getEndSeq(), 0); + } + + // lcimg is a local *copy* of img which we'll draw selectImage on top of + BufferedImage lcimg = buildLocalImage(selectImage); + g.drawImage(lcimg, 0, 0, this); } + } - if (av.antiAlias) + /* + * Make a local image by combining the cached image img + * with any selection + */ + private BufferedImage buildLocalImage(BufferedImage selectImage) + { + // clone the cached image + BufferedImage lcimg = new BufferedImage(img.getWidth(), img.getHeight(), + img.getType()); + Graphics2D g2d = lcimg.createGraphics(); + g2d.drawImage(img, 0, 0, null); + + // overlay selection group on lcimg + if (selectImage != null) { - gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING, - RenderingHints.VALUE_ANTIALIAS_ON); + g2d.setComposite( + AlphaComposite.getInstance(AlphaComposite.SRC_OVER)); + g2d.drawImage(selectImage, 0, 0, this); } + g2d.dispose(); - gg.setColor(Color.white); - gg.fillRect(0, 0, imgWidth, imgHeight); + return lcimg; + } - if (av.getWrapAlignment()) + private void paintSeqGroup() + { + fastPaint = true; + repaint(); + } + + private BufferedImage setupImage() + { + BufferedImage lcimg = null; + + int width = getWidth(); + int height = getHeight(); + + width -= (width % charWidth); + height -= (height % charHeight); + + if ((width < 1) || (height < 1)) { - drawWrappedPanel(gg, getWidth(), getHeight(), av.startRes); + return null; } - else + + try { - drawPanel(gg, av.startRes, av.endRes, av.startSeq, av.endSeq, 0); - } + lcimg = new BufferedImage(width, height, + BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works + } catch (OutOfMemoryError er) + { + System.gc(); + System.err.println( + "Selection 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; } /** @@ -411,17 +494,17 @@ public class SeqCanvas extends JComponent LABEL_EAST = 0; LABEL_WEST = 0; - if (av.scaleRightWrapped) + if (av.getScaleRightWrapped()) { LABEL_EAST = fm.stringWidth(getMask()); } - if (av.scaleLeftWrapped) + if (av.getScaleLeftWrapped()) { LABEL_WEST = fm.stringWidth(getMask()); } - return (cwidth - LABEL_EAST - LABEL_WEST) / av.charWidth; + return (cwidth - LABEL_EAST - LABEL_WEST) / charWidth; } /** @@ -465,40 +548,45 @@ public class SeqCanvas extends JComponent public void drawWrappedPanel(Graphics g, int canvasWidth, int canvasHeight, int startRes) { + updateViewport(); AlignmentI al = av.getAlignment(); FontMetrics fm = getFontMetrics(av.getFont()); - if (av.scaleRightWrapped) + LABEL_EAST = 0; + LABEL_WEST = 0; + + if (av.getScaleRightWrapped()) { LABEL_EAST = fm.stringWidth(getMask()); } - if (av.scaleLeftWrapped) + if (av.getScaleLeftWrapped()) { LABEL_WEST = fm.stringWidth(getMask()); } - int hgap = av.charHeight; - if (av.scaleAboveWrapped) + int hgap = charHeight; + if (av.getScaleAboveWrapped()) { - hgap += av.charHeight; + hgap += charHeight; } - int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / av.charWidth; - int cHeight = av.getAlignment().getHeight() * av.charHeight; + int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / charWidth; + int cHeight = av.getAlignment().getHeight() * charHeight; av.setWrappedWidth(cWidth); - av.endRes = av.startRes + cWidth; + av.getRanges().setViewportStartAndWidth(startRes, cWidth); int endx; int ypos = hgap; - int maxwidth = av.getAlignment().getWidth() - 1; + int maxwidth = av.getAlignment().getWidth(); if (av.hasHiddenColumns()) { - maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1; + maxwidth = av.getAlignment().getHiddenColumns() + .findColumnPosition(maxwidth); } while ((ypos <= canvasHeight) && (startRes < maxwidth)) @@ -513,12 +601,12 @@ public class SeqCanvas extends JComponent g.setFont(av.getFont()); g.setColor(Color.black); - if (av.scaleLeftWrapped) + if (av.getScaleLeftWrapped()) { drawWestScale(g, startRes, endx, ypos); } - if (av.scaleRightWrapped) + if (av.getScaleRightWrapped()) { g.translate(canvasWidth - LABEL_EAST, 0); drawEastScale(g, startRes, endx, ypos); @@ -527,32 +615,32 @@ public class SeqCanvas extends JComponent g.translate(LABEL_WEST, 0); - if (av.scaleAboveWrapped) + if (av.getScaleAboveWrapped()) { drawNorthScale(g, startRes, endx, ypos); } - if (av.hasHiddenColumns() && av.showHiddenMarkers) + if (av.hasHiddenColumns() && av.getShowHiddenMarkers()) { g.setColor(Color.blue); int res; - for (int i = 0; i < av.getColumnSelection().getHiddenColumns() - .size(); i++) + HiddenColumns hidden = av.getAlignment().getHiddenColumns(); + List positions = hidden.findHiddenRegionPositions(); + for (int pos : positions) { - res = av.getColumnSelection().findHiddenRegionPosition(i) - - startRes; + res = pos - startRes; if (res < 0 || res > endx - startRes) { continue; } - gg.fillPolygon(new int[] - { res * av.charWidth - av.charHeight / 4, - res * av.charWidth + av.charHeight / 4, res * av.charWidth }, - new int[] - { ypos - (av.charHeight / 2), ypos - (av.charHeight / 2), - ypos - (av.charHeight / 2) + 8 }, 3); + 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); } } @@ -563,15 +651,15 @@ public class SeqCanvas extends JComponent if (clip == null) { - g.setClip(0, 0, cWidth * av.charWidth, canvasHeight); + g.setClip(0, 0, cWidth * charWidth, canvasHeight); } else { - g.setClip(0, (int) clip.getBounds().getY(), cWidth * av.charWidth, + g.setClip(0, (int) clip.getBounds().getY(), cWidth * charWidth, (int) clip.getBounds().getHeight()); } - drawPanel(g, startRes, endx, 0, al.getHeight(), ypos); + drawPanel(g, startRes, endx, 0, al.getHeight() - 1, ypos); if (av.isShowAnnotation()) { @@ -581,8 +669,8 @@ public class SeqCanvas extends JComponent annotations = new AnnotationPanel(av); } - annotations.renderer.drawComponent(annotations, av, g, - -1, startRes, endx + 1); + annotations.renderer.drawComponent(annotations, av, g, -1, + startRes, endx + 1); g.translate(0, -cHeight - ypos - 3); } g.setClip(clip); @@ -594,6 +682,62 @@ public class SeqCanvas extends JComponent } } + /* + * Draw a selection group over a wrapped alignment + */ + private void drawWrappedSelection(Graphics2D g, SequenceGroup group, + int canvasWidth, + int canvasHeight, int startRes) + { + // height gap above each panel + int hgap = charHeight; + if (av.getScaleAboveWrapped()) + { + hgap += charHeight; + } + + int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / charWidth; + int cHeight = av.getAlignment().getHeight() * charHeight; + + int startx = startRes; + int endx; + int ypos = hgap; // vertical offset + int maxwidth = av.getAlignment().getWidth(); + + if (av.hasHiddenColumns()) + { + maxwidth = av.getAlignment().getHiddenColumns() + .findColumnPosition(maxwidth); + } + + // chop the wrapped alignment extent up into panel-sized blocks and treat + // each block as if it were a block from an unwrapped alignment + while ((ypos <= canvasHeight) && (startx < maxwidth)) + { + // set end value to be start + width, or maxwidth, whichever is smaller + endx = startx + cWidth - 1; + + if (endx > maxwidth) + { + endx = maxwidth; + } + + g.translate(LABEL_WEST, 0); + + drawUnwrappedSelection(g, group, startx, endx, 0, + av.getAlignment().getHeight() - 1, + ypos); + + g.translate(-LABEL_WEST, 0); + + // update vertical offset + ypos += cHeight + getAnnotationHeight() + hgap; + + // update horizontal offset + startx += cWidth; + } + } + AnnotationPanel annotations; int getAnnotationHeight() @@ -628,24 +772,22 @@ public class SeqCanvas extends JComponent * DOCUMENT ME! */ public void drawPanel(Graphics g1, int startRes, int endRes, - int startSeq, - int endSeq, int offset) + int startSeq, int endSeq, int offset) { + updateViewport(); if (!av.hasHiddenColumns()) { draw(g1, startRes, endRes, startSeq, endSeq, offset); } else { - java.util.Vector regions = av.getColumnSelection().getHiddenColumns(); - int screenY = 0; int blockStart = startRes; int blockEnd = endRes; - for (int i = 0; regions != null && i < regions.size(); i++) + for (int[] region : av.getAlignment().getHiddenColumns() + .getHiddenColumnsCopy()) { - int[] region = (int[]) regions.elementAt(i); int hideStart = region[0]; int hideEnd = region[1]; @@ -657,7 +799,7 @@ public class SeqCanvas extends JComponent blockEnd = hideStart - 1; - g1.translate(screenY * av.charWidth, 0); + g1.translate(screenY * charWidth, 0); draw(g1, blockStart, blockEnd, startSeq, endSeq, offset); @@ -665,41 +807,46 @@ public class SeqCanvas extends JComponent { g1.setColor(Color.blue); - g1.drawLine((blockEnd - blockStart + 1) * av.charWidth - 1, - 0 + offset, (blockEnd - blockStart + 1) * av.charWidth - - 1, (endSeq - startSeq) * av.charHeight + offset); + g1.drawLine((blockEnd - blockStart + 1) * charWidth - 1, + 0 + offset, (blockEnd - blockStart + 1) * charWidth - 1, + (endSeq - startSeq + 1) * charHeight + offset); } - g1.translate(-screenY * av.charWidth, 0); + g1.translate(-screenY * charWidth, 0); screenY += blockEnd - blockStart + 1; blockStart = hideEnd + 1; + + if (screenY > (endRes - startRes)) + { + // already rendered last block + return; + } } if (screenY <= (endRes - startRes)) { + // remaining visible region to render blockEnd = blockStart + (endRes - startRes) - screenY; - g1.translate(screenY * av.charWidth, 0); + g1.translate(screenY * charWidth, 0); draw(g1, blockStart, blockEnd, startSeq, endSeq, offset); - g1.translate(-screenY * av.charWidth, 0); + g1.translate(-screenY * charWidth, 0); } } } - // int startRes, int endRes, int startSeq, int endSeq, int x, int y, - // int x1, int x2, int y1, int y2, int startx, int starty, - void draw(Graphics g, int startRes, int endRes, int startSeq, int endSeq, - int offset) + private void draw(Graphics g, int startRes, int endRes, int startSeq, + int endSeq, int offset) { g.setFont(av.getFont()); - sr.prepare(g, av.renderGaps); + seqRdr.prepare(g, av.isRenderGaps()); SequenceI nextSeq; // / First draw the sequences // /////////////////////////// - for (int i = startSeq; i < endSeq; i++) + for (int i = startSeq; i <= endSeq; i++) { nextSeq = av.getAlignment().getSequenceAt(i); if (nextSeq == null) @@ -708,29 +855,29 @@ public class SeqCanvas extends JComponent // empty continue; } - sr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq), - startRes, endRes, offset + ((i - startSeq) * av.charHeight)); + seqRdr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq), + startRes, endRes, offset + ((i - startSeq) * charHeight)); - if (av.showSequenceFeatures) + if (av.isShowSequenceFeatures()) { fr.drawSequence(g, nextSeq, startRes, endRes, offset - + ((i - startSeq) * av.charHeight)); + + ((i - startSeq) * charHeight), false); } // / Highlight search Results once all sequences have been drawn // //////////////////////////////////////////////////////// - if (searchResults != null) + if (av.hasSearchResults()) { - int[] visibleResults = searchResults.getResults(nextSeq, startRes, - endRes); + int[] visibleResults = av.getSearchResults().getResults(nextSeq, + startRes, endRes); if (visibleResults != null) { for (int r = 0; r < visibleResults.length; r += 2) { - sr.drawHighlightedText(nextSeq, visibleResults[r], + seqRdr.drawHighlightedText(nextSeq, visibleResults[r], visibleResults[r + 1], (visibleResults[r] - startRes) - * av.charWidth, offset - + ((i - startSeq) * av.charHeight)); + * charWidth, offset + + ((i - startSeq) * charHeight)); } } } @@ -738,9 +885,8 @@ public class SeqCanvas extends JComponent if (av.cursorMode && cursorY == i && cursorX >= startRes && cursorX <= endRes) { - sr.drawCursor(nextSeq, cursorX, - (cursorX - startRes) * av.charWidth, offset - + ((i - startSeq) * av.charHeight)); + seqRdr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth, + offset + ((i - startSeq) * charHeight)); } } @@ -760,15 +906,16 @@ public class SeqCanvas extends JComponent // /////////////////////////////////// // Now outline any areas if necessary // /////////////////////////////////// - SequenceGroup group = av.getSelectionGroup(); + + SequenceGroup group = null; int sx = -1; int sy = -1; int ex = -1; int groupIndex = -1; - int visWidth = (endRes - startRes + 1) * av.charWidth; + int visWidth = (endRes - startRes + 1) * charWidth; - if ((group == null) && (av.getAlignment().getGroups().size() > 0)) + if (av.getAlignment().getGroups().size() > 0) { group = av.getAlignment().getGroups().get(0); groupIndex = 0; @@ -776,26 +923,35 @@ public class SeqCanvas extends JComponent if (group != null) { + g.setStroke(new BasicStroke()); + g.setColor(group.getOutlineColour()); + do { + + // drawSelectionGroupPart(g, group, startRes, endRes, startSeq, + // endSeq,offset); int oldY = -1; int i = 0; boolean inGroup = false; int top = -1; int bottom = -1; - for (i = startSeq; i < endSeq; i++) + for (i = startSeq; i <= endSeq; i++) { - sx = (group.getStartRes() - startRes) * av.charWidth; - sy = offset + ((i - startSeq) * av.charHeight); - ex = (((group.getEndRes() + 1) - group.getStartRes()) * av.charWidth) - 1; + // position of start residue of group relative to startRes, in pixels + sx = (group.getStartRes() - startRes) * charWidth; + sy = offset + ((i - startSeq) * charHeight); + // width of group in pixels + ex = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth) + - 1; if (sx + ex < 0 || sx > visWidth) { continue; } - if ((sx <= (endRes - startRes) * av.charWidth) + if ((sx <= (endRes - startRes) * charWidth) && group.getSequences(null).contains( av.getAlignment().getSequenceAt(i))) { @@ -803,7 +959,7 @@ public class SeqCanvas extends JComponent && !group.getSequences(null).contains( av.getAlignment().getSequenceAt(i + 1))) { - bottom = sy + av.charHeight; + bottom = sy + charHeight; } if (!inGroup) @@ -818,29 +974,23 @@ public class SeqCanvas extends JComponent oldY = sy; inGroup = true; - if (group == av.getSelectionGroup()) - { - g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT, - BasicStroke.JOIN_ROUND, 3f, new float[] - { 5f, 3f }, 0f)); - g.setColor(Color.RED); - } - else - { - g.setStroke(new BasicStroke()); - g.setColor(group.getOutlineColour()); - } + g.setStroke(new BasicStroke()); + g.setColor(group.getOutlineColour()); } } else { if (inGroup) { + // if start position is visible, draw vertical line to left of + // group if (sx >= 0 && sx < visWidth) { g.drawLine(sx, oldY, sx, sy); } + // if end position is visible, draw vertical line to right of + // group if (sx + ex < visWidth) { g.drawLine(sx + ex, oldY, sx + ex, sy); @@ -856,18 +1006,19 @@ public class SeqCanvas extends JComponent { ex = visWidth; } - - else if (sx + ex >= (endRes - startRes + 1) * av.charWidth) + else if (sx + ex >= (endRes - startRes + 1) * charWidth) { - ex = (endRes - startRes + 1) * av.charWidth; + ex = (endRes - startRes + 1) * charWidth; } + // draw horizontal line at top of group if (top != -1) { g.drawLine(sx, top, sx + ex, top); top = -1; } + // draw horizontal line at bottom of group if (bottom != -1) { g.drawLine(sx, bottom, sx + ex, bottom); @@ -881,7 +1032,7 @@ public class SeqCanvas extends JComponent if (inGroup) { - sy = offset + ((i - startSeq) * av.charHeight); + sy = offset + ((i - startSeq) * charHeight); if (sx >= 0 && sx < visWidth) { g.drawLine(sx, oldY, sx, sy); @@ -902,9 +1053,9 @@ public class SeqCanvas extends JComponent { ex = visWidth; } - else if (sx + ex >= (endRes - startRes + 1) * av.charWidth) + else if (sx + ex >= (endRes - startRes + 1) * charWidth) { - ex = (endRes - startRes + 1) * av.charWidth; + ex = (endRes - startRes + 1) * charWidth; } if (top != -1) @@ -931,8 +1082,7 @@ public class SeqCanvas extends JComponent break; } - group = av.getAlignment().getGroups() - .get(groupIndex); + group = av.getAlignment().getGroups().get(groupIndex); } while (groupIndex < av.getAlignment().getGroups().size()); @@ -940,18 +1090,339 @@ public class SeqCanvas extends JComponent } + + /* + * 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(); + + // 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 (!av.getWrapAlignment()) + { + drawUnwrappedSelection(g, group, startRes, endRes, startSeq, endSeq, + 0); + } + else + { + drawWrappedSelection(g, group, getWidth(), getHeight(), + av.getRanges().getStartRes()); + } + + g.dispose(); + return selectionImage; + } + + /* + * Draw a selection group over an unwrapped alignment + * @param g graphics object to draw with + * @param group selection group + * @param startRes start residue of area to draw + * @param endRes end residue of area to draw + * @param startSeq start sequence of area to draw + * @param endSeq end sequence of area to draw + * @param offset vertical offset (used when called from wrapped alignment code) + */ + private void drawUnwrappedSelection(Graphics2D g, SequenceGroup group, + int startRes, int endRes, int startSeq, int endSeq, int offset) + { + if (!av.hasHiddenColumns()) + { + drawSelectionGroupPart(g, group, startRes, endRes, startSeq, endSeq, + offset); + } + else + { + // package into blocks of visible columns + int screenY = 0; + int blockStart = startRes; + int blockEnd = endRes; + + for (int[] region : av.getAlignment().getHiddenColumns() + .getHiddenColumnsCopy()) + { + int hideStart = region[0]; + int hideEnd = region[1]; + + if (hideStart <= blockStart) + { + blockStart += (hideEnd - hideStart) + 1; + continue; + } + + blockEnd = hideStart - 1; + + g.translate(screenY * charWidth, 0); + drawSelectionGroupPart(g, group, + blockStart, blockEnd, startSeq, endSeq, offset); + + g.translate(-screenY * charWidth, 0); + screenY += blockEnd - blockStart + 1; + blockStart = hideEnd + 1; + + if (screenY > (endRes - startRes)) + { + // already rendered last block + break; + } + } + + if (screenY <= (endRes - startRes)) + { + // remaining visible region to render + blockEnd = blockStart + (endRes - startRes) - screenY; + g.translate(screenY * charWidth, 0); + drawSelectionGroupPart(g, group, + blockStart, blockEnd, startSeq, endSeq, offset); + + g.translate(-screenY * charWidth, 0); + } + } + } + + /* + * Draw the selection group as a separate image and overlay + */ + private void drawSelectionGroupPart(Graphics2D g, SequenceGroup group, + int startRes, int endRes, int startSeq, int endSeq, + int verticalOffset) + { + int visWidth = (endRes - startRes + 1) * charWidth; + + int oldY = -1; + int i = 0; + boolean inGroup = false; + int top = -1; + int bottom = -1; + + int sx = -1; + int sy = -1; + int xwidth = -1; + + for (i = startSeq; i <= endSeq; i++) + { + // position of start residue of group relative to startRes, in pixels + sx = (group.getStartRes() - startRes) * charWidth; + + // width of group in pixels + xwidth = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth) + - 1; + + sy = verticalOffset + (i - startSeq) * charHeight; + + if (sx + xwidth < 0 || sx > visWidth) + { + continue; + } + + if ((sx <= (endRes - startRes) * charWidth) + && group.getSequences(null) + .contains(av.getAlignment().getSequenceAt(i))) + { + if ((bottom == -1) && !group.getSequences(null) + .contains(av.getAlignment().getSequenceAt(i + 1))) + { + bottom = sy + charHeight; + } + + if (!inGroup) + { + if (((top == -1) && (i == 0)) || !group.getSequences(null) + .contains(av.getAlignment().getSequenceAt(i - 1))) + { + top = sy; + } + + oldY = sy; + inGroup = true; + } + } + else + { + if (inGroup) + { + // if start position is visible, draw vertical line to left of + // group + if (sx >= 0 && sx < visWidth) + { + g.drawLine(sx, oldY, sx, sy); + } + + // if end position is visible, draw vertical line to right of + // group + if (sx + xwidth < visWidth) + { + g.drawLine(sx + xwidth, oldY, sx + xwidth, sy); + } + + if (sx < 0) + { + xwidth += sx; + sx = 0; + } + + if (sx + xwidth >= (endRes - startRes + 1) * charWidth) + { + xwidth = (endRes - startRes + 1) * charWidth - sx; + } + + // draw horizontal line at top of group + if (top != -1) + { + g.drawLine(sx, top, sx + xwidth, top); + top = -1; + } + + // draw horizontal line at bottom of group + if (bottom != -1) + { + g.drawLine(sx, bottom, sx + xwidth, bottom); + bottom = -1; + } + + inGroup = false; + } + } + } + + if (inGroup) + { + sy = verticalOffset + ((i - startSeq) * charHeight); + if (sx >= 0 && sx < visWidth) + { + g.drawLine(sx, oldY, sx, sy); + } + + if (sx + xwidth < visWidth) + { + g.drawLine(sx + xwidth, oldY, sx + xwidth, sy); + } + + if (sx < 0) + { + xwidth += sx; + sx = 0; + } + + if (sx + xwidth > visWidth) + { + xwidth = visWidth; + } + else if (sx + xwidth >= (endRes - startRes + 1) * charWidth) + { + xwidth = (endRes - startRes + 1) * charWidth; + } + + if (top != -1) + { + g.drawLine(sx, top, sx + xwidth, top); + top = -1; + } + + if (bottom != -1) + { + g.drawLine(sx, bottom - 1, sx + xwidth, bottom - 1); + bottom = -1; + } + + inGroup = false; + } + } + /** * DOCUMENT ME! * * @param results * DOCUMENT ME! */ - public void highlightSearchResults(SearchResults results) + public void highlightSearchResults(SearchResultsI results) { img = null; - searchResults = results; + av.setSearchResults(results); repaint(); } + + @Override + public void propertyChange(PropertyChangeEvent evt) + { + String eventName = evt.getPropertyName(); + + if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED)) + { + paintSeqGroup(); + } + else if (av.getWrapAlignment()) + { + if (eventName.equals(ViewportRanges.STARTRES)) + { + repaint(); + } + } + else + { + int scrollX = 0; + if (eventName.equals(ViewportRanges.STARTRES)) + { + // Make sure we're not trying to draw a panel + // larger than the visible window + ViewportRanges vpRanges = av.getRanges(); + scrollX = (int) evt.getNewValue() - (int) evt.getOldValue(); + int range = vpRanges.getEndRes() - vpRanges.getStartRes(); + if (scrollX > range) + { + scrollX = range; + } + else if (scrollX < -range) + { + scrollX = -range; + } + } + + // Both scrolling and resizing change viewport ranges: scrolling changes + // both start and end points, but resize only changes end values. + // Here we only want to fastpaint on a scroll, with resize using a normal + // paint, so scroll events are identified as changes to the horizontal or + // vertical start value. + if (eventName.equals(ViewportRanges.STARTRES)) + { + // scroll - startres and endres both change + fastPaint(scrollX, 0); + } + else if (eventName.equals(ViewportRanges.STARTSEQ)) + { + // scroll + fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue()); + } + } + } }