X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqCanvas.java;h=0e312461ab54154139e2a931e9a77578048136c9;hb=182059d079ef2563d139ab1f0721c466cd648c02;hp=52e584977fab987bea6f73f768df887a5bec6cdb;hpb=43141b2f7afda8dbb88090d0630574b1cdefb0eb;p=jalview.git diff --git a/src/jalview/gui/SeqCanvas.java b/src/jalview/gui/SeqCanvas.java index 52e5849..0e31246 100755 --- a/src/jalview/gui/SeqCanvas.java +++ b/src/jalview/gui/SeqCanvas.java @@ -52,6 +52,8 @@ import javax.swing.JComponent; */ public class SeqCanvas extends JComponent implements ViewportListenerI { + private static String ZEROS = "0000000000"; + final FeatureRenderer fr; final SequenceRenderer sr; @@ -68,9 +70,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI boolean fastPaint = false; - int LABEL_WEST; + int labelWidthWest; - int LABEL_EAST; + int labelWidthEast; int cursorX = 0; @@ -206,7 +208,7 @@ public class SeqCanvas extends JComponent implements ViewportListenerI if (value != -1) { - int x = LABEL_WEST - fm.stringWidth(String.valueOf(value)) + int x = labelWidthWest - fm.stringWidth(String.valueOf(value)) - charWidth / 2; g.drawString(value + "", x, (ypos + (i * charHeight)) - (charHeight / 5)); @@ -286,8 +288,6 @@ public class SeqCanvas extends JComponent implements ViewportListenerI fastpainting = true; fastPaint = true; updateViewport(); - gg.copyArea(horizontal * charWidth, vertical * charHeight, imgWidth, - imgHeight, -horizontal * charWidth, -vertical * charHeight); ViewportRanges ranges = av.getRanges(); int startRes = ranges.getStartRes(); @@ -297,6 +297,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI int transX = 0; int transY = 0; + gg.copyArea(horizontal * charWidth, vertical * charHeight, imgWidth, + imgHeight, -horizontal * charWidth, -vertical * charHeight); + if (horizontal > 0) // scrollbar pulled right, image to the left { transX = (endRes - startRes - horizontal) * charWidth; @@ -411,57 +414,63 @@ public class SeqCanvas extends JComponent implements ViewportListenerI } /** - * DOCUMENT ME! + * Returns the visible width of the canvas in residues, after allowing for + * East or West scales (if shown) * - * @param cwidth - * DOCUMENT ME! + * @param canvasWidth + * the width in pixels (possibly including scales) * - * @return DOCUMENT ME! + * @return */ - public int getWrappedCanvasWidth(int cwidth) + public int getWrappedCanvasWidth(int canvasWidth) { FontMetrics fm = getFontMetrics(av.getFont()); - LABEL_EAST = 0; - LABEL_WEST = 0; + labelWidthEast = 0; + labelWidthWest = 0; if (av.getScaleRightWrapped()) { - LABEL_EAST = fm.stringWidth(getMask()); + labelWidthEast = getLabelWidth(fm); } if (av.getScaleLeftWrapped()) { - LABEL_WEST = fm.stringWidth(getMask()); + labelWidthWest = labelWidthEast > 0 ? labelWidthEast + : getLabelWidth(fm); } - return (cwidth - LABEL_EAST - LABEL_WEST) / charWidth; + return (canvasWidth - labelWidthEast - labelWidthWest) / charWidth; } /** - * Generates a string of zeroes. + * Returns a pixel width suitable for showing the largest sequence coordinate + * (end position) in the alignment. Returns 2 plus the number of decimal + * digits to be shown (3 for 1-10, 4 for 11-99 etc). * - * @return String + * @param fm + * @return */ - String getMask() + protected int getLabelWidth(FontMetrics fm) { - String mask = "00"; + /* + * find the biggest sequence end position we need to show + * (note this is not necessarily the sequence length) + */ int maxWidth = 0; - int tmp; - for (int i = 0; i < av.getAlignment().getHeight(); i++) + AlignmentI alignment = av.getAlignment(); + for (int i = 0; i < alignment.getHeight(); i++) { - tmp = av.getAlignment().getSequenceAt(i).getEnd(); - if (tmp > maxWidth) - { - maxWidth = tmp; - } + maxWidth = Math.max(maxWidth, alignment.getSequenceAt(i).getEnd()); } + int length = 2; for (int i = maxWidth; i > 0; i /= 10) { - mask += "0"; + length++; } - return mask; + + return fm.stringWidth(ZEROS.substring(0, length)); } /** @@ -482,17 +491,15 @@ public class SeqCanvas extends JComponent implements ViewportListenerI updateViewport(); AlignmentI al = av.getAlignment(); - FontMetrics fm = getFontMetrics(av.getFont()); - - if (av.getScaleRightWrapped()) + int labelWidth = 0; + if (av.getScaleRightWrapped() || av.getScaleLeftWrapped()) { - LABEL_EAST = fm.stringWidth(getMask()); + FontMetrics fm = getFontMetrics(av.getFont()); + labelWidth = getLabelWidth(fm); } - if (av.getScaleLeftWrapped()) - { - LABEL_WEST = fm.stringWidth(getMask()); - } + labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0; + labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0; int hgap = charHeight; if (av.getScaleAboveWrapped()) @@ -500,23 +507,25 @@ public class SeqCanvas extends JComponent implements ViewportListenerI hgap += charHeight; } - int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / charWidth; + int cWidth = (canvasWidth - labelWidthEast - labelWidthWest) / charWidth; int cHeight = av.getAlignment().getHeight() * charHeight; av.setWrappedWidth(cWidth); - av.getRanges().setEndRes(av.getRanges().getStartRes() + cWidth - 1); + 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.getAlignment().getHiddenColumns() - .findColumnPosition(maxwidth) - 1; + .findColumnPosition(maxwidth); } + int annotationHeight = getAnnotationHeight(); + while ((ypos <= canvasHeight) && (startRes < maxwidth)) { endx = startRes + cWidth - 1; @@ -536,12 +545,12 @@ public class SeqCanvas extends JComponent implements ViewportListenerI if (av.getScaleRightWrapped()) { - g.translate(canvasWidth - LABEL_EAST, 0); + g.translate(canvasWidth - labelWidthEast, 0); drawEastScale(g, startRes, endx, ypos); - g.translate(-(canvasWidth - LABEL_EAST), 0); + g.translate(-(canvasWidth - labelWidthEast), 0); } - g.translate(LABEL_WEST, 0); + g.translate(labelWidthWest, 0); if (av.getScaleAboveWrapped()) { @@ -553,9 +562,10 @@ public class SeqCanvas extends JComponent implements ViewportListenerI g.setColor(Color.blue); int res; HiddenColumns hidden = av.getAlignment().getHiddenColumns(); - for (int i = 0; i < hidden.getHiddenRegions().size(); i++) + List positions = hidden.findHiddenRegionPositions(); + for (int pos : positions) { - res = hidden.findHiddenRegionPosition(i) - startRes; + res = pos - startRes; if (res < 0 || res > endx - startRes) { @@ -601,9 +611,9 @@ public class SeqCanvas extends JComponent implements ViewportListenerI g.translate(0, -cHeight - ypos - 3); } g.setClip(clip); - g.translate(-LABEL_WEST, 0); + g.translate(-labelWidthWest, 0); - ypos += cHeight + getAnnotationHeight() + hgap; + ypos += cHeight + annotationHeight + hgap; startRes += cWidth; } @@ -654,15 +664,13 @@ public class SeqCanvas extends JComponent implements ViewportListenerI } else { - List regions = av.getAlignment().getHiddenColumns() - .getHiddenRegions(); - int screenY = 0; final int screenYMax = endRes - startRes; int blockStart = startRes; int blockEnd = endRes; - for (int[] region : regions) + for (int[] region : av.getAlignment().getHiddenColumns() + .getHiddenColumnsCopy()) { int hideStart = region[0]; int hideEnd = region[1]; @@ -989,18 +997,36 @@ public class SeqCanvas extends JComponent implements ViewportListenerI /** * Highlights search results in the visible region by rendering as white text - * on a black background. Any previous highlighting is removed. + * on a black background. Any previous highlighting is removed. Answers true + * if any highlight was left on the visible alignment (so status bar should be + * set to match), else false. + *

+ * Currently fastPaint is not implemented for wrapped alignments. If a wrapped + * alignment had to be scrolled to show the highlighted region, then it should + * be fully redrawn, otherwise a fast paint can be performed. This argument + * could be removed if fast paint of scrolled wrapped alignment is coded in + * future (JAL-2609). * * @param results + * @param noFastPaint + * @return */ - public void highlightSearchResults(SearchResultsI results) + public boolean highlightSearchResults(SearchResultsI results, + boolean noFastPaint) { - updateViewport(); - fastpainting = true; - fastPaint = true; + if (fastpainting) + { + return false; + } + boolean wrapped = av.getWrapAlignment(); try { + fastPaint = !noFastPaint; + fastpainting = fastPaint; + + updateViewport(); + /* * to avoid redrawing the whole visible region, we instead * redraw just the minimal regions to remove previous highlights @@ -1008,12 +1034,34 @@ public class SeqCanvas extends JComponent implements ViewportListenerI */ SearchResultsI previous = av.getSearchResults(); av.setSearchResults(results); - boolean redrawn = drawMappedPositions(previous); - redrawn |= drawMappedPositions(results); + boolean redrawn = false; + boolean drawn = false; + if (wrapped) + { + redrawn = drawMappedPositionsWrapped(previous); + drawn = drawMappedPositionsWrapped(results); + redrawn |= drawn; + } + else + { + redrawn = drawMappedPositions(previous); + drawn = drawMappedPositions(results); + redrawn |= drawn; + } + + /* + * if highlights were either removed or added, repaint + */ if (redrawn) { repaint(); } + + /* + * return true only if highlights were added + */ + return drawn; + } finally { fastpainting = false; @@ -1116,30 +1164,189 @@ public class SeqCanvas extends JComponent implements ViewportListenerI @Override public void propertyChange(PropertyChangeEvent evt) { - if (!av.getWrapAlignment()) + String eventName = evt.getPropertyName(); + + if (av.getWrapAlignment()) + { + if (eventName.equals(ViewportRanges.STARTRES)) + { + repaint(); + } + } + else { - if (evt.getPropertyName().equals("startres") - || evt.getPropertyName().equals("endres")) + 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(); - int scrollX = (int) evt.getNewValue() - (int) evt.getOldValue(); - if (scrollX > vpRanges.getEndRes() - vpRanges.getStartRes()) + scrollX = (int) evt.getNewValue() - (int) evt.getOldValue(); + int range = vpRanges.getEndRes() - vpRanges.getStartRes(); + if (scrollX > range) { - scrollX = vpRanges.getEndRes() - vpRanges.getStartRes(); + scrollX = range; } - else if (scrollX < vpRanges.getStartRes() - vpRanges.getEndRes()) + else if (scrollX < -range) { - scrollX = vpRanges.getStartRes() - vpRanges.getEndRes(); + 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 (evt.getPropertyName().equals("startseq") - || evt.getPropertyName().equals("endseq")) + else if (eventName.equals(ViewportRanges.STARTSEQ)) { + // scroll fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue()); } } } + + /** + * Redraws any positions in the search results in the visible region of a + * wrapped alignment. Any highlights are drawn depending on the search results + * set on the Viewport, not the results argument. This allows + * this method to be called either to clear highlights (passing the previous + * search results), or to draw new highlights. + * + * @param results + * @return + */ + protected boolean drawMappedPositionsWrapped(SearchResultsI results) + { + if (results == null) + { + return false; + } + + boolean matchFound = false; + + int wrappedWidth = av.getWrappedWidth(); + int wrappedHeight = getRepeatHeightWrapped(); + + ViewportRanges ranges = av.getRanges(); + int canvasHeight = getHeight(); + int repeats = canvasHeight / wrappedHeight; + if (canvasHeight / wrappedHeight > 0) + { + repeats++; + } + + int firstVisibleColumn = ranges.getStartRes(); + int lastVisibleColumn = ranges.getStartRes() + repeats + * ranges.getViewportWidth() - 1; + + AlignmentI alignment = av.getAlignment(); + if (av.hasHiddenColumns()) + { + firstVisibleColumn = alignment.getHiddenColumns() + .adjustForHiddenColumns(firstVisibleColumn); + lastVisibleColumn = alignment.getHiddenColumns() + .adjustForHiddenColumns(lastVisibleColumn); + } + + int gapHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1); + + for (int seqNo = ranges.getStartSeq(); seqNo <= ranges + .getEndSeq(); seqNo++) + { + SequenceI seq = alignment.getSequenceAt(seqNo); + + int[] visibleResults = results.getResults(seq, firstVisibleColumn, + lastVisibleColumn); + if (visibleResults != null) + { + for (int i = 0; i < visibleResults.length - 1; i += 2) + { + int firstMatchedColumn = visibleResults[i]; + int lastMatchedColumn = visibleResults[i + 1]; + if (firstMatchedColumn <= lastVisibleColumn + && lastMatchedColumn >= firstVisibleColumn) + { + /* + * found a search results match in the visible region + */ + firstMatchedColumn = Math.max(firstMatchedColumn, + firstVisibleColumn); + lastMatchedColumn = Math.min(lastMatchedColumn, + lastVisibleColumn); + + /* + * draw each mapped position separately (as contiguous positions may + * wrap across lines) + */ + for (int mappedPos = firstMatchedColumn; mappedPos <= lastMatchedColumn; mappedPos++) + { + int displayColumn = mappedPos; + if (av.hasHiddenColumns()) + { + displayColumn = alignment.getHiddenColumns() + .findColumnPosition(displayColumn); + } + + /* + * transX: offset from left edge of canvas to residue position + */ + int transX = labelWidthWest + + ((displayColumn - ranges.getStartRes()) % wrappedWidth) + * av.getCharWidth(); + + /* + * transY: offset from top edge of canvas to residue position + */ + int transY = gapHeight; + transY += (displayColumn - ranges.getStartRes()) + / wrappedWidth * wrappedHeight; + transY += (seqNo - ranges.getStartSeq()) * av.getCharHeight(); + + /* + * yOffset is from graphics origin to start of visible region + */ + int yOffset = 0;// (displayColumn / wrappedWidth) * wrappedHeight; + if (transY < getHeight()) + { + matchFound = true; + gg.translate(transX, transY); + drawPanel(gg, displayColumn, displayColumn, seqNo, seqNo, + yOffset); + gg.translate(-transX, -transY); + } + } + } + } + } + } + + return matchFound; + } + + /** + * Answers the height in pixels of a repeating section of the wrapped + * alignment, including space above, scale above if shown, sequences, and + * annotation panel if shown + * + * @return + */ + protected int getRepeatHeightWrapped() + { + // gap (and maybe scale) above + int repeatHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1); + + // add sequences + repeatHeight += av.getRanges().getViewportHeight() * charHeight; + + // add annotations panel height if shown + repeatHeight += getAnnotationHeight(); + + return repeatHeight; + } }