0d27354dd8a2ef5054ff71459834e4c73d7ecb32
[jalview.git] / src / jalview / gui / SeqCanvas.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
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.
11  *  
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.
16  * 
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.
20  */
21 package jalview.gui;
22
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.datamodel.VisibleContigsIterator;
29 import jalview.renderer.ScaleRenderer;
30 import jalview.renderer.ScaleRenderer.ScaleMark;
31 import jalview.util.Comparison;
32 import jalview.viewmodel.ViewportListenerI;
33 import jalview.viewmodel.ViewportRanges;
34
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.Rectangle;
42 import java.awt.RenderingHints;
43 import java.awt.image.BufferedImage;
44 import java.beans.PropertyChangeEvent;
45 import java.util.Iterator;
46 import java.util.List;
47
48 import javax.swing.JPanel;
49
50 /**
51  * The Swing component on which the alignment sequences, and annotations (if
52  * shown), are drawn. This includes scales above, left and right (if shown) in
53  * Wrapped mode, but not the scale above in Unwrapped mode.
54  * 
55  */
56 @SuppressWarnings("serial")
57 public class SeqCanvas extends JPanel implements ViewportListenerI
58 {
59   /*
60    * pixels gap between sequences and annotations when in wrapped mode
61    */
62   static final int SEQS_ANNOTATION_GAP = 3;
63
64   private static final String ZEROS = "0000000000";
65
66   final FeatureRenderer fr;
67
68   BufferedImage img;
69
70   AlignViewport av;
71
72   int cursorX = 0;
73
74   int cursorY = 0;
75
76   private final SequenceRenderer seqRdr;
77
78   boolean fastPaint = false;
79
80   private boolean fastpainting = false;
81
82   private AnnotationPanel annotations;
83
84   /*
85    * measurements for drawing a wrapped alignment
86    */
87   private int labelWidthEast; // label right width in pixels if shown
88
89   private int labelWidthWest; // label left width in pixels if shown
90
91   int wrappedSpaceAboveAlignment; // gap between widths
92
93   int wrappedRepeatHeightPx; // height in pixels of wrapped width
94
95   private int wrappedVisibleWidths; // number of wrapped widths displayed
96
97   // Don't do this! Graphics handles are supposed to be transient
98   //private Graphics2D gg;
99
100   /**
101    * Creates a new SeqCanvas object.
102    * 
103    * @param ap
104    */
105   public SeqCanvas(AlignmentPanel ap)
106   {
107     this.av = ap.av;
108     fr = new FeatureRenderer(ap);
109     seqRdr = new SequenceRenderer(av);
110     setLayout(new BorderLayout());
111     PaintRefresher.Register(this, av.getSequenceSetId());
112     setBackground(Color.white);
113
114     av.getRanges().addPropertyChangeListener(this);
115   }
116
117   public SequenceRenderer getSequenceRenderer()
118   {
119     return seqRdr; 
120   }
121
122   public FeatureRenderer getFeatureRenderer()
123   {
124     return fr;
125   }
126
127   /**
128    * Draws the scale above a region of a wrapped alignment, consisting of a
129    * column number every major interval (10 columns).
130    * 
131    * @param g
132    *          the graphics context to draw on, positioned at the start (bottom
133    *          left) of the line on which to draw any scale marks
134    * @param startx
135    *          start alignment column (0..)
136    * @param endx
137    *          end alignment column (0..)
138    * @param ypos
139    *          y offset to draw at
140    */
141   private void drawNorthScale(Graphics g, int startx, int endx, int ypos)
142   {
143     int charHeight = av.getCharHeight();
144     int charWidth = av.getCharWidth();
145
146     /*
147      * white fill the scale space (for the fastPaint case)
148      */
149     g.setColor(Color.white);
150     g.fillRect(0, ypos - charHeight - charHeight / 2, getWidth(),
151             charHeight * 3 / 2 + 2);
152     g.setColor(Color.black);
153
154     List<ScaleMark> marks = new ScaleRenderer().calculateMarks(av, startx,
155             endx);
156     for (ScaleMark mark : marks)
157     {
158       int mpos = mark.column; // (i - startx - 1)
159       if (mpos < 0)
160       {
161         continue;
162       }
163       String mstring = mark.text;
164
165       if (mark.major)
166       {
167         if (mstring != null)
168         {
169           g.drawString(mstring, mpos * charWidth, ypos - (charHeight / 2));
170         }
171
172         /*
173          * draw a tick mark below the column number, centred on the column;
174          * height of tick mark is 4 pixels less than half a character
175          */
176         int xpos = (mpos * charWidth) + (charWidth / 2);
177         g.drawLine(xpos, (ypos + 2) - (charHeight / 2), xpos, ypos - 2);
178       }
179     }
180   }
181
182   /**
183    * Draw the scale to the left or right of a wrapped alignment
184    * 
185    * @param g
186    *          graphics context, positioned at the start of the scale to be drawn
187    * @param startx
188    *          first column of wrapped width (0.. excluding any hidden columns)
189    * @param endx
190    *          last column of wrapped width (0.. excluding any hidden columns)
191    * @param ypos
192    *          vertical offset at which to begin the scale
193    * @param left
194    *          if true, scale is left of residues, if false, scale is right
195    */
196   void drawVerticalScale(Graphics g, final int startx, final int endx,
197           final int ypos, final boolean left)
198   {
199     int charHeight = av.getCharHeight();
200     int charWidth = av.getCharWidth();
201
202     int yPos = ypos + charHeight;
203     int startX = startx;
204     int endX = endx;
205     
206     if (av.hasHiddenColumns())
207     {
208       HiddenColumns hiddenColumns = av.getAlignment().getHiddenColumns();
209       startX = hiddenColumns.visibleToAbsoluteColumn(startx);
210       endX = hiddenColumns.visibleToAbsoluteColumn(endx);
211     }
212     FontMetrics fm = getFontMetrics(av.getFont());
213
214     for (int i = 0; i < av.getAlignment().getHeight(); i++)
215     {
216       SequenceI seq = av.getAlignment().getSequenceAt(i);
217
218       /*
219        * find sequence position of first non-gapped position -
220        * to the right if scale left, to the left if scale right
221        */
222       int index = left ? startX : endX;
223       int value = -1;
224       while (index >= startX && index <= endX)
225       {
226         if (!Comparison.isGap(seq.getCharAt(index)))
227         {
228           value = seq.findPosition(index);
229           break;
230         }
231         if (left)
232         {
233           index++;
234         }
235         else
236         {
237           index--;
238         }
239       }
240
241       
242       /*
243        * white fill the space for the scale
244        */
245       g.setColor(Color.white);
246       int y = (yPos + (i * charHeight)) - (charHeight / 5);
247       // fillRect origin is top left of rectangle
248       g.fillRect(0, y - charHeight, left ? labelWidthWest : labelWidthEast,
249               charHeight + 1);
250
251       if (value != -1)
252       {
253         /*
254          * draw scale value, right justified within its width less half a
255          * character width padding on the right
256          */
257         int labelSpace = left ? labelWidthWest : labelWidthEast;
258         labelSpace -= charWidth / 2; // leave space to the right
259         String valueAsString = String.valueOf(value);
260         int labelLength = fm.stringWidth(valueAsString);
261         int xOffset = labelSpace - labelLength;
262         g.setColor(Color.black);
263         g.drawString(valueAsString, xOffset, y);
264       }
265     }
266
267   }
268
269   /**
270    * Does a fast paint of an alignment in response to a scroll. Most of the
271    * visible region is simply copied and shifted, and then any newly visible
272    * columns or rows are drawn. The scroll may be horizontal or vertical, but
273    * not both at once. Scrolling may be the result of
274    * <ul>
275    * <li>dragging a scroll bar</li>
276    * <li>clicking in the scroll bar</li>
277    * <li>scrolling by trackpad, middle mouse button, or other device</li>
278    * <li>by moving the box in the Overview window</li>
279    * <li>programmatically to make a highlighted position visible</li>
280    * <li>pasting a block of sequences</li>
281    * </ul>
282    * 
283    * @param horizontal
284    *          columns to shift right (positive) or left (negative)
285    * @param vertical
286    *          rows to shift down (positive) or up (negative)
287    */
288   public void fastPaint(int horizontal, int vertical)
289   {
290
291     // effectively:
292     // if (horizontal != 0 && vertical != 0)
293     // throw new InvalidArgumentException();
294     if (fastpainting || img == null)
295     {
296       return;
297     }
298     fastpainting = true;
299     fastPaint = true;
300     try
301     {
302       int charHeight = av.getCharHeight();
303       int charWidth = av.getCharWidth();
304
305       ViewportRanges ranges = av.getRanges();
306       int startRes = ranges.getStartRes();
307       int endRes = ranges.getEndRes();
308       int startSeq = ranges.getStartSeq();
309       int endSeq = ranges.getEndSeq();
310       int transX = 0;
311       int transY = 0;
312
313       if (horizontal > 0) // scrollbar pulled right, image to the left
314       {
315         transX = (endRes - startRes - horizontal) * charWidth;
316         startRes = endRes - horizontal;
317       }
318       else if (horizontal < 0)
319       {
320         endRes = startRes - horizontal;
321       }
322
323       if (vertical > 0) // scroll down
324       {
325         startSeq = endSeq - vertical;
326
327         if (startSeq < ranges.getStartSeq())
328         { // ie scrolling too fast, more than a page at a time
329           startSeq = ranges.getStartSeq();
330         }
331         else
332         {
333           transY = img.getHeight() - ((vertical + 1) * charHeight);
334         }
335       }
336       else if (vertical < 0)
337       {
338         endSeq = startSeq - vertical;
339
340         if (endSeq > ranges.getEndSeq())
341         {
342           endSeq = ranges.getEndSeq();
343         }
344       }
345
346
347       // System.err.println(">>> FastPaint to " + transX + " " + transY + " "
348       // + horizontal + " " + vertical + " " + startRes + " " + endRes
349       // + " " + startSeq + " " + endSeq);
350
351       Graphics gg = img.getGraphics();
352       gg.copyArea(horizontal * charWidth, vertical * charHeight,
353               img.getWidth(), img.getHeight(), -horizontal * charWidth,
354               -vertical * charHeight);
355       gg.translate(transX, transY);
356       drawPanel(gg, startRes, endRes, startSeq, endSeq, 0);
357       gg.translate(-transX, -transY);
358       gg.dispose();
359
360       // Call repaint on alignment panel so that repaints from other alignment
361       // panel components can be aggregated. Otherwise performance of the
362       // overview window and others may be adversely affected.
363       // System.out.println("SeqCanvas fastPaint() repaint() request...");
364       av.getAlignPanel().repaint();
365     } finally
366     {
367       fastpainting = false;
368     }
369   }
370
371   @Override
372   public void paintComponent(Graphics g)
373   {
374
375     int charHeight = av.getCharHeight();
376     int charWidth = av.getCharWidth();
377
378     int width = getWidth();
379     int height = getHeight();
380
381     width -= (width % charWidth);
382     height -= (height % charHeight);
383
384     // BH 2019 can't possibly fastPaint if either width or height is 0
385
386     if (width == 0 || height == 0)
387     {
388       return;
389     }
390
391     ViewportRanges ranges = av.getRanges();
392     int startRes = ranges.getStartRes();
393     int startSeq = ranges.getStartSeq();
394     int endRes = ranges.getEndRes();
395     int endSeq = ranges.getEndSeq();
396
397     // [JAL-3226] problem that JavaScript (or Java) may consolidate multiple
398     // repaint() requests in unpredictable ways. In this case, the issue was
399     // that in response to a CTRL-C/CTRL-V paste request, in Java a fast
400     // repaint request preceded two full requests, thus resulting
401     // in a full request for paint. In constrast, in JavaScript, the three
402     // requests were bundled together into one, so the fastPaint flag was
403     // still present for the second and third request.
404     //
405     // This resulted in incomplete painting.
406     //
407     // The solution was to set seqCanvas.fastPaint and idCanvas.fastPaint false
408     // in PaintRefresher when the target to be painted is one of those two
409     // components.
410     //
411     // BH 2019.04.22
412     //
413     // An initial idea; can be removed once we determine this issue is closed:
414     // if (av.isFastPaintDisabled())
415     // {
416     // fastPaint = false;
417     // }
418
419     Rectangle vis, clip;
420     if (img != null
421             && (fastPaint
422                     || (vis = getVisibleRect()).width != (clip = g
423                             .getClipBounds()).width
424                     || vis.height != clip.height))
425     {
426       g.drawImage(img, 0, 0, this);
427       drawSelectionGroup((Graphics2D) g, startRes, endRes, startSeq,
428               endSeq);
429       fastPaint = false;
430     }
431     else
432     {
433       // img is a cached version of the last view we drew.
434       // If we have no img or the size has changed, make a new one.
435       //
436       if (img == null || width != img.getWidth()
437               || height != img.getHeight())
438       {
439         img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
440       }
441
442       Graphics2D gg = (Graphics2D) img.getGraphics();
443       gg.setFont(av.getFont());
444
445       if (av.antiAlias)
446       {
447         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
448                 RenderingHints.VALUE_ANTIALIAS_ON);
449       }
450
451       gg.setColor(Color.white);
452       gg.fillRect(0, 0, img.getWidth(), img.getHeight());
453
454       if (av.getWrapAlignment())
455       {
456         drawWrappedPanel(gg, width, height, ranges.getStartRes());
457       }
458       else
459       {
460         drawPanel(gg, startRes, endRes, startSeq, endSeq, 0);
461       }
462
463       drawSelectionGroup(gg, startRes, endRes, startSeq, endSeq);
464
465       g.drawImage(img, 0, 0, this);
466       gg.dispose();
467     }
468
469     if (av.cursorMode)
470     {
471       drawCursor(g, startRes, endRes, startSeq, endSeq);
472     }
473   }
474   
475   /**
476    * Draw an alignment panel for printing
477    * 
478    * @param g1
479    *          Graphics object to draw with
480    * @param startRes
481    *          start residue of print area
482    * @param endRes
483    *          end residue of print area
484    * @param startSeq
485    *          start sequence of print area
486    * @param endSeq
487    *          end sequence of print area
488    */
489   public void drawPanelForPrinting(Graphics g1, int startRes, int endRes,
490           int startSeq, int endSeq)
491   {
492     drawPanel(g1, startRes, endRes, startSeq, endSeq, 0);
493
494     drawSelectionGroup((Graphics2D) g1, startRes, endRes,
495             startSeq, endSeq);
496   }
497
498   /**
499    * Draw a wrapped alignment panel for printing
500    * 
501    * @param g
502    *          Graphics object to draw with
503    * @param canvasWidth
504    *          width of drawing area
505    * @param canvasHeight
506    *          height of drawing area
507    * @param startRes
508    *          start residue of print area
509    */
510   public void drawWrappedPanelForPrinting(Graphics g, int canvasWidth,
511           int canvasHeight, int startRes)
512   {
513     drawWrappedPanel(g, canvasWidth, canvasHeight, startRes);
514
515     SequenceGroup group = av.getSelectionGroup();
516     if (group != null)
517     {
518       drawWrappedSelection((Graphics2D) g, group, canvasWidth, canvasHeight,
519                 startRes);
520     }
521   }
522
523   /**
524    * Returns the visible width of the canvas in residues, after allowing for
525    * East or West scales (if shown)
526    * 
527    * @param canvasWidth
528    *          the width in pixels (possibly including scales)
529    * 
530    * @return
531    */
532   public int getWrappedCanvasWidth(int canvasWidth)
533   {
534     int charWidth = av.getCharWidth();
535
536     FontMetrics fm = getFontMetrics(av.getFont());
537
538     int labelWidth = 0;
539     
540     if (av.getScaleRightWrapped() || av.getScaleLeftWrapped())
541     {
542       labelWidth = getLabelWidth(fm);
543     }
544
545     labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0;
546
547     labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0;
548
549     return (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
550   }
551
552   /**
553    * Returns a pixel width sufficient to show the largest sequence coordinate
554    * (end position) in the alignment, calculated as the FontMetrics width of
555    * zeroes "0000000" limited to the number of decimal digits to be shown (3 for
556    * 1-10, 4 for 11-99 etc). One character width is added to this, to allow for
557    * half a character width space on either side.
558    * 
559    * @param fm
560    * @return
561    */
562   protected int getLabelWidth(FontMetrics fm)
563   {
564     /*
565      * find the biggest sequence end position we need to show
566      * (note this is not necessarily the sequence length)
567      */
568     int maxWidth = 0;
569     AlignmentI alignment = av.getAlignment();
570     for (int i = 0; i < alignment.getHeight(); i++)
571     {
572       maxWidth = Math.max(maxWidth, alignment.getSequenceAt(i).getEnd());
573     }
574
575     int length = 0;
576     for (int i = maxWidth; i > 0; i /= 10)
577     {
578       length++;
579     }
580
581     return fm.stringWidth(ZEROS.substring(0, length)) + av.getCharWidth();
582   }
583
584   /**
585    * Draws as many widths of a wrapped alignment as can fit in the visible
586    * window
587    * 
588    * @param g
589    * @param canvasWidth
590    *          available width in pixels
591    * @param canvasHeight
592    *          available height in pixels
593    * @param startColumn
594    *          the first column (0...) of the alignment to draw
595    */
596   public void drawWrappedPanel(Graphics g, int canvasWidth,
597           int canvasHeight, final int startColumn)
598   {
599     int wrappedWidthInResidues = calculateWrappedGeometry(canvasWidth,
600             canvasHeight);
601
602     av.setWrappedWidth(wrappedWidthInResidues);
603
604     ViewportRanges ranges = av.getRanges();
605     ranges.setViewportStartAndWidth(startColumn, wrappedWidthInResidues);
606
607     // we need to call this again to make sure the startColumn +
608     // wrappedWidthInResidues values are used to calculate wrappedVisibleWidths
609     // correctly.
610     calculateWrappedGeometry(canvasWidth, canvasHeight);
611
612     /*
613      * draw one width at a time (excluding any scales shown),
614      * until we have run out of either alignment or vertical space available
615      */
616     int ypos = wrappedSpaceAboveAlignment;
617     int maxWidth = ranges.getVisibleAlignmentWidth();
618
619     int start = startColumn;
620     int currentWidth = 0;
621     while ((currentWidth < wrappedVisibleWidths) && (start < maxWidth))
622     {
623       int endColumn = Math
624               .min(maxWidth, start + wrappedWidthInResidues - 1);
625       drawWrappedWidth(g, ypos, start, endColumn, canvasHeight);
626       ypos += wrappedRepeatHeightPx;
627       start += wrappedWidthInResidues;
628       currentWidth++;
629     }
630
631     drawWrappedDecorators(g, startColumn);
632   }
633
634   /**
635    * Calculates and saves values needed when rendering a wrapped alignment.
636    * These depend on many factors, including
637    * <ul>
638    * <li>canvas width and height</li>
639    * <li>number of visible sequences, and height of annotations if shown</li>
640    * <li>font and character width</li>
641    * <li>whether scales are shown left, right or above the alignment</li>
642    * </ul>
643    * 
644    * @param canvasWidth
645    * @param canvasHeight
646    * @return the number of residue columns in each width
647    */
648   protected int calculateWrappedGeometry(int canvasWidth, int canvasHeight)
649   {
650     int charHeight = av.getCharHeight();
651
652     /*
653      * vertical space in pixels between wrapped widths of alignment
654      * - one character height, or two if scale above is drawn
655      */
656     wrappedSpaceAboveAlignment = charHeight
657             * (av.getScaleAboveWrapped() ? 2 : 1);
658
659     /*
660      * compute height in pixels of the wrapped widths
661      * - start with space above plus sequences
662      */
663     wrappedRepeatHeightPx = wrappedSpaceAboveAlignment;
664     wrappedRepeatHeightPx += av.getAlignment().getHeight()
665             * charHeight;
666
667     /*
668      * add annotations panel height if shown
669      * also gap between sequences and annotations
670      */
671     if (av.isShowAnnotation())
672     {
673       wrappedRepeatHeightPx += getAnnotationHeight();
674       wrappedRepeatHeightPx += SEQS_ANNOTATION_GAP; // 3px
675     }
676
677     /*
678      * number of visible widths (the last one may be part height),
679      * ensuring a part height includes at least one sequence
680      */
681     ViewportRanges ranges = av.getRanges();
682     wrappedVisibleWidths = canvasHeight / wrappedRepeatHeightPx;
683     int remainder = canvasHeight % wrappedRepeatHeightPx;
684     if (remainder >= (wrappedSpaceAboveAlignment + charHeight))
685     {
686       wrappedVisibleWidths++;
687     }
688
689     /*
690      * compute width in residues; this also sets East and West label widths
691      */
692     int wrappedWidthInResidues = getWrappedCanvasWidth(canvasWidth);
693
694     /*
695      *  limit visibleWidths to not exceed width of alignment
696      */
697     int xMax = ranges.getVisibleAlignmentWidth();
698     int startToEnd = xMax - ranges.getStartRes();
699     int maxWidths = startToEnd / wrappedWidthInResidues;
700     if (startToEnd % wrappedWidthInResidues > 0)
701     {
702       maxWidths++;
703     }
704     wrappedVisibleWidths = Math.min(wrappedVisibleWidths, maxWidths);
705
706     return wrappedWidthInResidues;
707   }
708
709   /**
710    * Draws one width of a wrapped alignment, including sequences and
711    * annnotations, if shown, but not scales or hidden column markers
712    * 
713    * @param g
714    * @param ypos
715    * @param startColumn
716    * @param endColumn
717    * @param canvasHeight
718    */
719   protected void drawWrappedWidth(Graphics g, final int ypos,
720           final int startColumn, final int endColumn,
721           final int canvasHeight)
722   {
723     ViewportRanges ranges = av.getRanges();
724     int viewportWidth = ranges.getViewportWidth();
725
726     int endx = Math.min(startColumn + viewportWidth - 1, endColumn);
727
728     /*
729      * move right before drawing by the width of the scale left (if any)
730      * plus column offset from left margin (usually zero, but may be non-zero
731      * when fast painting is drawing just a few columns)
732      */
733     int charWidth = av.getCharWidth();
734     int xOffset = labelWidthWest
735             + ((startColumn - ranges.getStartRes()) % viewportWidth)
736             * charWidth;
737
738     g.translate(xOffset, 0);
739
740     /*
741      * white fill the region to be drawn (so incremental fast paint doesn't
742      * scribble over an existing image)
743      */
744     g.setColor(Color.white);
745     g.fillRect(0, ypos, (endx - startColumn + 1) * charWidth,
746             wrappedRepeatHeightPx);
747
748     drawPanel(g, startColumn, endx, 0, av.getAlignment().getHeight() - 1,
749             ypos);
750
751     int cHeight = av.getAlignment().getHeight() * av.getCharHeight();
752
753     if (av.isShowAnnotation())
754     {
755       final int yShift = cHeight + ypos + SEQS_ANNOTATION_GAP;
756       g.translate(0, yShift);
757       if (annotations == null)
758       {
759         annotations = new AnnotationPanel(av);
760       }
761
762       annotations.renderer.drawComponent(annotations, av, g, -1,
763               startColumn, endx + 1);
764       g.translate(0, -yShift);
765     }
766     g.translate(-xOffset, 0);
767   }
768
769   /**
770    * Draws scales left, right and above (if shown), and any hidden column
771    * markers, on all widths of the wrapped alignment
772    * 
773    * @param g
774    * @param startColumn
775    */
776   protected void drawWrappedDecorators(Graphics g, final int startColumn)
777   {
778     int charWidth = av.getCharWidth();
779
780     g.setFont(av.getFont());
781
782     g.setColor(Color.black);
783
784     int ypos = wrappedSpaceAboveAlignment;
785     ViewportRanges ranges = av.getRanges();
786     int viewportWidth = ranges.getViewportWidth();
787     int maxWidth = ranges.getVisibleAlignmentWidth();
788     int widthsDrawn = 0;
789     int startCol = startColumn;
790
791     while (widthsDrawn < wrappedVisibleWidths)
792     {
793       int endColumn = Math.min(maxWidth, startCol + viewportWidth - 1);
794
795       if (av.getScaleLeftWrapped())
796       {
797         drawVerticalScale(g, startCol, endColumn - 1, ypos, true);
798       }
799
800       if (av.getScaleRightWrapped())
801       {
802         int x = labelWidthWest + viewportWidth * charWidth;
803         
804         g.translate(x, 0);
805         drawVerticalScale(g, startCol, endColumn, ypos, false);
806         g.translate(-x, 0);
807       }
808
809       /*
810        * white fill region of scale above and hidden column markers
811        * (to support incremental fast paint of image)
812        */
813       g.translate(labelWidthWest, 0);
814       g.setColor(Color.white);
815       g.fillRect(0, ypos - wrappedSpaceAboveAlignment, viewportWidth
816               * charWidth + labelWidthWest, wrappedSpaceAboveAlignment);
817       g.setColor(Color.black);
818       g.translate(-labelWidthWest, 0);
819
820       g.translate(labelWidthWest, 0);
821
822       if (av.getScaleAboveWrapped())
823       {
824         drawNorthScale(g, startCol, endColumn, ypos);
825       }
826
827       if (av.hasHiddenColumns() && av.getShowHiddenMarkers())
828       {
829         drawHiddenColumnMarkers(g, ypos, startCol, endColumn);
830       }
831
832       g.translate(-labelWidthWest, 0);
833
834       ypos += wrappedRepeatHeightPx;
835       startCol += viewportWidth;
836       widthsDrawn++;
837     }
838   }
839
840   /**
841    * Draws markers (triangles) above hidden column positions between startColumn
842    * and endColumn.
843    * 
844    * @param g
845    * @param ypos
846    * @param startColumn
847    * @param endColumn
848    */
849   protected void drawHiddenColumnMarkers(Graphics g, int ypos,
850           int startColumn, int endColumn)
851   {
852     int charHeight = av.getCharHeight();
853     int charWidth = av.getCharWidth();
854
855     g.setColor(Color.blue);
856     int res;
857     HiddenColumns hidden = av.getAlignment().getHiddenColumns();
858
859     Iterator<Integer> it = hidden.getStartRegionIterator(startColumn,
860             endColumn);
861     while (it.hasNext())
862     {
863       res = it.next() - startColumn;
864
865       if (res < 0 || res > endColumn - startColumn + 1)
866       {
867         continue;
868       }
869
870       /*
871        * draw a downward-pointing triangle at the hidden columns location
872        * (before the following visible column)
873        */
874       int xMiddle = res * charWidth;
875       int[] xPoints = new int[] { xMiddle - charHeight / 4,
876           xMiddle + charHeight / 4, xMiddle };
877       int yTop = ypos - (charHeight / 2);
878       int[] yPoints = new int[] { yTop, yTop, yTop + 8 };
879       g.fillPolygon(xPoints, yPoints, 3);
880     }
881   }
882
883   /*
884    * Draw a selection group over a wrapped alignment
885    */
886   private void drawWrappedSelection(Graphics2D g, SequenceGroup group,
887           int canvasWidth,
888           int canvasHeight, int startRes)
889   {
890     int charHeight = av.getCharHeight();
891     int charWidth = av.getCharWidth();
892       
893     // height gap above each panel
894     int hgap = charHeight;
895     if (av.getScaleAboveWrapped())
896     {
897       hgap += charHeight;
898     }
899
900     int cWidth = (canvasWidth - labelWidthEast - labelWidthWest)
901             / charWidth;
902     int cHeight = av.getAlignment().getHeight() * charHeight;
903
904     int startx = startRes;
905     int endx;
906     int ypos = hgap; // vertical offset
907     int maxwidth = av.getAlignment().getVisibleWidth();
908
909     // chop the wrapped alignment extent up into panel-sized blocks and treat
910     // each block as if it were a block from an unwrapped alignment
911     g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
912             BasicStroke.JOIN_ROUND, 3f, new float[]
913             { 5f, 3f }, 0f));
914     g.setColor(Color.RED);
915     while ((ypos <= canvasHeight) && (startx < maxwidth))
916     {
917       // set end value to be start + width, or maxwidth, whichever is smaller
918       endx = startx + cWidth - 1;
919
920       if (endx > maxwidth)
921       {
922         endx = maxwidth;
923       }
924
925       g.translate(labelWidthWest, 0);
926
927       drawUnwrappedSelection(g, group, startx, endx, 0,
928               av.getAlignment().getHeight() - 1,
929               ypos);
930
931       g.translate(-labelWidthWest, 0);
932
933       // update vertical offset
934       ypos += cHeight + getAnnotationHeight() + hgap;
935
936       // update horizontal offset
937       startx += cWidth;
938     }
939     g.setStroke(new BasicStroke());
940   }
941
942   int getAnnotationHeight()
943   {
944     if (!av.isShowAnnotation())
945     {
946       return 0;
947     }
948
949     if (annotations == null)
950     {
951       annotations = new AnnotationPanel(av);
952     }
953
954     return annotations.adjustPanelHeight();
955   }
956
957   /**
958    * Draws the visible region of the alignment on the graphics context. If there
959    * are hidden column markers in the visible region, then each sub-region
960    * between the markers is drawn separately, followed by the hidden column
961    * marker.
962    * 
963    * @param g1
964    *          the graphics context, positioned at the first residue to be drawn
965    * @param startRes
966    *          offset of the first column to draw (0..)
967    * @param endRes
968    *          offset of the last column to draw (0..)
969    * @param startSeq
970    *          offset of the first sequence to draw (0..)
971    * @param endSeq
972    *          offset of the last sequence to draw (0..)
973    * @param yOffset
974    *          vertical offset at which to draw (for wrapped alignments)
975    */
976   public void drawPanel(Graphics g1, final int startRes, final int endRes,
977           final int startSeq, final int endSeq, final int yOffset)
978   {
979     int charHeight = av.getCharHeight();
980     int charWidth = av.getCharWidth();
981
982     if (!av.hasHiddenColumns())
983     {
984       draw(g1, startRes, endRes, startSeq, endSeq, yOffset);
985     }
986     else
987     {
988       int screenY = 0;
989       int blockStart;
990       int blockEnd;
991
992       HiddenColumns hidden = av.getAlignment().getHiddenColumns();
993       VisibleContigsIterator regions = hidden
994               .getVisContigsIterator(startRes, endRes + 1, true);
995
996       while (regions.hasNext())
997       {
998         int[] region = regions.next();
999         blockEnd = region[1];
1000         blockStart = region[0];
1001
1002         /*
1003          * draw up to just before the next hidden region, or the end of
1004          * the visible region, whichever comes first
1005          */
1006         g1.translate(screenY * charWidth, 0);
1007
1008         draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
1009
1010         /*
1011          * draw the downline of the hidden column marker (ScalePanel draws the
1012          * triangle on top) if we reached it
1013          */
1014         if (av.getShowHiddenMarkers()
1015                 && (regions.hasNext() || regions.endsAtHidden()))
1016         {
1017           g1.setColor(Color.blue);
1018
1019           g1.drawLine((blockEnd - blockStart + 1) * charWidth - 1,
1020                   0 + yOffset, (blockEnd - blockStart + 1) * charWidth - 1,
1021                   (endSeq - startSeq + 1) * charHeight + yOffset);
1022         }
1023
1024         g1.translate(-screenY * charWidth, 0);
1025         screenY += blockEnd - blockStart + 1;
1026       }
1027     }
1028
1029   }
1030
1031   /**
1032    * Draws a region of the visible alignment
1033    * 
1034    * @param g1
1035    * @param startRes
1036    *          offset of the first column in the visible region (0..)
1037    * @param endRes
1038    *          offset of the last column in the visible region (0..)
1039    * @param startSeq
1040    *          offset of the first sequence in the visible region (0..)
1041    * @param endSeq
1042    *          offset of the last sequence in the visible region (0..)
1043    * @param yOffset
1044    *          vertical offset at which to draw (for wrapped alignments)
1045    */
1046   private void draw(Graphics g, int startRes, int endRes, int startSeq,
1047           int endSeq, int offset)
1048   {
1049     int charHeight = av.getCharHeight();
1050     int charWidth = av.getCharWidth();
1051
1052     g.setFont(av.getFont());
1053     seqRdr.prepare(g, av.isRenderGaps());
1054
1055     SequenceI nextSeq;
1056
1057     // / First draw the sequences
1058     // ///////////////////////////
1059     for (int i = startSeq; i <= endSeq; i++)
1060     {
1061       nextSeq = av.getAlignment().getSequenceAt(i);
1062       if (nextSeq == null)
1063       {
1064         // occasionally, a race condition occurs such that the alignment row is
1065         // empty
1066         continue;
1067       }
1068       seqRdr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
1069               startRes, endRes, offset + ((i - startSeq) * charHeight));
1070
1071       if (av.isShowSequenceFeatures())
1072       {
1073         fr.drawSequence(g, nextSeq, startRes, endRes,
1074                 offset + ((i - startSeq) * charHeight), false);
1075       }
1076
1077       /*
1078        * highlight search Results once sequence has been drawn
1079        */
1080       if (av.hasSearchResults())
1081       {
1082         SearchResultsI searchResults = av.getSearchResults();
1083         int[] visibleResults = searchResults.getResults(nextSeq, startRes,
1084                 endRes);
1085         if (visibleResults != null)
1086         {
1087           for (int r = 0; r < visibleResults.length; r += 2)
1088           {
1089             seqRdr.drawHighlightedText(nextSeq, visibleResults[r],
1090                     visibleResults[r + 1],
1091                     (visibleResults[r] - startRes) * charWidth,
1092                     offset + ((i - startSeq) * charHeight));
1093           }
1094         }
1095       }
1096     }
1097
1098     if (av.getSelectionGroup() != null
1099             || av.getAlignment().getGroups().size() > 0)
1100     {
1101       drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);
1102     }
1103
1104   }
1105
1106   /**
1107    * Draws the outlines of any groups defined on the alignment (excluding the
1108    * current selection group, if any)
1109    * 
1110    * @param g1
1111    * @param startRes
1112    * @param endRes
1113    * @param startSeq
1114    * @param endSeq
1115    * @param offset
1116    */
1117   void drawGroupsBoundaries(Graphics g1, int startRes, int endRes,
1118           int startSeq, int endSeq, int offset)
1119   {
1120     Graphics2D g = (Graphics2D) g1;
1121
1122     SequenceGroup group = null;
1123     int groupIndex = -1;
1124
1125     if (av.getAlignment().getGroups().size() > 0)
1126     {
1127       group = av.getAlignment().getGroups().get(0);
1128       groupIndex = 0;
1129     }
1130
1131     if (group != null)
1132     {
1133       do
1134       {
1135         g.setColor(group.getOutlineColour());
1136         drawPartialGroupOutline(g, group, startRes, endRes, startSeq,
1137                 endSeq, offset);
1138
1139         groupIndex++;
1140         if (groupIndex >= av.getAlignment().getGroups().size())
1141         {
1142           break;
1143         }
1144         group = av.getAlignment().getGroups().get(groupIndex);
1145       } while (groupIndex < av.getAlignment().getGroups().size());
1146     }
1147   }
1148
1149   /**
1150    * Draws the outline of the current selection group (if any)
1151    * 
1152    * @param g
1153    * @param startRes
1154    * @param endRes
1155    * @param startSeq
1156    * @param endSeq
1157    */
1158   private void drawSelectionGroup(Graphics2D g, int startRes, int endRes,
1159           int startSeq, int endSeq)
1160   {
1161     SequenceGroup group = av.getSelectionGroup();
1162     if (group == null)
1163     {
1164       return;
1165     }
1166
1167     g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
1168             BasicStroke.JOIN_ROUND, 3f, new float[]
1169             { 5f, 3f }, 0f));
1170     g.setColor(Color.RED);
1171     if (!av.getWrapAlignment())
1172     {
1173       drawUnwrappedSelection(g, group, startRes, endRes, startSeq, endSeq,
1174               0);
1175     }
1176     else
1177     {
1178       drawWrappedSelection(g, group, getWidth(), getHeight(),
1179               av.getRanges().getStartRes());
1180     }
1181     g.setStroke(new BasicStroke());
1182   }
1183
1184   /**
1185    * Draw the cursor as a separate image and overlay
1186    * 
1187    * @param startRes
1188    *          start residue of area to draw cursor in
1189    * @param endRes
1190    *          end residue of area to draw cursor in
1191    * @param startSeq
1192    *          start sequence of area to draw cursor in
1193    * @param endSeq
1194    *          end sequence of are to draw cursor in
1195    * @return a transparent image of the same size as the sequence canvas, with
1196    *         the cursor drawn on it, if any
1197    */
1198   private void drawCursor(Graphics g, int startRes, int endRes,
1199           int startSeq,
1200           int endSeq)
1201   {
1202     // convert the cursorY into a position on the visible alignment
1203     int cursor_ypos = cursorY;
1204
1205     // don't do work unless we have to
1206     if (cursor_ypos >= startSeq && cursor_ypos <= endSeq)
1207     {
1208       int yoffset = 0;
1209       int xoffset = 0;
1210       int startx = startRes;
1211       int endx = endRes;
1212
1213       // convert the cursorX into a position on the visible alignment
1214       int cursor_xpos = av.getAlignment().getHiddenColumns()
1215               .absoluteToVisibleColumn(cursorX);
1216
1217       if (av.getAlignment().getHiddenColumns().isVisible(cursorX))
1218       {
1219
1220         if (av.getWrapAlignment())
1221         {
1222           // work out the correct offsets for the cursor
1223           int charHeight = av.getCharHeight();
1224           int charWidth = av.getCharWidth();
1225           int canvasWidth = getWidth();
1226           int canvasHeight = getHeight();
1227
1228           // height gap above each panel
1229           int hgap = charHeight;
1230           if (av.getScaleAboveWrapped())
1231           {
1232             hgap += charHeight;
1233           }
1234
1235           int cWidth = (canvasWidth - labelWidthEast - labelWidthWest)
1236                   / charWidth;
1237           int cHeight = av.getAlignment().getHeight() * charHeight;
1238
1239           endx = startx + cWidth - 1;
1240           int ypos = hgap; // vertical offset
1241
1242           // iterate down the wrapped panels
1243           while ((ypos <= canvasHeight) && (endx < cursor_xpos))
1244           {
1245             // update vertical offset
1246             ypos += cHeight + getAnnotationHeight() + hgap;
1247
1248             // update horizontal offset
1249             startx += cWidth;
1250             endx = startx + cWidth - 1;
1251           }
1252           yoffset = ypos;
1253           xoffset = labelWidthWest;
1254         }
1255
1256         // now check if cursor is within range for x values
1257         if (cursor_xpos >= startx && cursor_xpos <= endx)
1258         {
1259           // get the character the cursor is drawn at
1260           SequenceI seq = av.getAlignment().getSequenceAt(cursorY);
1261           char s = seq.getCharAt(cursorX);
1262
1263           seqRdr.drawCursor(g, s,
1264                   xoffset + (cursor_xpos - startx) * av.getCharWidth(),
1265                   yoffset + (cursor_ypos - startSeq) * av.getCharHeight());
1266         }
1267       }
1268     }
1269   }
1270
1271
1272   /**
1273    * Draw a selection group over an unwrapped alignment
1274    * 
1275    * @param g
1276    *          graphics object to draw with
1277    * @param group
1278    *          selection group
1279    * @param startRes
1280    *          start residue of area to draw
1281    * @param endRes
1282    *          end residue of area to draw
1283    * @param startSeq
1284    *          start sequence of area to draw
1285    * @param endSeq
1286    *          end sequence of area to draw
1287    * @param offset
1288    *          vertical offset (used when called from wrapped alignment code)
1289    */
1290   private void drawUnwrappedSelection(Graphics2D g, SequenceGroup group,
1291           int startRes, int endRes, int startSeq, int endSeq, int offset)
1292   {
1293     int charWidth = av.getCharWidth();
1294           
1295     if (!av.hasHiddenColumns())
1296     {
1297       drawPartialGroupOutline(g, group, startRes, endRes, startSeq, endSeq,
1298               offset);
1299     }
1300     else
1301     {
1302       // package into blocks of visible columns
1303       int screenY = 0;
1304       int blockStart;
1305       int blockEnd;
1306
1307       HiddenColumns hidden = av.getAlignment().getHiddenColumns();
1308       VisibleContigsIterator regions = hidden
1309               .getVisContigsIterator(startRes, endRes + 1, true);
1310       while (regions.hasNext())
1311       {
1312         int[] region = regions.next();
1313         blockEnd = region[1];
1314         blockStart = region[0];
1315
1316         g.translate(screenY * charWidth, 0);
1317         drawPartialGroupOutline(g, group,
1318                 blockStart, blockEnd, startSeq, endSeq, offset);
1319
1320         g.translate(-screenY * charWidth, 0);
1321         screenY += blockEnd - blockStart + 1;
1322       }
1323     }
1324   }
1325
1326   /**
1327    * Draws part of a selection group outline
1328    * 
1329    * @param g
1330    * @param group
1331    * @param startRes
1332    * @param endRes
1333    * @param startSeq
1334    * @param endSeq
1335    * @param verticalOffset
1336    */
1337   private void drawPartialGroupOutline(Graphics2D g, SequenceGroup group,
1338           int startRes, int endRes, int startSeq, int endSeq,
1339           int verticalOffset)
1340   {
1341     int charHeight = av.getCharHeight();
1342     int charWidth = av.getCharWidth();
1343     int visWidth = (endRes - startRes + 1) * charWidth;
1344
1345     int oldY = -1;
1346     int i = 0;
1347     boolean inGroup = false;
1348     int top = -1;
1349     int bottom = -1;
1350     int sy = -1;
1351
1352     List<SequenceI> seqs = group.getSequences(null);
1353
1354     // position of start residue of group relative to startRes, in pixels
1355     int sx = (group.getStartRes() - startRes) * charWidth;
1356
1357     // width of group in pixels
1358     int xwidth = (((group.getEndRes() + 1) - group.getStartRes())
1359             * charWidth) - 1;
1360
1361     if (!(sx + xwidth < 0 || sx > visWidth))
1362     {
1363       for (i = startSeq; i <= endSeq; i++)
1364       {
1365         sy = verticalOffset + (i - startSeq) * charHeight;
1366
1367         if ((sx <= (endRes - startRes) * charWidth)
1368                 && seqs.contains(av.getAlignment().getSequenceAt(i)))
1369         {
1370           if ((bottom == -1)
1371                   && !seqs.contains(av.getAlignment().getSequenceAt(i + 1)))
1372           {
1373             bottom = sy + charHeight;
1374           }
1375
1376           if (!inGroup)
1377           {
1378             if (((top == -1) && (i == 0)) || !seqs
1379                     .contains(av.getAlignment().getSequenceAt(i - 1)))
1380             {
1381               top = sy;
1382             }
1383
1384             oldY = sy;
1385             inGroup = true;
1386           }
1387         }
1388         else if (inGroup)
1389         {
1390           drawVerticals(g, sx, xwidth, visWidth, oldY, sy);
1391           drawHorizontals(g, sx, xwidth, visWidth, top, bottom);
1392
1393           // reset top and bottom
1394           top = -1;
1395           bottom = -1;
1396           inGroup = false;
1397         }
1398       }
1399       if (inGroup)
1400       {
1401         sy = verticalOffset + ((i - startSeq) * charHeight);
1402         drawVerticals(g, sx, xwidth, visWidth, oldY, sy);
1403         drawHorizontals(g, sx, xwidth, visWidth, top, bottom);
1404       }
1405     }
1406   }
1407
1408   /**
1409    * Draw horizontal selection group boundaries at top and bottom positions
1410    * 
1411    * @param g
1412    *          graphics object to draw on
1413    * @param sx
1414    *          start x position
1415    * @param xwidth
1416    *          width of gap
1417    * @param visWidth
1418    *          visWidth maximum available width
1419    * @param top
1420    *          position to draw top of group at
1421    * @param bottom
1422    *          position to draw bottom of group at
1423    */
1424   private void drawHorizontals(Graphics2D g, int sx, int xwidth,
1425           int visWidth, int top, int bottom)
1426   {
1427     int width = xwidth;
1428     int startx = sx;
1429     if (startx < 0)
1430     {
1431       width += startx;
1432       startx = 0;
1433     }
1434
1435     // don't let width extend beyond current block, or group extent
1436     // fixes JAL-2672
1437     if (startx + width >= visWidth)
1438     {
1439       width = visWidth - startx;
1440     }
1441
1442     if (top != -1)
1443     {
1444       g.drawLine(startx, top, startx + width, top);
1445     }
1446
1447     if (bottom != -1)
1448     {
1449       g.drawLine(startx, bottom - 1, startx + width, bottom - 1);
1450     }
1451   }
1452
1453   /**
1454    * Draw vertical lines at sx and sx+xwidth providing they lie within
1455    * [0,visWidth)
1456    * 
1457    * @param g
1458    *          graphics object to draw on
1459    * @param sx
1460    *          start x position
1461    * @param xwidth
1462    *          width of gap
1463    * @param visWidth
1464    *          visWidth maximum available width
1465    * @param oldY
1466    *          top y value
1467    * @param sy
1468    *          bottom y value
1469    */
1470   private void drawVerticals(Graphics2D g, int sx, int xwidth, int visWidth,
1471           int oldY, int sy)
1472   {
1473     // if start position is visible, draw vertical line to left of
1474     // group
1475     if (sx >= 0 && sx < visWidth)
1476     {
1477       g.drawLine(sx, oldY, sx, sy);
1478     }
1479
1480     // if end position is visible, draw vertical line to right of
1481     // group
1482     if (sx + xwidth < visWidth)
1483     {
1484       g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
1485     }
1486   }
1487   
1488   /**
1489    * Highlights search results in the visible region by rendering as white text
1490    * on a black background. Any previous highlighting is removed. Answers true
1491    * if any highlight was left on the visible alignment (so status bar should be
1492    * set to match), else false. This method does _not_ set the 'fastPaint' flag,
1493    * so allows the next repaint to update the whole display.
1494    * 
1495    * @param results
1496    * @return
1497    */
1498   public boolean highlightSearchResults(SearchResultsI results)
1499   {
1500     return highlightSearchResults(results, false);
1501
1502   }
1503   
1504   /**
1505    * Highlights search results in the visible region by rendering as white text
1506    * on a black background. Any previous highlighting is removed. Answers true
1507    * if any highlight was left on the visible alignment (so status bar should be
1508    * set to match), else false.
1509    * <p>
1510    * Optionally, set the 'fastPaint' flag for a faster redraw if only the
1511    * highlighted regions are modified. This speeds up highlighting across linked
1512    * alignments.
1513    * <p>
1514    * Currently fastPaint is not implemented for scrolled wrapped alignments. If
1515    * a wrapped alignment had to be scrolled to show the highlighted region, then
1516    * it should be fully redrawn, otherwise a fast paint can be performed. This
1517    * argument could be removed if fast paint of scrolled wrapped alignment is
1518    * coded in future (JAL-2609).
1519    * 
1520    * @param results
1521    * @param doFastPaint
1522    *          if true, sets a flag so the next repaint only redraws the modified
1523    *          image
1524    * @return
1525    */
1526   public boolean highlightSearchResults(SearchResultsI results,
1527           boolean doFastPaint)
1528   {
1529     if (fastpainting)
1530     {
1531       return false;
1532     }
1533     boolean wrapped = av.getWrapAlignment();
1534     try
1535     {
1536       fastPaint = doFastPaint;
1537       fastpainting = fastPaint;
1538
1539       /*
1540        * to avoid redrawing the whole visible region, we instead
1541        * redraw just the minimal regions to remove previous highlights
1542        * and add new ones
1543        */
1544       SearchResultsI previous = av.getSearchResults();
1545       av.setSearchResults(results);
1546       boolean redrawn = false;
1547       boolean drawn = false;
1548       if (wrapped)
1549       {
1550         redrawn = drawMappedPositionsWrapped(previous);
1551         drawn = drawMappedPositionsWrapped(results);
1552         redrawn |= drawn;
1553       }
1554       else
1555       {
1556         redrawn = drawMappedPositions(previous);
1557         drawn = drawMappedPositions(results);
1558         redrawn |= drawn;
1559       }
1560
1561       /*
1562        * if highlights were either removed or added, repaint
1563        */
1564       if (redrawn)
1565       {
1566         repaint();
1567       }
1568
1569       /*
1570        * return true only if highlights were added
1571        */
1572       return drawn;
1573
1574     } finally
1575     {
1576       fastpainting = false;
1577     }
1578   }
1579
1580   /**
1581    * Redraws the minimal rectangle in the visible region (if any) that includes
1582    * mapped positions of the given search results. Whether or not positions are
1583    * highlighted depends on the SearchResults set on the Viewport. This allows
1584    * this method to be called to either clear or set highlighting. Answers true
1585    * if any positions were drawn (in which case a repaint is still required),
1586    * else false.
1587    * 
1588    * @param results
1589    * @return
1590    */
1591   protected boolean drawMappedPositions(SearchResultsI results)
1592   {
1593     if ((results == null) || (img == null)) // JAL-2784 check gg is not null
1594     {
1595       return false;
1596     }
1597
1598     /*
1599      * calculate the minimal rectangle to redraw that 
1600      * includes both new and existing search results
1601      */
1602     int firstSeq = Integer.MAX_VALUE;
1603     int lastSeq = -1;
1604     int firstCol = Integer.MAX_VALUE;
1605     int lastCol = -1;
1606     boolean matchFound = false;
1607
1608     ViewportRanges ranges = av.getRanges();
1609     int firstVisibleColumn = ranges.getStartRes();
1610     int lastVisibleColumn = ranges.getEndRes();
1611     AlignmentI alignment = av.getAlignment();
1612     if (av.hasHiddenColumns())
1613     {
1614       firstVisibleColumn = alignment.getHiddenColumns()
1615               .visibleToAbsoluteColumn(firstVisibleColumn);
1616       lastVisibleColumn = alignment.getHiddenColumns()
1617               .visibleToAbsoluteColumn(lastVisibleColumn);
1618     }
1619
1620     for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
1621             .getEndSeq(); seqNo++)
1622     {
1623       SequenceI seq = alignment.getSequenceAt(seqNo);
1624
1625       int[] visibleResults = results.getResults(seq, firstVisibleColumn,
1626               lastVisibleColumn);
1627       if (visibleResults != null)
1628       {
1629         for (int i = 0; i < visibleResults.length - 1; i += 2)
1630         {
1631           int firstMatchedColumn = visibleResults[i];
1632           int lastMatchedColumn = visibleResults[i + 1];
1633           if (firstMatchedColumn <= lastVisibleColumn
1634                   && lastMatchedColumn >= firstVisibleColumn)
1635           {
1636             /*
1637              * found a search results match in the visible region - 
1638              * remember the first and last sequence matched, and the first
1639              * and last visible columns in the matched positions
1640              */
1641             matchFound = true;
1642             firstSeq = Math.min(firstSeq, seqNo);
1643             lastSeq = Math.max(lastSeq, seqNo);
1644             firstMatchedColumn = Math.max(firstMatchedColumn,
1645                     firstVisibleColumn);
1646             lastMatchedColumn = Math.min(lastMatchedColumn,
1647                     lastVisibleColumn);
1648             firstCol = Math.min(firstCol, firstMatchedColumn);
1649             lastCol = Math.max(lastCol, lastMatchedColumn);
1650           }
1651         }
1652       }
1653     }
1654
1655     if (matchFound)
1656     {
1657       if (av.hasHiddenColumns())
1658       {
1659         firstCol = alignment.getHiddenColumns()
1660                 .absoluteToVisibleColumn(firstCol);
1661         lastCol = alignment.getHiddenColumns().absoluteToVisibleColumn(lastCol);
1662       }
1663       int transX = (firstCol - ranges.getStartRes()) * av.getCharWidth();
1664       int transY = (firstSeq - ranges.getStartSeq()) * av.getCharHeight();
1665       Graphics gg = img.getGraphics();
1666       gg.translate(transX, transY);
1667       drawPanel(gg, firstCol, lastCol, firstSeq, lastSeq, 0);
1668       gg.translate(-transX, -transY);
1669       gg.dispose();
1670     }
1671
1672     return matchFound;
1673   }
1674
1675   @Override
1676   public void propertyChange(PropertyChangeEvent evt)
1677   {
1678     String eventName = evt.getPropertyName();
1679
1680     // BH 2019.07.27 removes dead code introduced in aad3650 and simplifies
1681     // logic, emphasizing no check for ENDRES or ENDSEQ
1682
1683     // Both scrolling and resizing change viewport ranges: scrolling changes
1684     // both start and end points, but resize only changes end values.
1685     // Here we only want to fastpaint on a scroll, with resize using a normal
1686     // paint, so scroll events are identified as changes to the horizontal or
1687     // vertical start value.
1688
1689     // Make sure we're not trying to draw a panel
1690     // larger than the visible window
1691     int scrollX = 0;
1692     switch (eventName)
1693     {
1694     case SequenceGroup.SEQ_GROUP_CHANGED:
1695       fastPaint = true;
1696       repaint();
1697       return;
1698     case ViewportRanges.MOVE_VIEWPORT:
1699       fastPaint = false;
1700       repaint();
1701       return;
1702     case ViewportRanges.STARTSEQ:
1703       // meaning STARTOREND
1704       // typically scroll, but possibly just the end changed
1705       fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
1706       return;
1707     case ViewportRanges.ENDRES:
1708     case ViewportRanges.ENDSEQ:
1709       // meaning second event along with "START" -- ENDONLY,NOTSTART
1710       // TODO: ignore??
1711       return;
1712     case ViewportRanges.STARTRES:
1713       // meaning STARTOREND
1714       scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
1715       break;
1716     case ViewportRanges.STARTRESANDSEQ:
1717       scrollX = ((int[]) evt.getNewValue())[0]
1718               - ((int[]) evt.getOldValue())[0];
1719       break;
1720     }
1721     ViewportRanges vpRanges = av.getRanges();
1722     int range = vpRanges.getEndRes() - vpRanges.getStartRes() + 1;
1723     scrollX = Math.max(Math.min(scrollX, range), -range);
1724     // only STARTRES or STARTRESANDSEQ:
1725     if (av.getWrapAlignment())
1726     {
1727       fastPaintWrapped(scrollX);
1728     }
1729     else
1730     {
1731       fastPaint(scrollX, 0);
1732     }
1733
1734     // BH 2019.07.27 was:
1735     // if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
1736     // {
1737     // fastPaint = true;
1738     // repaint();
1739     // return;
1740     // }
1741     // else if (eventName.equals(ViewportRanges.MOVE_VIEWPORT))
1742     // {
1743     // fastPaint = false;
1744     // // System.err.println("!!!! fastPaint false from MOVE_VIEWPORT");
1745     // repaint();
1746     // return;
1747     // }
1748     //
1749     // if (eventName.equals(ViewportRanges.STARTRES)
1750     // || eventName.equals(ViewportRanges.STARTRESANDSEQ))
1751     // {
1752     // // Make sure we're not trying to draw a panel
1753     // // larger than the visible window
1754     // if (eventName.equals(ViewportRanges.STARTRES))
1755     // {
1756     // scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
1757     // }
1758     // else
1759     // {
1760     // scrollX = ((int[]) evt.getNewValue())[0]
1761     // - ((int[]) evt.getOldValue())[0];
1762     // }
1763     // ViewportRanges vpRanges = av.getRanges();
1764     //
1765     // int range = vpRanges.getEndRes() - vpRanges.getStartRes() + 1;
1766     // if (scrollX > range)
1767     // {
1768     // scrollX = range;
1769     // }
1770     // else if (scrollX < -range)
1771     // {
1772     // scrollX = -range;
1773     // }
1774     // }
1775     // Both scrolling and resizing change viewport ranges: scrolling changes
1776     // both start and end points, but resize only changes end values.
1777     // Here we only want to fastpaint on a scroll, with resize using a normal
1778     // paint, so scroll events are identified as changes to the horizontal or
1779     // vertical start value.
1780     // BH 2019.07.27 was:
1781     // if (eventName.equals(ViewportRanges.STARTRES))
1782     // {
1783     // if (av.getWrapAlignment())
1784     // {
1785     // fastPaintWrapped(scrollX);
1786     // }
1787     // else
1788     // {
1789     // fastPaint(scrollX, 0);
1790     // }
1791     // }
1792     // else if (eventName.equals(ViewportRanges.STARTSEQ))
1793     // {
1794     // // scroll
1795     // fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
1796     // }
1797     // else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
1798     // {
1799     // if (av.getWrapAlignment())
1800     // {
1801     // fastPaintWrapped(scrollX);
1802     // }
1803     // else
1804     // {
1805     // fastPaint(scrollX, 0);
1806     // }
1807     // }
1808     //
1809     // BH oops!
1810     //
1811     // else if (eventName.equals(ViewportRanges.STARTSEQ))
1812     // {
1813     // // scroll
1814     // fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
1815     // }
1816     // else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
1817     // {
1818     // if (av.getWrapAlignment())
1819     // {
1820     // fastPaintWrapped(scrollX);
1821     // }
1822     // }
1823   }
1824
1825   /**
1826    * Does a minimal update of the image for a scroll movement. This method
1827    * handles scroll movements of up to one width of the wrapped alignment (one
1828    * click in the vertical scrollbar). Larger movements (for example after a
1829    * scroll to highlight a mapped position) trigger a full redraw instead.
1830    * 
1831    * @param scrollX
1832    *          number of positions scrolled (right if positive, left if negative)
1833    */
1834   protected void fastPaintWrapped(int scrollX)
1835   {
1836     ViewportRanges ranges = av.getRanges();
1837
1838     if (Math.abs(scrollX) >= ranges.getViewportWidth())
1839     {
1840       /*
1841        * shift of one view width or more is 
1842        * overcomplicated to handle in this method
1843        */
1844       fastPaint = false;
1845       repaint();
1846       return;
1847     }
1848
1849     if (fastpainting || img == null)
1850     {
1851       return;
1852     }
1853
1854     fastPaint = true;
1855     fastpainting = true;
1856
1857     try
1858     {
1859       
1860       Graphics gg = img.getGraphics();
1861       
1862       calculateWrappedGeometry(getWidth(), getHeight());
1863
1864       /*
1865        * relocate the regions of the alignment that are still visible
1866        */
1867       shiftWrappedAlignment(-scrollX);
1868
1869       /*
1870        * add new columns (sequence, annotation)
1871        * - at top left if scrollX < 0 
1872        * - at right of last two widths if scrollX > 0
1873        */
1874       if (scrollX < 0)
1875       {
1876         int startRes = ranges.getStartRes();
1877         drawWrappedWidth(gg, wrappedSpaceAboveAlignment, startRes, startRes
1878                 - scrollX - 1, getHeight());
1879       }
1880       else
1881       {
1882         fastPaintWrappedAddRight(scrollX);
1883       }
1884
1885       /*
1886        * draw all scales (if  shown) and hidden column markers
1887        */
1888       drawWrappedDecorators(gg, ranges.getStartRes());
1889
1890       gg.dispose();
1891       
1892       repaint();
1893     } finally
1894     {
1895       fastpainting = false;
1896     }
1897   }
1898
1899   /**
1900    * Draws the specified number of columns at the 'end' (bottom right) of a
1901    * wrapped alignment view, including sequences and annotations if shown, but
1902    * not scales. Also draws the same number of columns at the right hand end of
1903    * the second last width shown, if the last width is not full height (so
1904    * cannot simply be copied from the graphics image).
1905    * 
1906    * @param columns
1907    */
1908   protected void fastPaintWrappedAddRight(int columns)
1909   {
1910     if (columns == 0)
1911     {
1912       return;
1913     }
1914
1915     Graphics gg = img.getGraphics();
1916     
1917     ViewportRanges ranges = av.getRanges();
1918     int viewportWidth = ranges.getViewportWidth();
1919     int charWidth = av.getCharWidth();
1920
1921     /**
1922      * draw full height alignment in the second last row, last columns, if the
1923      * last row was not full height
1924      */
1925     int visibleWidths = wrappedVisibleWidths;
1926     int canvasHeight = getHeight();
1927     boolean lastWidthPartHeight = (wrappedVisibleWidths * wrappedRepeatHeightPx) > canvasHeight;
1928
1929     if (lastWidthPartHeight)
1930     {
1931       int widthsAbove = Math.max(0, visibleWidths - 2);
1932       int ypos = wrappedRepeatHeightPx * widthsAbove
1933               + wrappedSpaceAboveAlignment;
1934       int endRes = ranges.getEndRes();
1935       endRes += widthsAbove * viewportWidth;
1936       int startRes = endRes - columns;
1937       int xOffset = ((startRes - ranges.getStartRes()) % viewportWidth)
1938               * charWidth;
1939
1940       /*
1941        * white fill first to erase annotations
1942        */
1943       
1944       
1945       gg.translate(xOffset, 0);
1946       gg.setColor(Color.white);
1947       gg.fillRect(labelWidthWest, ypos,
1948               (endRes - startRes + 1) * charWidth, wrappedRepeatHeightPx);
1949       gg.translate(-xOffset, 0);
1950
1951       drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight);
1952       
1953     }
1954
1955     /*
1956      * draw newly visible columns in last wrapped width (none if we
1957      * have reached the end of the alignment)
1958      * y-offset for drawing last width is height of widths above,
1959      * plus one gap row
1960      */
1961     int widthsAbove = visibleWidths - 1;
1962     int ypos = wrappedRepeatHeightPx * widthsAbove
1963             + wrappedSpaceAboveAlignment;
1964     int endRes = ranges.getEndRes();
1965     endRes += widthsAbove * viewportWidth;
1966     int startRes = endRes - columns + 1;
1967
1968     /*
1969      * white fill first to erase annotations
1970      */
1971     int xOffset = ((startRes - ranges.getStartRes()) % viewportWidth)
1972             * charWidth;
1973     gg.translate(xOffset, 0);
1974     gg.setColor(Color.white);
1975     int width = viewportWidth * charWidth - xOffset;
1976     gg.fillRect(labelWidthWest, ypos, width, wrappedRepeatHeightPx);
1977     gg.translate(-xOffset, 0);
1978
1979     gg.setFont(av.getFont());
1980     gg.setColor(Color.black);
1981
1982     if (startRes < ranges.getVisibleAlignmentWidth())
1983     {
1984       drawWrappedWidth(gg, ypos, startRes, endRes, canvasHeight);
1985     }
1986
1987     /*
1988      * and finally, white fill any space below the visible alignment
1989      */
1990     int heightBelow = canvasHeight - visibleWidths * wrappedRepeatHeightPx;
1991     if (heightBelow > 0)
1992     {
1993       gg.setColor(Color.white);
1994       gg.fillRect(0, canvasHeight - heightBelow, getWidth(), heightBelow);
1995     }
1996     gg.dispose();
1997  }
1998
1999   /**
2000    * Shifts the visible alignment by the specified number of columns - left if
2001    * negative, right if positive. Copies and moves sequences and annotations (if
2002    * shown). Scales, hidden column markers and any newly visible columns must be
2003    * drawn separately.
2004    * 
2005    * @param positions
2006    */
2007   protected void shiftWrappedAlignment(int positions)
2008   {
2009     if (positions == 0)
2010     {
2011       return;
2012     }
2013
2014     Graphics gg = img.getGraphics();
2015
2016     int charWidth = av.getCharWidth();
2017
2018     int canvasHeight = getHeight();
2019     ViewportRanges ranges = av.getRanges();
2020     int viewportWidth = ranges.getViewportWidth();
2021     int widthToCopy = (ranges.getViewportWidth() - Math.abs(positions))
2022             * charWidth;
2023     int heightToCopy = wrappedRepeatHeightPx - wrappedSpaceAboveAlignment;
2024     int xMax = ranges.getVisibleAlignmentWidth();
2025
2026     if (positions > 0)
2027     {
2028       /*
2029        * shift right (after scroll left)
2030        * for each wrapped width (starting with the last), copy (width-positions) 
2031        * columns from the left margin to the right margin, and copy positions 
2032        * columns from the right margin of the row above (if any) to the 
2033        * left margin of the current row
2034        */
2035
2036       /*
2037        * get y-offset of last wrapped width, first row of sequences
2038        */
2039       int y = canvasHeight / wrappedRepeatHeightPx * wrappedRepeatHeightPx;
2040       y += wrappedSpaceAboveAlignment;
2041       int copyFromLeftStart = labelWidthWest;
2042       int copyFromRightStart = copyFromLeftStart + widthToCopy;
2043
2044       while (y >= 0)
2045       {
2046         /*
2047          * shift 'widthToCopy' residues by 'positions' places to the right
2048          */
2049         gg.copyArea(copyFromLeftStart, y, widthToCopy, heightToCopy,
2050                 positions * charWidth, 0);
2051         if (y > 0)
2052         {
2053           /*
2054            * copy 'positions' residue from the row above (right hand end)
2055            * to this row's left hand end
2056            */
2057           gg.copyArea(copyFromRightStart, y - wrappedRepeatHeightPx,
2058                   positions * charWidth, heightToCopy, -widthToCopy,
2059                   wrappedRepeatHeightPx);
2060         }
2061
2062         y -= wrappedRepeatHeightPx;
2063       }
2064     }
2065     else
2066     {
2067       /*
2068        * shift left (after scroll right)
2069        * for each wrapped width (starting with the first), copy (width-positions) 
2070        * columns from the right margin to the left margin, and copy positions 
2071        * columns from the left margin of the row below (if any) to the 
2072        * right margin of the current row
2073        */
2074       int xpos = av.getRanges().getStartRes();
2075       int y = wrappedSpaceAboveAlignment;
2076       int copyFromRightStart = labelWidthWest - positions * charWidth;
2077
2078       while (y < canvasHeight)
2079       {
2080         gg.copyArea(copyFromRightStart, y, widthToCopy, heightToCopy,
2081                 positions * charWidth, 0);
2082         if (y + wrappedRepeatHeightPx < canvasHeight - wrappedRepeatHeightPx
2083                 && (xpos + viewportWidth <= xMax))
2084         {
2085           gg.copyArea(labelWidthWest, y + wrappedRepeatHeightPx, -positions
2086                   * charWidth, heightToCopy, widthToCopy,
2087                   -wrappedRepeatHeightPx);
2088         }
2089         y += wrappedRepeatHeightPx;
2090         xpos += viewportWidth;
2091       }
2092     }
2093     gg.dispose();
2094   }
2095
2096   
2097   /**
2098    * Redraws any positions in the search results in the visible region of a
2099    * wrapped alignment. Any highlights are drawn depending on the search results
2100    * set on the Viewport, not the <code>results</code> argument. This allows
2101    * this method to be called either to clear highlights (passing the previous
2102    * search results), or to draw new highlights.
2103    * 
2104    * @param results
2105    * @return
2106    */
2107   protected boolean drawMappedPositionsWrapped(SearchResultsI results)
2108   {
2109     if ((results == null) || (img == null)) // JAL-2784 check gg is not null
2110     {
2111       return false;
2112     }
2113     int charHeight = av.getCharHeight();
2114
2115     boolean matchFound = false;
2116
2117     calculateWrappedGeometry(getWidth(), getHeight());
2118     int wrappedWidth = av.getWrappedWidth();
2119     int wrappedHeight = wrappedRepeatHeightPx;
2120
2121     ViewportRanges ranges = av.getRanges();
2122     int canvasHeight = getHeight();
2123     int repeats = canvasHeight / wrappedHeight;
2124     if (canvasHeight / wrappedHeight > 0)
2125     {
2126       repeats++;
2127     }
2128
2129     int firstVisibleColumn = ranges.getStartRes();
2130     int lastVisibleColumn = ranges.getStartRes() + repeats
2131             * ranges.getViewportWidth() - 1;
2132
2133     AlignmentI alignment = av.getAlignment();
2134     if (av.hasHiddenColumns())
2135     {
2136       firstVisibleColumn = alignment.getHiddenColumns()
2137               .visibleToAbsoluteColumn(firstVisibleColumn);
2138       lastVisibleColumn = alignment.getHiddenColumns()
2139               .visibleToAbsoluteColumn(lastVisibleColumn);
2140     }
2141
2142     int gapHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
2143
2144     
2145     Graphics gg = img.getGraphics();
2146
2147     for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
2148             .getEndSeq(); seqNo++)
2149     {
2150       SequenceI seq = alignment.getSequenceAt(seqNo);
2151
2152       int[] visibleResults = results.getResults(seq, firstVisibleColumn,
2153               lastVisibleColumn);
2154       if (visibleResults != null)
2155       {
2156         for (int i = 0; i < visibleResults.length - 1; i += 2)
2157         {
2158           int firstMatchedColumn = visibleResults[i];
2159           int lastMatchedColumn = visibleResults[i + 1];
2160           if (firstMatchedColumn <= lastVisibleColumn
2161                   && lastMatchedColumn >= firstVisibleColumn)
2162           {
2163             /*
2164              * found a search results match in the visible region
2165              */
2166             firstMatchedColumn = Math.max(firstMatchedColumn,
2167                     firstVisibleColumn);
2168             lastMatchedColumn = Math.min(lastMatchedColumn,
2169                     lastVisibleColumn);
2170
2171             /*
2172              * draw each mapped position separately (as contiguous positions may
2173              * wrap across lines)
2174              */
2175             for (int mappedPos = firstMatchedColumn; mappedPos <= lastMatchedColumn; mappedPos++)
2176             {
2177               int displayColumn = mappedPos;
2178               if (av.hasHiddenColumns())
2179               {
2180                 displayColumn = alignment.getHiddenColumns()
2181                         .absoluteToVisibleColumn(displayColumn);
2182               }
2183
2184               /*
2185                * transX: offset from left edge of canvas to residue position
2186                */
2187               int transX = labelWidthWest
2188                       + ((displayColumn - ranges.getStartRes()) % wrappedWidth)
2189                       * av.getCharWidth();
2190
2191               /*
2192                * transY: offset from top edge of canvas to residue position
2193                */
2194               int transY = gapHeight;
2195               transY += (displayColumn - ranges.getStartRes())
2196                       / wrappedWidth * wrappedHeight;
2197               transY += (seqNo - ranges.getStartSeq()) * av.getCharHeight();
2198
2199               /*
2200                * yOffset is from graphics origin to start of visible region
2201                */
2202               int yOffset = 0;// (displayColumn / wrappedWidth) * wrappedHeight;
2203               if (transY < getHeight())
2204               {
2205                 matchFound = true;
2206                 gg.translate(transX, transY);
2207                 drawPanel(gg, displayColumn, displayColumn, seqNo, seqNo,
2208                         yOffset);
2209                 gg.translate(-transX, -transY);
2210               }
2211             }
2212           }
2213         }
2214       }
2215     }
2216   
2217     gg.dispose();
2218
2219     return matchFound;
2220   }
2221
2222   /**
2223    * Answers the width in pixels of the left scale labels (0 if not shown)
2224    * 
2225    * @return
2226    */
2227   int getLabelWidthWest()
2228   {
2229     return labelWidthWest;
2230   }
2231
2232 }