2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
7 * Jalview is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation, either version 3
10 * of the License, or (at your option) any later version.
12 * Jalview is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty
14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19 * The Jalview Authors are detailed in the 'AUTHORS' file.
23 import jalview.datamodel.AlignmentI;
24 import jalview.datamodel.HiddenColumns;
25 import jalview.datamodel.SearchResultsI;
26 import jalview.datamodel.SequenceGroup;
27 import jalview.datamodel.SequenceI;
28 import jalview.renderer.ScaleRenderer;
29 import jalview.renderer.ScaleRenderer.ScaleMark;
30 import jalview.util.Comparison;
31 import jalview.viewmodel.ViewportListenerI;
32 import jalview.viewmodel.ViewportRanges;
34 import java.awt.AlphaComposite;
35 import java.awt.BasicStroke;
36 import java.awt.BorderLayout;
37 import java.awt.Color;
38 import java.awt.FontMetrics;
39 import java.awt.Graphics;
40 import java.awt.Graphics2D;
41 import java.awt.RenderingHints;
42 import java.awt.Shape;
43 import java.awt.image.BufferedImage;
44 import java.beans.PropertyChangeEvent;
45 import java.util.List;
47 import javax.swing.JComponent;
50 * The Swing component on which the alignment sequences, and annotations (if
51 * shown), are drawn. This includes scales above, left and right (if shown) in
52 * Wrapped mode, but not the scale above in Unwrapped mode.
55 public class SeqCanvas extends JComponent implements ViewportListenerI
57 private static final String ZEROS = "0000000000";
59 final FeatureRenderer fr;
69 private final SequenceRenderer seqRdr;
71 private boolean fastPaint = false;
73 private boolean fastpainting = false;
75 private AnnotationPanel annotations;
78 * measurements for drawing a wrapped alignment
80 private int labelWidthEast; // label right width in pixels if shown
82 private int labelWidthWest; // label left width in pixels if shown
84 private int wrappedSpaceAboveAlignment; // gap between widths
86 private int wrappedRepeatHeightPx; // height in pixels of wrapped width
88 private int wrappedVisibleWidths; // number of wrapped widths displayed
90 private Graphics2D gg;
93 * Creates a new SeqCanvas object.
97 public SeqCanvas(AlignmentPanel ap)
100 fr = new FeatureRenderer(ap);
101 seqRdr = new SequenceRenderer(av);
102 setLayout(new BorderLayout());
103 PaintRefresher.Register(this, av.getSequenceSetId());
104 setBackground(Color.white);
106 av.getRanges().addPropertyChangeListener(this);
109 public SequenceRenderer getSequenceRenderer()
114 public FeatureRenderer getFeatureRenderer()
120 * Draws the scale above a region of a wrapped alignment, consisting of a
121 * column number every major interval (10 columns).
124 * the graphics context to draw on, positioned at the start (bottom
125 * left) of the line on which to draw any scale marks
127 * start alignment column (0..)
129 * end alignment column (0..)
131 * y offset to draw at
133 private void drawNorthScale(Graphics g, int startx, int endx, int ypos)
135 int charHeight = av.getCharHeight();
136 int charWidth = av.getCharWidth();
139 * white fill the scale space (for the fastPaint case)
141 g.setColor(Color.white);
142 g.fillRect(0, ypos - charHeight - charHeight / 2, getWidth(),
143 charHeight * 3 / 2 + 2);
144 g.setColor(Color.black);
146 List<ScaleMark> marks = new ScaleRenderer().calculateMarks(av, startx,
148 for (ScaleMark mark : marks)
150 int mpos = mark.column; // (i - startx - 1)
155 String mstring = mark.text;
161 g.drawString(mstring, mpos * charWidth, ypos - (charHeight / 2));
165 * draw a tick mark below the column number, centred on the column;
166 * height of tick mark is 4 pixels less than half a character
168 int xpos = (mpos * charWidth) + (charWidth / 2);
169 g.drawLine(xpos, (ypos + 2) - (charHeight / 2), xpos, ypos - 2);
175 * Draw the scale to the left or right of a wrapped alignment
178 * graphics context, positioned at the start of the scale to be drawn
180 * first column of wrapped width (0.. excluding any hidden columns)
182 * last column of wrapped width (0.. excluding any hidden columns)
184 * vertical offset at which to begin the scale
186 * if true, scale is left of residues, if false, scale is right
188 void drawVerticalScale(Graphics g, final int startx, final int endx,
189 final int ypos, final boolean left)
191 int charHeight = av.getCharHeight();
192 int charWidth = av.getCharWidth();
194 int yPos = ypos + charHeight;
198 if (av.hasHiddenColumns())
200 HiddenColumns hiddenColumns = av.getAlignment().getHiddenColumns();
201 startX = hiddenColumns.adjustForHiddenColumns(startx);
202 endX = hiddenColumns.adjustForHiddenColumns(endx);
204 FontMetrics fm = getFontMetrics(av.getFont());
206 for (int i = 0; i < av.getAlignment().getHeight(); i++)
208 SequenceI seq = av.getAlignment().getSequenceAt(i);
211 * find sequence position of first non-gapped position -
212 * to the right if scale left, to the left if scale right
214 int index = left ? startX : endX;
216 while (index >= startX && index <= endX)
218 if (!Comparison.isGap(seq.getCharAt(index)))
220 value = seq.findPosition(index);
234 * white fill the space for the scale
236 g.setColor(Color.white);
237 int y = (yPos + (i * charHeight)) - (charHeight / 5);
238 // fillRect origin is top left of rectangle
239 g.fillRect(0, y - charHeight, left ? labelWidthWest : labelWidthEast,
245 * draw scale value, right justified within its width less half a
246 * character width padding on the right
248 int labelSpace = left ? labelWidthWest : labelWidthEast;
249 labelSpace -= charWidth / 2; // leave space to the right
250 String valueAsString = String.valueOf(value);
251 int labelLength = fm.stringWidth(valueAsString);
252 int xOffset = labelSpace - labelLength;
253 g.setColor(Color.black);
254 g.drawString(valueAsString, xOffset, y);
260 * Does a fast paint of an alignment in response to a scroll. Most of the
261 * visible region is simply copied and shifted, and then any newly visible
262 * columns or rows are drawn. The scroll may be horizontal or vertical, but
263 * not both at once. Scrolling may be the result of
265 * <li>dragging a scroll bar</li>
266 * <li>clicking in the scroll bar</li>
267 * <li>scrolling by trackpad, middle mouse button, or other device</li>
268 * <li>by moving the box in the Overview window</li>
269 * <li>programmatically to make a highlighted position visible</li>
273 * columns to shift right (positive) or left (negative)
275 * rows to shift down (positive) or up (negative)
277 public void fastPaint(int horizontal, int vertical)
279 if (fastpainting || gg == null || img == null)
288 int charHeight = av.getCharHeight();
289 int charWidth = av.getCharWidth();
291 ViewportRanges ranges = av.getRanges();
292 int startRes = ranges.getStartRes();
293 int endRes = ranges.getEndRes();
294 int startSeq = ranges.getStartSeq();
295 int endSeq = ranges.getEndSeq();
299 gg.copyArea(horizontal * charWidth, vertical * charHeight,
300 img.getWidth(), img.getHeight(), -horizontal * charWidth,
301 -vertical * charHeight);
303 if (horizontal > 0) // scrollbar pulled right, image to the left
305 transX = (endRes - startRes - horizontal) * charWidth;
306 startRes = endRes - horizontal;
308 else if (horizontal < 0)
310 endRes = startRes - horizontal;
313 if (vertical > 0) // scroll down
315 startSeq = endSeq - vertical;
317 if (startSeq < ranges.getStartSeq())
318 { // ie scrolling too fast, more than a page at a time
319 startSeq = ranges.getStartSeq();
323 transY = img.getHeight() - ((vertical + 1) * charHeight);
326 else if (vertical < 0)
328 endSeq = startSeq - vertical;
330 if (endSeq > ranges.getEndSeq())
332 endSeq = ranges.getEndSeq();
336 gg.translate(transX, transY);
337 drawPanel(gg, startRes, endRes, startSeq, endSeq, 0);
338 gg.translate(-transX, -transY);
343 fastpainting = false;
348 public void paintComponent(Graphics g)
350 super.paintComponent(g);
352 int charHeight = av.getCharHeight();
353 int charWidth = av.getCharWidth();
355 ViewportRanges ranges = av.getRanges();
357 int width = getWidth();
358 int height = getHeight();
360 width -= (width % charWidth);
361 height -= (height % charHeight);
363 // selectImage is the selection group outline image
364 BufferedImage selectImage = drawSelectionGroup(
365 ranges.getStartRes(), ranges.getEndRes(),
366 ranges.getStartSeq(), ranges.getEndSeq());
368 if ((img != null) && (fastPaint
369 || (getVisibleRect().width != g.getClipBounds().width)
370 || (getVisibleRect().height != g.getClipBounds().height)))
372 BufferedImage lcimg = buildLocalImage(selectImage);
373 g.drawImage(lcimg, 0, 0, this);
376 else if ((width > 0) && (height > 0))
378 // img is a cached version of the last view we drew, if any
379 // if we have no img or the size has changed, make a new one
380 if (img == null || width != img.getWidth()
381 || height != img.getHeight())
388 gg = (Graphics2D) img.getGraphics();
389 gg.setFont(av.getFont());
394 gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
395 RenderingHints.VALUE_ANTIALIAS_ON);
398 gg.setColor(Color.white);
399 gg.fillRect(0, 0, img.getWidth(), img.getHeight());
401 if (av.getWrapAlignment())
403 drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
407 drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
408 ranges.getStartSeq(), ranges.getEndSeq(), 0);
411 // lcimg is a local *copy* of img which we'll draw selectImage on top of
412 BufferedImage lcimg = buildLocalImage(selectImage);
413 g.drawImage(lcimg, 0, 0, this);
419 drawCursor(g, ranges.getStartRes(), ranges.getEndRes(),
420 ranges.getStartSeq(), ranges.getEndSeq());
425 * Draw an alignment panel for printing
428 * Graphics object to draw with
430 * start residue of print area
432 * end residue of print area
434 * start sequence of print area
436 * end sequence of print area
438 public void drawPanelForPrinting(Graphics g1, int startRes, int endRes,
439 int startSeq, int endSeq)
441 drawPanel(g1, startRes, endRes, startSeq, endSeq, 0);
443 BufferedImage selectImage = drawSelectionGroup(startRes, endRes,
445 if (selectImage != null)
447 ((Graphics2D) g1).setComposite(AlphaComposite
448 .getInstance(AlphaComposite.SRC_OVER));
449 g1.drawImage(selectImage, 0, 0, this);
454 * Draw a wrapped alignment panel for printing
457 * Graphics object to draw with
459 * width of drawing area
460 * @param canvasHeight
461 * height of drawing area
463 * start residue of print area
465 public void drawWrappedPanelForPrinting(Graphics g, int canvasWidth,
466 int canvasHeight, int startRes)
468 SequenceGroup group = av.getSelectionGroup();
470 drawWrappedPanel(g, canvasWidth, canvasHeight, startRes);
474 BufferedImage selectImage = null;
477 selectImage = new BufferedImage(canvasWidth, canvasHeight,
478 BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
479 } catch (OutOfMemoryError er)
482 System.err.println("Print image OutOfMemory Error.\n" + er);
483 new OOMWarning("Creating wrapped alignment image for printing", er);
485 if (selectImage != null)
487 Graphics2D g2 = selectImage.createGraphics();
488 setupSelectionGroup(g2, selectImage);
489 drawWrappedSelection(g2, group, canvasWidth, canvasHeight,
493 AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
494 g.drawImage(selectImage, 0, 0, this);
501 * Make a local image by combining the cached image img
504 private BufferedImage buildLocalImage(BufferedImage selectImage)
506 // clone the cached image
507 BufferedImage lcimg = new BufferedImage(img.getWidth(), img.getHeight(),
509 Graphics2D g2d = lcimg.createGraphics();
510 g2d.drawImage(img, 0, 0, null);
512 // overlay selection group on lcimg
513 if (selectImage != null)
516 AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
517 g2d.drawImage(selectImage, 0, 0, this);
526 * Set up a buffered image of the correct height and size for the sequence canvas
528 private BufferedImage setupImage()
530 BufferedImage lcimg = null;
532 int charWidth = av.getCharWidth();
533 int charHeight = av.getCharHeight();
535 int width = getWidth();
536 int height = getHeight();
538 width -= (width % charWidth);
539 height -= (height % charHeight);
541 if ((width < 1) || (height < 1))
548 lcimg = new BufferedImage(width, height,
549 BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
550 } catch (OutOfMemoryError er)
554 "Group image OutOfMemory Redraw Error.\n" + er);
555 new OOMWarning("Creating alignment image for display", er);
564 * Returns the visible width of the canvas in residues, after allowing for
565 * East or West scales (if shown)
568 * the width in pixels (possibly including scales)
572 public int getWrappedCanvasWidth(int canvasWidth)
574 int charWidth = av.getCharWidth();
576 FontMetrics fm = getFontMetrics(av.getFont());
580 if (av.getScaleRightWrapped() || av.getScaleLeftWrapped())
582 labelWidth = getLabelWidth(fm);
585 labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0;
587 labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0;
589 return (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
593 * Returns a pixel width sufficient to show the largest sequence coordinate
594 * (end position) in the alignment, calculated as the FontMetrics width of
595 * zeroes "0000000" limited to the number of decimal digits to be shown (3 for
596 * 1-10, 4 for 11-99 etc). One character width is added to this, to allow for
597 * half a character width space on either side.
602 protected int getLabelWidth(FontMetrics fm)
605 * find the biggest sequence end position we need to show
606 * (note this is not necessarily the sequence length)
609 AlignmentI alignment = av.getAlignment();
610 for (int i = 0; i < alignment.getHeight(); i++)
612 maxWidth = Math.max(maxWidth, alignment.getSequenceAt(i).getEnd());
616 for (int i = maxWidth; i > 0; i /= 10)
621 return fm.stringWidth(ZEROS.substring(0, length)) + av.getCharWidth();
625 * Draws as many widths of a wrapped alignment as can fit in the visible
630 * available width in pixels
631 * @param canvasHeight
632 * available height in pixels
634 * the first column (0...) of the alignment to draw
636 public void drawWrappedPanel(Graphics g, int canvasWidth,
637 int canvasHeight, final int startColumn)
639 int wrappedWidthInResidues = calculateWrappedGeometry(canvasWidth,
642 av.setWrappedWidth(wrappedWidthInResidues);
644 ViewportRanges ranges = av.getRanges();
645 ranges.setViewportStartAndWidth(startColumn, wrappedWidthInResidues);
648 * draw one width at a time (including any scales or annotation shown),
649 * until we have run out of either alignment or vertical space available
651 int ypos = wrappedSpaceAboveAlignment;
652 int maxWidth = ranges.getVisibleAlignmentWidth();
654 int start = startColumn;
655 int currentWidth = 0;
656 while ((currentWidth < wrappedVisibleWidths) && (start < maxWidth))
659 .min(maxWidth, start + wrappedWidthInResidues - 1);
660 drawWrappedWidth(g, ypos, start, endColumn, canvasHeight);
661 ypos += wrappedRepeatHeightPx;
662 start += wrappedWidthInResidues;
666 drawWrappedDecorators(g, startColumn);
670 * Calculates and saves values needed when rendering a wrapped alignment.
671 * These depend on many factors, including
673 * <li>canvas width and height</li>
674 * <li>number of visible sequences, and height of annotations if shown</li>
675 * <li>font and character width</li>
676 * <li>whether scales are shown left, right or above the alignment</li>
680 * @param canvasHeight
681 * @return the number of residue columns in each width
683 protected int calculateWrappedGeometry(int canvasWidth, int canvasHeight)
685 int charHeight = av.getCharHeight();
688 * vertical space in pixels between wrapped widths of alignment
689 * - one character height, or two if scale above is drawn
691 wrappedSpaceAboveAlignment = charHeight
692 * (av.getScaleAboveWrapped() ? 2 : 1);
695 * height in pixels of the wrapped widths
697 wrappedRepeatHeightPx = wrappedSpaceAboveAlignment;
699 wrappedRepeatHeightPx += av.getRanges().getViewportHeight()
701 // add annotations panel height if shown
702 wrappedRepeatHeightPx += getAnnotationHeight();
705 * number of visible widths (the last one may be part height),
706 * ensuring a part height includes at least one sequence
708 ViewportRanges ranges = av.getRanges();
709 wrappedVisibleWidths = canvasHeight / wrappedRepeatHeightPx;
710 int remainder = canvasHeight % wrappedRepeatHeightPx;
711 if (remainder >= (wrappedSpaceAboveAlignment + charHeight))
713 wrappedVisibleWidths++;
717 * compute width in residues; this also sets East and West label widths
719 int wrappedWidthInResidues = getWrappedCanvasWidth(canvasWidth);
722 * limit visibleWidths to not exceed width of alignment
724 int xMax = ranges.getVisibleAlignmentWidth();
725 int startToEnd = xMax - ranges.getStartRes();
726 int maxWidths = startToEnd / wrappedWidthInResidues;
727 if (startToEnd % wrappedWidthInResidues > 0)
731 wrappedVisibleWidths = Math.min(wrappedVisibleWidths, maxWidths);
733 return wrappedWidthInResidues;
737 * Draws one width of a wrapped alignment, including sequences and
738 * annnotations, if shown, but not scales or hidden column markers
744 * @param canvasHeight
746 protected void drawWrappedWidth(Graphics g, int ypos, int startColumn,
747 int endColumn, int canvasHeight)
749 ViewportRanges ranges = av.getRanges();
750 int viewportWidth = ranges.getViewportWidth();
752 int endx = Math.min(startColumn + viewportWidth - 1, endColumn);
755 * move right before drawing by the width of the scale left (if any)
756 * plus column offset from left margin (usually zero, but may be non-zero
757 * when fast painting is drawing just a few columns)
759 int charWidth = av.getCharWidth();
760 int xOffset = labelWidthWest
761 + ((startColumn - ranges.getStartRes()) % viewportWidth)
763 g.translate(xOffset, 0);
765 // When printing we have an extra clipped region,
766 // the Printable page which we need to account for here
767 Shape clip = g.getClip();
771 g.setClip(0, 0, viewportWidth * charWidth, canvasHeight);
775 g.setClip(0, (int) clip.getBounds().getY(),
776 viewportWidth * charWidth, (int) clip.getBounds().getHeight());
780 * white fill the region to be drawn (so incremental fast paint doesn't
781 * scribble over an existing image)
783 gg.setColor(Color.white);
784 gg.fillRect(0, ypos, (endx - startColumn + 1) * charWidth,
785 wrappedRepeatHeightPx);
787 drawPanel(g, startColumn, endx, 0, av.getAlignment().getHeight() - 1,
790 int cHeight = av.getAlignment().getHeight() * av.getCharHeight();
792 if (av.isShowAnnotation())
794 g.translate(0, cHeight + ypos + 3);
795 if (annotations == null)
797 annotations = new AnnotationPanel(av);
800 annotations.renderer.drawComponent(annotations, av, g, -1,
801 startColumn, endx + 1);
802 g.translate(0, -cHeight - ypos - 3);
805 g.translate(-xOffset, 0);
809 * Draws scales left, right and above (if shown), and any hidden column
810 * markers, on all widths of the wrapped alignment
815 protected void drawWrappedDecorators(Graphics g, final int startColumn)
817 int charWidth = av.getCharWidth();
819 g.setFont(av.getFont());
820 g.setColor(Color.black);
822 int ypos = wrappedSpaceAboveAlignment;
823 ViewportRanges ranges = av.getRanges();
824 int viewportWidth = ranges.getViewportWidth();
825 int maxWidth = ranges.getVisibleAlignmentWidth();
827 int startCol = startColumn;
829 while (widthsDrawn < wrappedVisibleWidths)
831 int endColumn = Math.min(maxWidth, startCol + viewportWidth - 1);
833 if (av.getScaleLeftWrapped())
835 drawVerticalScale(g, startCol, endColumn - 1, ypos, true);
838 if (av.getScaleRightWrapped())
840 int x = labelWidthWest + viewportWidth * charWidth;
842 drawVerticalScale(g, startCol, endColumn, ypos, false);
847 * white fill region of scale above and hidden column markers
848 * (to support incremental fast paint of image)
850 g.translate(labelWidthWest, 0);
851 g.setColor(Color.white);
852 g.fillRect(0, ypos - wrappedSpaceAboveAlignment, viewportWidth
853 * charWidth + labelWidthWest, wrappedSpaceAboveAlignment);
854 g.setColor(Color.black);
855 g.translate(-labelWidthWest, 0);
857 g.translate(labelWidthWest, 0);
859 if (av.getScaleAboveWrapped())
861 drawNorthScale(g, startCol, endColumn, ypos);
864 if (av.hasHiddenColumns() && av.getShowHiddenMarkers())
866 drawHiddenColumnMarkers(g, ypos, startCol, endColumn);
869 g.translate(-labelWidthWest, 0);
871 ypos += wrappedRepeatHeightPx;
872 startCol += viewportWidth;
878 * Draws markers (triangles) above hidden column positions between startColumn
886 protected void drawHiddenColumnMarkers(Graphics g, int ypos,
887 int startColumn, int endColumn)
889 int charHeight = av.getCharHeight();
890 int charWidth = av.getCharWidth();
892 g.setColor(Color.blue);
893 HiddenColumns hidden = av.getAlignment().getHiddenColumns();
894 List<Integer> positions = hidden.findHiddenRegionPositions();
895 for (int pos : positions)
897 int res = pos - startColumn;
899 if (res < 0 || res > endColumn - startColumn + 1)
905 * draw a downward-pointing triangle at the hidden columns location
906 * (before the following visible column)
908 int xMiddle = res * charWidth;
909 int[] xPoints = new int[] { xMiddle - charHeight / 4,
910 xMiddle + charHeight / 4, xMiddle };
911 int yTop = ypos - (charHeight / 2);
912 int[] yPoints = new int[] { yTop, yTop, yTop + 8 };
913 g.fillPolygon(xPoints, yPoints, 3);
918 * Draw a selection group over a wrapped alignment
920 private void drawWrappedSelection(Graphics2D g, SequenceGroup group,
922 int canvasHeight, int startRes)
924 int charHeight = av.getCharHeight();
925 int charWidth = av.getCharWidth();
927 // height gap above each panel
928 int hgap = charHeight;
929 if (av.getScaleAboveWrapped())
934 int cWidth = (canvasWidth - labelWidthEast - labelWidthWest)
936 int cHeight = av.getAlignment().getHeight() * charHeight;
938 int startx = startRes;
940 int ypos = hgap; // vertical offset
941 int maxwidth = av.getAlignment().getWidth();
943 if (av.hasHiddenColumns())
945 maxwidth = av.getAlignment().getHiddenColumns()
946 .findColumnPosition(maxwidth);
949 // chop the wrapped alignment extent up into panel-sized blocks and treat
950 // each block as if it were a block from an unwrapped alignment
951 while ((ypos <= canvasHeight) && (startx < maxwidth))
953 // set end value to be start + width, or maxwidth, whichever is smaller
954 endx = startx + cWidth - 1;
961 g.translate(labelWidthWest, 0);
963 drawUnwrappedSelection(g, group, startx, endx, 0,
964 av.getAlignment().getHeight() - 1,
967 g.translate(-labelWidthWest, 0);
969 // update vertical offset
970 ypos += cHeight + getAnnotationHeight() + hgap;
972 // update horizontal offset
977 int getAnnotationHeight()
979 if (!av.isShowAnnotation())
984 if (annotations == null)
986 annotations = new AnnotationPanel(av);
989 return annotations.adjustPanelHeight();
993 * Draws the visible region of the alignment on the graphics context. If there
994 * are hidden column markers in the visible region, then each sub-region
995 * between the markers is drawn separately, followed by the hidden column
999 * the graphics context, positioned at the first residue to be drawn
1001 * offset of the first column to draw (0..)
1003 * offset of the last column to draw (0..)
1005 * offset of the first sequence to draw (0..)
1007 * offset of the last sequence to draw (0..)
1009 * vertical offset at which to draw (for wrapped alignments)
1011 public void drawPanel(Graphics g1, final int startRes, final int endRes,
1012 final int startSeq, final int endSeq, final int yOffset)
1014 int charHeight = av.getCharHeight();
1015 int charWidth = av.getCharWidth();
1017 if (!av.hasHiddenColumns())
1019 draw(g1, startRes, endRes, startSeq, endSeq, yOffset);
1024 final int screenYMax = endRes - startRes;
1025 int blockStart = startRes;
1026 int blockEnd = endRes;
1028 for (int[] region : av.getAlignment().getHiddenColumns()
1029 .getHiddenColumnsCopy())
1031 int hideStart = region[0];
1032 int hideEnd = region[1];
1034 if (hideStart <= blockStart)
1036 blockStart += (hideEnd - hideStart) + 1;
1041 * draw up to just before the next hidden region, or the end of
1042 * the visible region, whichever comes first
1044 blockEnd = Math.min(hideStart - 1, blockStart + screenYMax
1047 g1.translate(screenY * charWidth, 0);
1049 draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
1052 * draw the downline of the hidden column marker (ScalePanel draws the
1053 * triangle on top) if we reached it
1055 if (av.getShowHiddenMarkers() && blockEnd == hideStart - 1)
1057 g1.setColor(Color.blue);
1059 g1.drawLine((blockEnd - blockStart + 1) * charWidth - 1,
1060 0 + yOffset, (blockEnd - blockStart + 1) * charWidth - 1,
1061 (endSeq - startSeq + 1) * charHeight + yOffset);
1064 g1.translate(-screenY * charWidth, 0);
1065 screenY += blockEnd - blockStart + 1;
1066 blockStart = hideEnd + 1;
1068 if (screenY > screenYMax)
1070 // already rendered last block
1075 if (screenY <= screenYMax)
1077 // remaining visible region to render
1078 blockEnd = blockStart + screenYMax - screenY;
1079 g1.translate(screenY * charWidth, 0);
1080 draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
1082 g1.translate(-screenY * charWidth, 0);
1089 * Draws a region of the visible alignment
1093 * offset of the first column in the visible region (0..)
1095 * offset of the last column in the visible region (0..)
1097 * offset of the first sequence in the visible region (0..)
1099 * offset of the last sequence in the visible region (0..)
1101 * vertical offset at which to draw (for wrapped alignments)
1103 private void draw(Graphics g, int startRes, int endRes, int startSeq,
1104 int endSeq, int offset)
1106 int charHeight = av.getCharHeight();
1107 int charWidth = av.getCharWidth();
1109 g.setFont(av.getFont());
1110 seqRdr.prepare(g, av.isRenderGaps());
1114 // / First draw the sequences
1115 // ///////////////////////////
1116 for (int i = startSeq; i <= endSeq; i++)
1118 nextSeq = av.getAlignment().getSequenceAt(i);
1119 if (nextSeq == null)
1121 // occasionally, a race condition occurs such that the alignment row is
1125 seqRdr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
1126 startRes, endRes, offset + ((i - startSeq) * charHeight));
1128 if (av.isShowSequenceFeatures())
1130 fr.drawSequence(g, nextSeq, startRes, endRes,
1131 offset + ((i - startSeq) * charHeight), false);
1135 * highlight search Results once sequence has been drawn
1137 if (av.hasSearchResults())
1139 SearchResultsI searchResults = av.getSearchResults();
1140 int[] visibleResults = searchResults.getResults(nextSeq,
1142 if (visibleResults != null)
1144 for (int r = 0; r < visibleResults.length; r += 2)
1146 seqRdr.drawHighlightedText(nextSeq, visibleResults[r],
1147 visibleResults[r + 1], (visibleResults[r] - startRes)
1149 + ((i - startSeq) * charHeight));
1155 if (av.getSelectionGroup() != null
1156 || av.getAlignment().getGroups().size() > 0)
1158 drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);
1163 void drawGroupsBoundaries(Graphics g1, int startRes, int endRes,
1164 int startSeq, int endSeq, int offset)
1166 Graphics2D g = (Graphics2D) g1;
1168 // ///////////////////////////////////
1169 // Now outline any areas if necessary
1170 // ///////////////////////////////////
1172 SequenceGroup group = null;
1173 int groupIndex = -1;
1175 if (av.getAlignment().getGroups().size() > 0)
1177 group = av.getAlignment().getGroups().get(0);
1183 g.setStroke(new BasicStroke());
1184 g.setColor(group.getOutlineColour());
1188 drawPartialGroupOutline(g, group, startRes, endRes, startSeq,
1193 g.setStroke(new BasicStroke());
1195 if (groupIndex >= av.getAlignment().getGroups().size())
1200 group = av.getAlignment().getGroups().get(groupIndex);
1202 } while (groupIndex < av.getAlignment().getGroups().size());
1210 * Draw the selection group as a separate image and overlay
1212 private BufferedImage drawSelectionGroup(int startRes, int endRes,
1213 int startSeq, int endSeq)
1215 // get a new image of the correct size
1216 BufferedImage selectionImage = setupImage();
1218 if (selectionImage == null)
1223 SequenceGroup group = av.getSelectionGroup();
1230 // set up drawing colour
1231 Graphics2D g = (Graphics2D) selectionImage.getGraphics();
1233 setupSelectionGroup(g, selectionImage);
1235 if (!av.getWrapAlignment())
1237 drawUnwrappedSelection(g, group, startRes, endRes, startSeq, endSeq,
1242 drawWrappedSelection(g, group, getWidth(), getHeight(),
1243 av.getRanges().getStartRes());
1247 return selectionImage;
1251 * Draw the cursor as a separate image and overlay
1254 * start residue of area to draw cursor in
1256 * end residue of area to draw cursor in
1258 * start sequence of area to draw cursor in
1260 * end sequence of are to draw cursor in
1261 * @return a transparent image of the same size as the sequence canvas, with
1262 * the cursor drawn on it, if any
1264 private void drawCursor(Graphics g, int startRes, int endRes,
1268 // convert the cursorY into a position on the visible alignment
1269 int cursor_ypos = av.getAlignment().getHiddenSequences()
1270 .findIndexWithoutHiddenSeqs(cursorY);
1272 // don't do work unless we have to
1273 if (!av.getAlignment().getHiddenSequences().isHidden(cursorY)
1274 && cursor_ypos >= startSeq && cursor_ypos <= endSeq)
1278 int startx = startRes;
1281 // convert the cursorX into a position on the visible alignment
1282 int cursor_xpos = av.getAlignment().getHiddenColumns()
1283 .findColumnPosition(cursorX);
1285 if (av.getAlignment().getHiddenColumns().isVisible(cursorX))
1288 if (av.getWrapAlignment())
1290 // work out the correct offsets for the cursor
1291 int charHeight = av.getCharHeight();
1292 int charWidth = av.getCharWidth();
1293 int canvasWidth = getWidth();
1294 int canvasHeight = getHeight();
1296 // height gap above each panel
1297 int hgap = charHeight;
1298 if (av.getScaleAboveWrapped())
1303 int cWidth = (canvasWidth - labelWidthEast - labelWidthWest)
1305 int cHeight = av.getAlignment().getHeight() * charHeight;
1307 endx = startx + cWidth - 1;
1308 int ypos = hgap; // vertical offset
1310 // iterate down the wrapped panels
1311 while ((ypos <= canvasHeight) && (endx < cursor_xpos))
1313 // update vertical offset
1314 ypos += cHeight + getAnnotationHeight() + hgap;
1316 // update horizontal offset
1318 endx = startx + cWidth - 1;
1321 xoffset = labelWidthWest;
1324 // now check if cursor is within range for x values
1325 if (cursor_xpos >= startx && cursor_xpos <= endx)
1327 // get the character the cursor is drawn at
1328 SequenceI seq = av.getAlignment().getSequenceAt(cursorY);
1329 char s = seq.getCharAt(cursorX);
1331 seqRdr.drawCursor(g, s,
1332 xoffset + (cursor_xpos - startx) * av.getCharWidth(),
1333 yoffset + (cursor_ypos - startSeq) * av.getCharHeight());
1341 * Set up graphics for selection group
1343 private void setupSelectionGroup(Graphics2D g,
1344 BufferedImage selectionImage)
1346 // set background to transparent
1347 g.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
1348 g.fillRect(0, 0, selectionImage.getWidth(), selectionImage.getHeight());
1350 // set up foreground to draw red dashed line
1351 g.setComposite(AlphaComposite.Src);
1352 g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
1353 BasicStroke.JOIN_ROUND, 3f, new float[]
1355 g.setColor(Color.RED);
1359 * Draw a selection group over an unwrapped alignment
1360 * @param g graphics object to draw with
1361 * @param group selection group
1362 * @param startRes start residue of area to draw
1363 * @param endRes end residue of area to draw
1364 * @param startSeq start sequence of area to draw
1365 * @param endSeq end sequence of area to draw
1366 * @param offset vertical offset (used when called from wrapped alignment code)
1368 private void drawUnwrappedSelection(Graphics2D g, SequenceGroup group,
1369 int startRes, int endRes, int startSeq, int endSeq, int offset)
1371 int charWidth = av.getCharWidth();
1373 if (!av.hasHiddenColumns())
1375 drawPartialGroupOutline(g, group, startRes, endRes, startSeq, endSeq,
1380 // package into blocks of visible columns
1382 int blockStart = startRes;
1383 int blockEnd = endRes;
1385 for (int[] region : av.getAlignment().getHiddenColumns()
1386 .getHiddenColumnsCopy())
1388 int hideStart = region[0];
1389 int hideEnd = region[1];
1391 if (hideStart <= blockStart)
1393 blockStart += (hideEnd - hideStart) + 1;
1397 blockEnd = hideStart - 1;
1399 g.translate(screenY * charWidth, 0);
1400 drawPartialGroupOutline(g, group,
1401 blockStart, blockEnd, startSeq, endSeq, offset);
1403 g.translate(-screenY * charWidth, 0);
1404 screenY += blockEnd - blockStart + 1;
1405 blockStart = hideEnd + 1;
1407 if (screenY > (endRes - startRes))
1409 // already rendered last block
1414 if (screenY <= (endRes - startRes))
1416 // remaining visible region to render
1417 blockEnd = blockStart + (endRes - startRes) - screenY;
1418 g.translate(screenY * charWidth, 0);
1419 drawPartialGroupOutline(g, group,
1420 blockStart, blockEnd, startSeq, endSeq, offset);
1422 g.translate(-screenY * charWidth, 0);
1428 * Draw the selection group as a separate image and overlay
1430 private void drawPartialGroupOutline(Graphics2D g, SequenceGroup group,
1431 int startRes, int endRes, int startSeq, int endSeq,
1434 int charHeight = av.getCharHeight();
1435 int charWidth = av.getCharWidth();
1437 int visWidth = (endRes - startRes + 1) * charWidth;
1441 boolean inGroup = false;
1449 for (i = startSeq; i <= endSeq; i++)
1451 // position of start residue of group relative to startRes, in pixels
1452 sx = (group.getStartRes() - startRes) * charWidth;
1454 // width of group in pixels
1455 xwidth = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth)
1458 sy = verticalOffset + (i - startSeq) * charHeight;
1460 if (sx + xwidth < 0 || sx > visWidth)
1465 if ((sx <= (endRes - startRes) * charWidth)
1466 && group.getSequences(null)
1467 .contains(av.getAlignment().getSequenceAt(i)))
1469 if ((bottom == -1) && !group.getSequences(null)
1470 .contains(av.getAlignment().getSequenceAt(i + 1)))
1472 bottom = sy + charHeight;
1477 if (((top == -1) && (i == 0)) || !group.getSequences(null)
1478 .contains(av.getAlignment().getSequenceAt(i - 1)))
1491 // if start position is visible, draw vertical line to left of
1493 if (sx >= 0 && sx < visWidth)
1495 g.drawLine(sx, oldY, sx, sy);
1498 // if end position is visible, draw vertical line to right of
1500 if (sx + xwidth < visWidth)
1502 g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
1511 // don't let width extend beyond current block, or group extent
1513 if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
1515 xwidth = (endRes - startRes + 1) * charWidth - sx;
1518 // draw horizontal line at top of group
1521 g.drawLine(sx, top, sx + xwidth, top);
1525 // draw horizontal line at bottom of group
1528 g.drawLine(sx, bottom, sx + xwidth, bottom);
1539 sy = verticalOffset + ((i - startSeq) * charHeight);
1540 if (sx >= 0 && sx < visWidth)
1542 g.drawLine(sx, oldY, sx, sy);
1545 if (sx + xwidth < visWidth)
1547 g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
1556 if (sx + xwidth > visWidth)
1560 else if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
1562 xwidth = (endRes - startRes + 1) * charWidth;
1567 g.drawLine(sx, top, sx + xwidth, top);
1573 g.drawLine(sx, bottom - 1, sx + xwidth, bottom - 1);
1582 * Highlights search results in the visible region by rendering as white text
1583 * on a black background. Any previous highlighting is removed. Answers true
1584 * if any highlight was left on the visible alignment (so status bar should be
1585 * set to match), else false.
1587 * Currently fastPaint is not implemented for wrapped alignments. If a wrapped
1588 * alignment had to be scrolled to show the highlighted region, then it should
1589 * be fully redrawn, otherwise a fast paint can be performed. This argument
1590 * could be removed if fast paint of scrolled wrapped alignment is coded in
1591 * future (JAL-2609).
1594 * @param noFastPaint
1597 public boolean highlightSearchResults(SearchResultsI results,
1598 boolean noFastPaint)
1604 boolean wrapped = av.getWrapAlignment();
1607 fastPaint = !noFastPaint;
1608 fastpainting = fastPaint;
1611 * to avoid redrawing the whole visible region, we instead
1612 * redraw just the minimal regions to remove previous highlights
1615 SearchResultsI previous = av.getSearchResults();
1616 av.setSearchResults(results);
1617 boolean redrawn = false;
1618 boolean drawn = false;
1621 redrawn = drawMappedPositionsWrapped(previous);
1622 drawn = drawMappedPositionsWrapped(results);
1627 redrawn = drawMappedPositions(previous);
1628 drawn = drawMappedPositions(results);
1633 * if highlights were either removed or added, repaint
1641 * return true only if highlights were added
1647 fastpainting = false;
1652 * Redraws the minimal rectangle in the visible region (if any) that includes
1653 * mapped positions of the given search results. Whether or not positions are
1654 * highlighted depends on the SearchResults set on the Viewport. This allows
1655 * this method to be called to either clear or set highlighting. Answers true
1656 * if any positions were drawn (in which case a repaint is still required),
1662 protected boolean drawMappedPositions(SearchResultsI results)
1664 if (results == null)
1670 * calculate the minimal rectangle to redraw that
1671 * includes both new and existing search results
1673 int firstSeq = Integer.MAX_VALUE;
1675 int firstCol = Integer.MAX_VALUE;
1677 boolean matchFound = false;
1679 ViewportRanges ranges = av.getRanges();
1680 int firstVisibleColumn = ranges.getStartRes();
1681 int lastVisibleColumn = ranges.getEndRes();
1682 AlignmentI alignment = av.getAlignment();
1683 if (av.hasHiddenColumns())
1685 firstVisibleColumn = alignment.getHiddenColumns()
1686 .adjustForHiddenColumns(firstVisibleColumn);
1687 lastVisibleColumn = alignment.getHiddenColumns()
1688 .adjustForHiddenColumns(lastVisibleColumn);
1691 for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
1692 .getEndSeq(); seqNo++)
1694 SequenceI seq = alignment.getSequenceAt(seqNo);
1696 int[] visibleResults = results.getResults(seq, firstVisibleColumn,
1698 if (visibleResults != null)
1700 for (int i = 0; i < visibleResults.length - 1; i += 2)
1702 int firstMatchedColumn = visibleResults[i];
1703 int lastMatchedColumn = visibleResults[i + 1];
1704 if (firstMatchedColumn <= lastVisibleColumn
1705 && lastMatchedColumn >= firstVisibleColumn)
1708 * found a search results match in the visible region -
1709 * remember the first and last sequence matched, and the first
1710 * and last visible columns in the matched positions
1713 firstSeq = Math.min(firstSeq, seqNo);
1714 lastSeq = Math.max(lastSeq, seqNo);
1715 firstMatchedColumn = Math.max(firstMatchedColumn,
1716 firstVisibleColumn);
1717 lastMatchedColumn = Math.min(lastMatchedColumn,
1719 firstCol = Math.min(firstCol, firstMatchedColumn);
1720 lastCol = Math.max(lastCol, lastMatchedColumn);
1728 if (av.hasHiddenColumns())
1730 firstCol = alignment.getHiddenColumns()
1731 .findColumnPosition(firstCol);
1732 lastCol = alignment.getHiddenColumns().findColumnPosition(lastCol);
1734 int transX = (firstCol - ranges.getStartRes()) * av.getCharWidth();
1735 int transY = (firstSeq - ranges.getStartSeq()) * av.getCharHeight();
1736 gg.translate(transX, transY);
1737 drawPanel(gg, firstCol, lastCol, firstSeq, lastSeq, 0);
1738 gg.translate(-transX, -transY);
1745 public void propertyChange(PropertyChangeEvent evt)
1747 String eventName = evt.getPropertyName();
1749 if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
1755 else if (eventName.equals(ViewportRanges.MOVE_VIEWPORT))
1763 if (eventName.equals(ViewportRanges.STARTRES)
1764 || eventName.equals(ViewportRanges.STARTRESANDSEQ))
1766 // Make sure we're not trying to draw a panel
1767 // larger than the visible window
1768 if (eventName.equals(ViewportRanges.STARTRES))
1770 scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
1774 scrollX = ((int[]) evt.getNewValue())[0]
1775 - ((int[]) evt.getOldValue())[0];
1777 ViewportRanges vpRanges = av.getRanges();
1779 int range = vpRanges.getEndRes() - vpRanges.getStartRes();
1780 if (scrollX > range)
1784 else if (scrollX < -range)
1789 // Both scrolling and resizing change viewport ranges: scrolling changes
1790 // both start and end points, but resize only changes end values.
1791 // Here we only want to fastpaint on a scroll, with resize using a normal
1792 // paint, so scroll events are identified as changes to the horizontal or
1793 // vertical start value.
1794 if (eventName.equals(ViewportRanges.STARTRES))
1796 if (av.getWrapAlignment())
1798 fastPaintWrapped(scrollX);
1802 fastPaint(scrollX, 0);
1805 else if (eventName.equals(ViewportRanges.STARTSEQ))
1808 fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
1810 else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
1812 if (av.getWrapAlignment())
1814 fastPaintWrapped(scrollX);
1818 fastPaint(scrollX, 0);
1820 // bizarrely, we only need to scroll on the x value here as fastpaint
1821 // copies the full height of the image anyway. Passing in the y value
1822 // causes nasty repaint artefacts, which only disappear on a full
1829 * Does a minimal update of the image for a scroll movement. This method
1830 * handles scroll movements of up to one width of the wrapped alignment (one
1831 * click in the vertical scrollbar). Larger movements (for example after a
1832 * scroll to highlight a mapped position) trigger a full redraw instead.
1835 * number of positions scrolled (right if positive, left if negative)
1837 protected void fastPaintWrapped(int scrollX)
1839 ViewportRanges ranges = av.getRanges();
1841 if (Math.abs(scrollX) > ranges.getViewportWidth())
1844 * shift of more than one view width is
1845 * overcomplicated to handle in this method
1852 if (fastpainting || gg == null)
1858 fastpainting = true;
1862 calculateWrappedGeometry(getWidth(), getHeight());
1865 * relocate the regions of the alignment that are still visible
1867 shiftWrappedAlignment(-scrollX);
1870 * add new columns (sequence, annotation)
1871 * - at top left if scrollX < 0
1872 * - at right of last two widths if scrollX > 0
1876 int startRes = ranges.getStartRes();
1877 drawWrappedWidth(gg, wrappedSpaceAboveAlignment, startRes, startRes
1878 - scrollX - 1, getHeight());
1882 fastPaintWrappedAddRight(scrollX);
1886 * draw all scales (if shown) and hidden column markers
1888 drawWrappedDecorators(gg, ranges.getStartRes());
1893 fastpainting = false;
1898 * Draws the specified number of columns at the 'end' (bottom right) of a
1899 * wrapped alignment view, including sequences and annotations if shown, but
1900 * not scales. Also draws the same number of columns at the right hand end of
1901 * the second last width shown, if the last width is not full height (so
1902 * cannot simply be copied from the graphics image).
1906 protected void fastPaintWrappedAddRight(int columns)
1913 ViewportRanges ranges = av.getRanges();
1914 int viewportWidth = ranges.getViewportWidth();
1915 int charWidth = av.getCharWidth();
1918 * draw full height alignment in the second last row, last columns, if the
1919 * last row was not full height
1921 int visibleWidths = wrappedVisibleWidths;
1922 int canvasHeight = getHeight();
1923 boolean lastWidthPartHeight = (wrappedVisibleWidths * wrappedRepeatHeightPx) > canvasHeight;
1925 if (lastWidthPartHeight)
1927 int widthsAbove = Math.max(0, visibleWidths - 2);
1928 int ypos = wrappedRepeatHeightPx * widthsAbove
1929 + wrappedSpaceAboveAlignment;
1930 int endRes = ranges.getEndRes();
1931 endRes += widthsAbove * viewportWidth;
1932 int startRes = endRes - columns;
1933 int xOffset = ((startRes - ranges.getStartRes()) % viewportWidth)
1937 * white fill first to erase annotations
1939 gg.translate(xOffset, 0);
1940 gg.setColor(Color.white);
1941 gg.fillRect(labelWidthWest, ypos,
1942 (endRes - startRes + 1) * charWidth, wrappedRepeatHeightPx);
1943 gg.translate(-xOffset, 0);
1945 drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight);
1949 * draw newly visible columns in last wrapped width (none if we
1950 * have reached the end of the alignment)
1951 * y-offset for drawing last width is height of widths above,
1954 int widthsAbove = visibleWidths - 1;
1955 int ypos = wrappedRepeatHeightPx * widthsAbove
1956 + wrappedSpaceAboveAlignment;
1957 int endRes = ranges.getEndRes();
1958 endRes += widthsAbove * viewportWidth;
1959 int startRes = endRes - columns + 1;
1962 * white fill first to erase annotations
1964 int xOffset = ((startRes - ranges.getStartRes()) % viewportWidth)
1966 gg.translate(xOffset, 0);
1967 gg.setColor(Color.white);
1968 int width = viewportWidth * charWidth - xOffset;
1969 gg.fillRect(labelWidthWest, ypos, width, wrappedRepeatHeightPx);
1970 gg.translate(-xOffset, 0);
1972 gg.setFont(av.getFont());
1973 gg.setColor(Color.black);
1975 if (startRes < ranges.getVisibleAlignmentWidth())
1977 drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight);
1981 * and finally, white fill any space below the visible alignment
1983 int heightBelow = canvasHeight - visibleWidths * wrappedRepeatHeightPx;
1984 if (heightBelow > 0)
1986 gg.setColor(Color.white);
1987 gg.fillRect(0, canvasHeight - heightBelow, getWidth(), heightBelow);
1992 * Shifts the visible alignment by the specified number of columns - left if
1993 * negative, right if positive. Copies and moves sequences and annotations (if
1994 * shown). Scales, hidden column markers and any newly visible columns must be
1999 protected void shiftWrappedAlignment(int positions)
2005 int charWidth = av.getCharWidth();
2007 int canvasHeight = getHeight();
2008 ViewportRanges ranges = av.getRanges();
2009 int viewportWidth = ranges.getViewportWidth();
2010 int widthToCopy = (ranges.getViewportWidth() - Math.abs(positions))
2012 int heightToCopy = wrappedRepeatHeightPx - wrappedSpaceAboveAlignment;
2013 int xMax = ranges.getVisibleAlignmentWidth();
2018 * shift right (after scroll left)
2019 * for each wrapped width (starting with the last), copy (width-positions)
2020 * columns from the left margin to the right margin, and copy positions
2021 * columns from the right margin of the row above (if any) to the
2022 * left margin of the current row
2026 * get y-offset of last wrapped width, first row of sequences
2028 int y = canvasHeight / wrappedRepeatHeightPx * wrappedRepeatHeightPx;
2029 y += wrappedSpaceAboveAlignment;
2030 int copyFromLeftStart = labelWidthWest;
2031 int copyFromRightStart = copyFromLeftStart + widthToCopy;
2035 gg.copyArea(copyFromLeftStart, y, widthToCopy, heightToCopy,
2036 positions * charWidth, 0);
2039 gg.copyArea(copyFromRightStart, y - wrappedRepeatHeightPx,
2040 positions * charWidth, heightToCopy, -widthToCopy,
2041 wrappedRepeatHeightPx);
2044 y -= wrappedRepeatHeightPx;
2050 * shift left (after scroll right)
2051 * for each wrapped width (starting with the first), copy (width-positions)
2052 * columns from the right margin to the left margin, and copy positions
2053 * columns from the left margin of the row below (if any) to the
2054 * right margin of the current row
2056 int xpos = av.getRanges().getStartRes();
2057 int y = wrappedSpaceAboveAlignment;
2058 int copyFromRightStart = labelWidthWest - positions * charWidth;
2060 while (y < canvasHeight)
2062 gg.copyArea(copyFromRightStart, y, widthToCopy, heightToCopy,
2063 positions * charWidth, 0);
2064 if (y + wrappedRepeatHeightPx < canvasHeight - wrappedRepeatHeightPx
2065 && (xpos + viewportWidth <= xMax))
2067 gg.copyArea(labelWidthWest, y + wrappedRepeatHeightPx, -positions
2068 * charWidth, heightToCopy, widthToCopy,
2069 -wrappedRepeatHeightPx);
2072 y += wrappedRepeatHeightPx;
2073 xpos += viewportWidth;
2080 * Redraws any positions in the search results in the visible region of a
2081 * wrapped alignment. Any highlights are drawn depending on the search results
2082 * set on the Viewport, not the <code>results</code> argument. This allows
2083 * this method to be called either to clear highlights (passing the previous
2084 * search results), or to draw new highlights.
2089 protected boolean drawMappedPositionsWrapped(SearchResultsI results)
2091 if (results == null)
2095 int charHeight = av.getCharHeight();
2097 boolean matchFound = false;
2099 calculateWrappedGeometry(getWidth(), getHeight());
2100 int wrappedWidth = av.getWrappedWidth();
2101 int wrappedHeight = wrappedRepeatHeightPx;
2103 ViewportRanges ranges = av.getRanges();
2104 int canvasHeight = getHeight();
2105 int repeats = canvasHeight / wrappedHeight;
2106 if (canvasHeight / wrappedHeight > 0)
2111 int firstVisibleColumn = ranges.getStartRes();
2112 int lastVisibleColumn = ranges.getStartRes() + repeats
2113 * ranges.getViewportWidth() - 1;
2115 AlignmentI alignment = av.getAlignment();
2116 if (av.hasHiddenColumns())
2118 firstVisibleColumn = alignment.getHiddenColumns()
2119 .adjustForHiddenColumns(firstVisibleColumn);
2120 lastVisibleColumn = alignment.getHiddenColumns()
2121 .adjustForHiddenColumns(lastVisibleColumn);
2124 int gapHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
2126 for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
2127 .getEndSeq(); seqNo++)
2129 SequenceI seq = alignment.getSequenceAt(seqNo);
2131 int[] visibleResults = results.getResults(seq, firstVisibleColumn,
2133 if (visibleResults != null)
2135 for (int i = 0; i < visibleResults.length - 1; i += 2)
2137 int firstMatchedColumn = visibleResults[i];
2138 int lastMatchedColumn = visibleResults[i + 1];
2139 if (firstMatchedColumn <= lastVisibleColumn
2140 && lastMatchedColumn >= firstVisibleColumn)
2143 * found a search results match in the visible region
2145 firstMatchedColumn = Math.max(firstMatchedColumn,
2146 firstVisibleColumn);
2147 lastMatchedColumn = Math.min(lastMatchedColumn,
2151 * draw each mapped position separately (as contiguous positions may
2152 * wrap across lines)
2154 for (int mappedPos = firstMatchedColumn; mappedPos <= lastMatchedColumn; mappedPos++)
2156 int displayColumn = mappedPos;
2157 if (av.hasHiddenColumns())
2159 displayColumn = alignment.getHiddenColumns()
2160 .findColumnPosition(displayColumn);
2164 * transX: offset from left edge of canvas to residue position
2166 int transX = labelWidthWest
2167 + ((displayColumn - ranges.getStartRes()) % wrappedWidth)
2168 * av.getCharWidth();
2171 * transY: offset from top edge of canvas to residue position
2173 int transY = gapHeight;
2174 transY += (displayColumn - ranges.getStartRes())
2175 / wrappedWidth * wrappedHeight;
2176 transY += (seqNo - ranges.getStartSeq()) * av.getCharHeight();
2179 * yOffset is from graphics origin to start of visible region
2181 int yOffset = 0;// (displayColumn / wrappedWidth) * wrappedHeight;
2182 if (transY < getHeight())
2185 gg.translate(transX, transY);
2186 drawPanel(gg, displayColumn, displayColumn, seqNo, seqNo,
2188 gg.translate(-transX, -transY);
2200 * Answers the width in pixels of the left scale labels (0 if not shown)
2204 int getLabelWidthWest()
2206 return labelWidthWest;