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.renderer.ScaleRenderer;
  29 import jalview.renderer.ScaleRenderer.ScaleMark;
  30 import jalview.viewmodel.ViewportListenerI;
  31 import jalview.viewmodel.ViewportRanges;
  32
  33 import java.awt.AlphaComposite;
  34 import java.awt.BasicStroke;
  35 import java.awt.BorderLayout;
  36 import java.awt.Color;
  37 import java.awt.FontMetrics;
  38 import java.awt.Graphics;
  39 import java.awt.Graphics2D;
  40 import java.awt.RenderingHints;
  41 import java.awt.Shape;
  42 import java.awt.image.BufferedImage;
  43 import java.beans.PropertyChangeEvent;
  44 import java.util.List;
  45
  46 import javax.swing.JComponent;
  47
  48 /**
  49  * DOCUMENT ME!
  50  *
  51  * @author $author$
  52  * @version $Revision$
  53  */
  54 public class SeqCanvas extends JComponent implements ViewportListenerI
  55 {
  56   private static String ZEROS = "0000000000";
  57
  58   final FeatureRenderer fr;
  59
  60   final SequenceRenderer seqRdr;
  61
  62   BufferedImage img;
  63
  64   Graphics2D gg;
  65
  66   AlignViewport av;
  67
  68   boolean fastPaint = false;
  69
  70   int labelWidthWest;
  71
  72   int labelWidthEast;
  73
  74   int cursorX = 0;
  75
  76   int cursorY = 0;
  77
  78   int charHeight = 0;
  79
  80   int charWidth = 0;
  81
  82   boolean fastpainting = false;
  83
  84   AnnotationPanel annotations;
  85
  86   /**
  87    * Creates a new SeqCanvas object.
  88    *
  89    * @param av
  90    *          DOCUMENT ME!
  91    */
  92   public SeqCanvas(AlignmentPanel ap)
  93   {
  94     this.av = ap.av;
  95     updateViewport();
  96     fr = new FeatureRenderer(ap);
  97     seqRdr = new SequenceRenderer(av);
  98     setLayout(new BorderLayout());
  99     PaintRefresher.Register(this, av.getSequenceSetId());
 100     setBackground(Color.white);
 101
 102     av.getRanges().addPropertyChangeListener(this);
 103   }
 104
 105   public SequenceRenderer getSequenceRenderer()
 106   {
 107     return seqRdr;
 108   }
 109
 110   public FeatureRenderer getFeatureRenderer()
 111   {
 112     return fr;
 113   }
 114
 115   private void updateViewport()
 116   {
 117     charHeight = av.getCharHeight();
 118     charWidth = av.getCharWidth();
 119   }
 120
 121   /**
 122    * DOCUMENT ME!
 123    *
 124    * @param g
 125    *          DOCUMENT ME!
 126    * @param startx
 127    *          DOCUMENT ME!
 128    * @param endx
 129    *          DOCUMENT ME!
 130    * @param ypos
 131    *          DOCUMENT ME!
 132    */
 133   private void drawNorthScale(Graphics g, int startx, int endx, int ypos)
 134   {
 135     updateViewport();
 136     for (ScaleMark mark : new ScaleRenderer().calculateMarks(av, startx,
 137             endx))
 138     {
 139       int mpos = mark.column; // (i - startx - 1)
 140       if (mpos < 0)
 141       {
 142         continue;
 143       }
 144       String mstring = mark.text;
 145
 146       if (mark.major)
 147       {
 148         if (mstring != null)
 149         {
 150           g.drawString(mstring, mpos * charWidth, ypos - (charHeight / 2));
 151         }
 152         g.drawLine((mpos * charWidth) + (charWidth / 2),
 153                 (ypos + 2) - (charHeight / 2),
 154                 (mpos * charWidth) + (charWidth / 2), ypos - 2);
 155       }
 156     }
 157   }
 158
 159   /**
 160    * DOCUMENT ME!
 161    *
 162    * @param g
 163    *          DOCUMENT ME!
 164    * @param startx
 165    *          DOCUMENT ME!
 166    * @param endx
 167    *          DOCUMENT ME!
 168    * @param ypos
 169    *          DOCUMENT ME!
 170    */
 171   void drawWestScale(Graphics g, int startx, int endx, int ypos)
 172   {
 173     FontMetrics fm = getFontMetrics(av.getFont());
 174     ypos += charHeight;
 175
 176     if (av.hasHiddenColumns())
 177     {
 178       startx = av.getAlignment().getHiddenColumns()
 179               .adjustForHiddenColumns(startx);
 180       endx = av.getAlignment().getHiddenColumns()
 181               .adjustForHiddenColumns(endx);
 182     }
 183
 184     int maxwidth = av.getAlignment().getWidth();
 185     if (av.hasHiddenColumns())
 186     {
 187       maxwidth = av.getAlignment().getHiddenColumns()
 188               .findColumnPosition(maxwidth) - 1;
 189     }
 190
 191     // WEST SCALE
 192     for (int i = 0; i < av.getAlignment().getHeight(); i++)
 193     {
 194       SequenceI seq = av.getAlignment().getSequenceAt(i);
 195       int index = startx;
 196       int value = -1;
 197
 198       while (index < endx)
 199       {
 200         if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
 201         {
 202           index++;
 203
 204           continue;
 205         }
 206
 207         value = av.getAlignment().getSequenceAt(i).findPosition(index);
 208
 209         break;
 210       }
 211
 212       if (value != -1)
 213       {
 214         int x = labelWidthWest - fm.stringWidth(String.valueOf(value))
 215                 - charWidth / 2;
 216         g.drawString(value + "", x,
 217                 (ypos + (i * charHeight)) - (charHeight / 5));
 218       }
 219     }
 220   }
 221
 222   /**
 223    * DOCUMENT ME!
 224    *
 225    * @param g
 226    *          DOCUMENT ME!
 227    * @param startx
 228    *          DOCUMENT ME!
 229    * @param endx
 230    *          DOCUMENT ME!
 231    * @param ypos
 232    *          DOCUMENT ME!
 233    */
 234   void drawEastScale(Graphics g, int startx, int endx, int ypos)
 235   {
 236     ypos += charHeight;
 237
 238     if (av.hasHiddenColumns())
 239     {
 240       endx = av.getAlignment().getHiddenColumns()
 241               .adjustForHiddenColumns(endx);
 242     }
 243
 244     SequenceI seq;
 245     // EAST SCALE
 246     for (int i = 0; i < av.getAlignment().getHeight(); i++)
 247     {
 248       seq = av.getAlignment().getSequenceAt(i);
 249       int index = endx;
 250       int value = -1;
 251
 252       while (index > startx)
 253       {
 254         if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
 255         {
 256           index--;
 257
 258           continue;
 259         }
 260
 261         value = seq.findPosition(index);
 262
 263         break;
 264       }
 265
 266       if (value != -1)
 267       {
 268         g.drawString(String.valueOf(value), 0,
 269                 (ypos + (i * charHeight)) - (charHeight / 5));
 270       }
 271     }
 272   }
 273
 274
 275   /**
 276    * need to make this thread safe move alignment rendering in response to
 277    * slider adjustment
 278    *
 279    * @param horizontal
 280    *          shift along
 281    * @param vertical
 282    *          shift up or down in repaint
 283    */
 284   public void fastPaint(int horizontal, int vertical)
 285   {
 286     if (fastpainting || gg == null)
 287     {
 288       return;
 289     }
 290     fastpainting = true;
 291     fastPaint = true;
 292     updateViewport();
 293
 294     ViewportRanges ranges = av.getRanges();
 295     int startRes = ranges.getStartRes();
 296     int endRes = ranges.getEndRes();
 297     int startSeq = ranges.getStartSeq();
 298     int endSeq = ranges.getEndSeq();
 299     int transX = 0;
 300     int transY = 0;
 301
 302     gg.copyArea(horizontal * charWidth, vertical * charHeight,
 303             img.getWidth(), img.getHeight(), -horizontal * charWidth,
 304             -vertical * charHeight);
 305
 306     if (horizontal > 0) // scrollbar pulled right, image to the left
 307     {
 308       transX = (endRes - startRes - horizontal) * charWidth;
 309       startRes = endRes - horizontal;
 310     }
 311     else if (horizontal < 0)
 312     {
 313       endRes = startRes - horizontal;
 314     }
 315     else if (vertical > 0) // scroll down
 316     {
 317       startSeq = endSeq - vertical;
 318
 319       if (startSeq < ranges.getStartSeq())
 320       { // ie scrolling too fast, more than a page at a time
 321         startSeq = ranges.getStartSeq();
 322       }
 323       else
 324       {
 325         transY = img.getHeight() - ((vertical + 1) * charHeight);
 326       }
 327     }
 328     else if (vertical < 0)
 329     {
 330       endSeq = startSeq - vertical;
 331
 332       if (endSeq > ranges.getEndSeq())
 333       {
 334         endSeq = ranges.getEndSeq();
 335       }
 336     }
 337
 338     gg.translate(transX, transY);
 339     drawPanel(gg, startRes, endRes, startSeq, endSeq, 0);
 340     gg.translate(-transX, -transY);
 341
 342     repaint();
 343     fastpainting = false;
 344   }
 345
 346   @Override
 347   public void paintComponent(Graphics g)
 348   {
 349     super.paintComponent(g);
 350
 351     updateViewport();
 352
 353     ViewportRanges ranges = av.getRanges();
 354
 355     int width = getWidth();
 356     int height = getHeight();
 357
 358     width -= (width % charWidth);
 359     height -= (height % charHeight);
 360
 361     // selectImage is the selection group outline image
 362     BufferedImage selectImage = drawSelectionGroup(
 363             ranges.getStartRes(), ranges.getEndRes(),
 364             ranges.getStartSeq(), ranges.getEndSeq());
 365
 366     if ((img != null) && (fastPaint
 367             || (getVisibleRect().width != g.getClipBounds().width)
 368             || (getVisibleRect().height != g.getClipBounds().height)))
 369     {
 370       BufferedImage lcimg = buildLocalImage(selectImage);
 371       g.drawImage(lcimg, 0, 0, this);
 372       fastPaint = false;
 373     }
 374     else if ((width > 0) && (height > 0))
 375     {
 376       // img is a cached version of the last view we drew, if any
 377       // if we have no img or the size has changed, make a new one
 378       if (img == null || width != img.getWidth()
 379               || height != img.getHeight())
 380       {
 381         img = setupImage();
 382         if (img == null)
 383         {
 384           return;
 385         }
 386         gg = (Graphics2D) img.getGraphics();
 387         gg.setFont(av.getFont());
 388       }
 389
 390       if (av.antiAlias)
 391       {
 392         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 393                 RenderingHints.VALUE_ANTIALIAS_ON);
 394       }
 395
 396       gg.setColor(Color.white);
 397       gg.fillRect(0, 0, img.getWidth(), img.getHeight());
 398
 399       if (av.getWrapAlignment())
 400       {
 401         drawWrappedPanel(gg, getWidth(), getHeight(), ranges.getStartRes());
 402       }
 403       else
 404       {
 405         drawPanel(gg, ranges.getStartRes(), ranges.getEndRes(),
 406                 ranges.getStartSeq(), ranges.getEndSeq(), 0);
 407       }
 408
 409       // lcimg is a local *copy* of img which we'll draw selectImage on top of
 410       BufferedImage lcimg = buildLocalImage(selectImage);
 411       g.drawImage(lcimg, 0, 0, this);
 412     }
 413   }
 414
 415   /**
 416    * Draw an alignment panel for printing
 417    *
 418    * @param g1
 419    *          Graphics object to draw with
 420    * @param startRes
 421    *          start residue of print area
 422    * @param endRes
 423    *          end residue of print area
 424    * @param startSeq
 425    *          start sequence of print area
 426    * @param endSeq
 427    *          end sequence of print area
 428    */
 429   public void drawPanelForPrinting(Graphics g1, int startRes, int endRes,
 430           int startSeq, int endSeq)
 431   {
 432     BufferedImage selectImage = drawSelectionGroup(startRes, endRes,
 433             startSeq, endSeq);
 434     drawPanel(g1, startRes, endRes, startSeq, endSeq, 0);
 435     ((Graphics2D) g1).setComposite(
 436             AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
 437     g1.drawImage(selectImage, 0, 0, this);
 438   }
 439
 440   /**
 441    * Draw a wrapped alignment panel for printing
 442    *
 443    * @param g
 444    *          Graphics object to draw with
 445    * @param canvasWidth
 446    *          width of drawing area
 447    * @param canvasHeight
 448    *          height of drawing area
 449    * @param startRes
 450    *          start residue of print area
 451    */
 452   public void drawWrappedPanelForPrinting(Graphics g, int canvasWidth,
 453           int canvasHeight, int startRes)
 454   {
 455     SequenceGroup group = av.getSelectionGroup();
 456     BufferedImage selectImage = new BufferedImage(canvasWidth, canvasHeight,
 457             BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
 458
 459     if (group != null)
 460     {
 461       Graphics2D g2 = selectImage.createGraphics();
 462       setupSelectionGroup(g2, selectImage);
 463       drawWrappedSelection(g2, group, canvasWidth, canvasHeight, startRes);
 464       drawWrappedPanel(g, canvasWidth, canvasHeight, startRes);
 465       g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
 466       g.drawImage(selectImage, 0, 0, this);
 467       g2.dispose();
 468     }
 469   }
 470
 471   /*
 472    * Make a local image by combining the cached image img
 473    * with any selection
 474    */
 475   private BufferedImage buildLocalImage(BufferedImage selectImage)
 476   {
 477     // clone the cached image
 478     BufferedImage lcimg = new BufferedImage(img.getWidth(), img.getHeight(),
 479             img.getType());
 480     Graphics2D g2d = lcimg.createGraphics();
 481     g2d.drawImage(img, 0, 0, null);
 482
 483     // overlay selection group on lcimg
 484     if (selectImage != null)
 485     {
 486       g2d.setComposite(
 487               AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
 488       g2d.drawImage(selectImage, 0, 0, this);
 489     }
 490     g2d.dispose();
 491
 492     return lcimg;
 493   }
 494
 495   /*
 496    * Set up a buffered image of the correct height and size for the sequence canvas
 497    */
 498   private BufferedImage setupImage()
 499   {
 500     BufferedImage lcimg = null;
 501
 502     int width = getWidth();
 503     int height = getHeight();
 504
 505     width -= (width % charWidth);
 506     height -= (height % charHeight);
 507
 508     if ((width < 1) || (height < 1))
 509     {
 510       return null;
 511     }
 512
 513     try
 514     {
 515       lcimg = new BufferedImage(width, height,
 516               BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
 517     } catch (OutOfMemoryError er)
 518     {
 519       System.gc();
 520       System.err.println(
 521               "Group image OutOfMemory Redraw Error.\n" + er);
 522       new OOMWarning("Creating alignment image for display", er);
 523
 524       return null;
 525     }
 526
 527     return lcimg;
 528   }
 529
 530   /**
 531    * Returns the visible width of the canvas in residues, after allowing for
 532    * East or West scales (if shown)
 533    *
 534    * @param canvasWidth
 535    *          the width in pixels (possibly including scales)
 536    *
 537    * @return
 538    */
 539   public int getWrappedCanvasWidth(int canvasWidth)
 540   {
 541     FontMetrics fm = getFontMetrics(av.getFont());
 542
 543     labelWidthEast = 0;
 544     labelWidthWest = 0;
 545
 546     if (av.getScaleRightWrapped())
 547     {
 548       labelWidthEast = getLabelWidth(fm);
 549     }
 550
 551     if (av.getScaleLeftWrapped())
 552     {
 553       labelWidthWest = labelWidthEast > 0 ? labelWidthEast
 554               : getLabelWidth(fm);
 555     }
 556
 557     return (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
 558   }
 559
 560   /**
 561    * Returns a pixel width suitable for showing the largest sequence coordinate
 562    * (end position) in the alignment. Returns 2 plus the number of decimal
 563    * digits to be shown (3 for 1-10, 4 for 11-99 etc).
 564    *
 565    * @param fm
 566    * @return
 567    */
 568   protected int getLabelWidth(FontMetrics fm)
 569   {
 570     /*
 571      * find the biggest sequence end position we need to show
 572      * (note this is not necessarily the sequence length)
 573      */
 574     int maxWidth = 0;
 575     AlignmentI alignment = av.getAlignment();
 576     for (int i = 0; i < alignment.getHeight(); i++)
 577     {
 578       maxWidth = Math.max(maxWidth, alignment.getSequenceAt(i).getEnd());
 579     }
 580
 581     int length = 2;
 582     for (int i = maxWidth; i > 0; i /= 10)
 583     {
 584       length++;
 585     }
 586
 587     return fm.stringWidth(ZEROS.substring(0, length));
 588   }
 589
 590   /**
 591    * DOCUMENT ME!
 592    *
 593    * @param g
 594    *          DOCUMENT ME!
 595    * @param canvasWidth
 596    *          DOCUMENT ME!
 597    * @param canvasHeight
 598    *          DOCUMENT ME!
 599    * @param startRes
 600    *          DOCUMENT ME!
 601    */
 602   private void drawWrappedPanel(Graphics g, int canvasWidth,
 603           int canvasHeight, int startRes)
 604   {
 605     updateViewport();
 606     AlignmentI al = av.getAlignment();
 607
 608     int labelWidth = 0;
 609     if (av.getScaleRightWrapped() || av.getScaleLeftWrapped())
 610     {
 611       FontMetrics fm = getFontMetrics(av.getFont());
 612       labelWidth = getLabelWidth(fm);
 613     }
 614
 615     labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0;
 616     labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0;
 617
 618     int hgap = charHeight;
 619     if (av.getScaleAboveWrapped())
 620     {
 621       hgap += charHeight;
 622     }
 623
 624     int cWidth = (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
 625     int cHeight = av.getAlignment().getHeight() * charHeight;
 626
 627     av.setWrappedWidth(cWidth);
 628
 629     av.getRanges().setViewportStartAndWidth(startRes, cWidth);
 630
 631     int endx;
 632     int ypos = hgap;
 633     int maxwidth = av.getAlignment().getWidth();
 634
 635     if (av.hasHiddenColumns())
 636     {
 637       maxwidth = av.getAlignment().getHiddenColumns()
 638               .findColumnPosition(maxwidth);
 639     }
 640
 641     int annotationHeight = getAnnotationHeight();
 642
 643     while ((ypos <= canvasHeight) && (startRes < maxwidth))
 644     {
 645       endx = startRes + cWidth - 1;
 646
 647       if (endx > maxwidth)
 648       {
 649         endx = maxwidth;
 650       }
 651
 652       g.setFont(av.getFont());
 653       g.setColor(Color.black);
 654
 655       if (av.getScaleLeftWrapped())
 656       {
 657         drawWestScale(g, startRes, endx, ypos);
 658       }
 659
 660       if (av.getScaleRightWrapped())
 661       {
 662         g.translate(canvasWidth - labelWidthEast, 0);
 663         drawEastScale(g, startRes, endx, ypos);
 664         g.translate(-(canvasWidth - labelWidthEast), 0);
 665       }
 666
 667       g.translate(labelWidthWest, 0);
 668
 669       if (av.getScaleAboveWrapped())
 670       {
 671         drawNorthScale(g, startRes, endx, ypos);
 672       }
 673
 674       if (av.hasHiddenColumns() && av.getShowHiddenMarkers())
 675       {
 676         g.setColor(Color.blue);
 677         int res;
 678         HiddenColumns hidden = av.getAlignment().getHiddenColumns();
 679         List<Integer> positions = hidden.findHiddenRegionPositions();
 680         for (int pos : positions)
 681         {
 682           res = pos - startRes;
 683
 684           if (res < 0 || res > endx - startRes)
 685           {
 686             continue;
 687           }
 688
 689           gg.fillPolygon(
 690                   new int[]
 691                   { res * charWidth - charHeight / 4,
 692                       res * charWidth + charHeight / 4, res * charWidth },
 693                   new int[]
 694                   { ypos - (charHeight / 2), ypos - (charHeight / 2),
 695                       ypos - (charHeight / 2) + 8 },
 696                   3);
 697
 698         }
 699       }
 700
 701       // When printing we have an extra clipped region,
 702       // the Printable page which we need to account for here
 703       Shape clip = g.getClip();
 704
 705       if (clip == null)
 706       {
 707         g.setClip(0, 0, cWidth * charWidth, canvasHeight);
 708       }
 709       else
 710       {
 711         g.setClip(0, (int) clip.getBounds().getY(), cWidth * charWidth,
 712                 (int) clip.getBounds().getHeight());
 713       }
 714
 715       drawPanel(g, startRes, endx, 0, al.getHeight() - 1, ypos);
 716
 717       if (av.isShowAnnotation())
 718       {
 719         g.translate(0, cHeight + ypos + 3);
 720         if (annotations == null)
 721         {
 722           annotations = new AnnotationPanel(av);
 723         }
 724
 725         annotations.renderer.drawComponent(annotations, av, g, -1, startRes,
 726                 endx + 1);
 727         g.translate(0, -cHeight - ypos - 3);
 728       }
 729       g.setClip(clip);
 730       g.translate(-labelWidthWest, 0);
 731
 732       ypos += cHeight + annotationHeight + hgap;
 733
 734       startRes += cWidth;
 735     }
 736   }
 737
 738   /*
 739    * Draw a selection group over a wrapped alignment
 740    */
 741   private void drawWrappedSelection(Graphics2D g, SequenceGroup group,
 742           int canvasWidth,
 743           int canvasHeight, int startRes)
 744   {
 745     // height gap above each panel
 746     int hgap = charHeight;
 747     if (av.getScaleAboveWrapped())
 748     {
 749       hgap += charHeight;
 750     }
 751
 752     int cWidth = (canvasWidth - labelWidthEast - labelWidthWest)
 753             / charWidth;
 754     int cHeight = av.getAlignment().getHeight() * charHeight;
 755
 756     int startx = startRes;
 757     int endx;
 758     int ypos = hgap; // vertical offset
 759     int maxwidth = av.getAlignment().getWidth();
 760
 761     if (av.hasHiddenColumns())
 762     {
 763       maxwidth = av.getAlignment().getHiddenColumns()
 764               .findColumnPosition(maxwidth);
 765     }
 766
 767     // chop the wrapped alignment extent up into panel-sized blocks and treat
 768     // each block as if it were a block from an unwrapped alignment
 769     while ((ypos <= canvasHeight) && (startx < maxwidth))
 770     {
 771       // set end value to be start + width, or maxwidth, whichever is smaller
 772       endx = startx + cWidth - 1;
 773
 774       if (endx > maxwidth)
 775       {
 776         endx = maxwidth;
 777       }
 778
 779       g.translate(labelWidthWest, 0);
 780
 781       drawUnwrappedSelection(g, group, startx, endx, 0,
 782               av.getAlignment().getHeight() - 1,
 783               ypos);
 784
 785       g.translate(-labelWidthWest, 0);
 786
 787       // update vertical offset
 788       ypos += cHeight + getAnnotationHeight() + hgap;
 789
 790       // update horizontal offset
 791       startx += cWidth;
 792     }
 793   }
 794
 795   int getAnnotationHeight()
 796   {
 797     if (!av.isShowAnnotation())
 798     {
 799       return 0;
 800     }
 801
 802     if (annotations == null)
 803     {
 804       annotations = new AnnotationPanel(av);
 805     }
 806
 807     return annotations.adjustPanelHeight();
 808   }
 809
 810
 811   /**
 812    * Draws the visible region of the alignment on the graphics context. If there
 813    * are hidden column markers in the visible region, then each sub-region
 814    * between the markers is drawn separately, followed by the hidden column
 815    * marker.
 816    *
 817    * @param g1
 818    *          Graphics object to draw with
 819    * @param startRes
 820    *          offset of the first column in the visible region (0..)
 821    * @param endRes
 822    *          offset of the last column in the visible region (0..)
 823    * @param startSeq
 824    *          offset of the first sequence in the visible region (0..)
 825    * @param endSeq
 826    *          offset of the last sequence in the visible region (0..)
 827    * @param yOffset
 828    *          vertical offset at which to draw (for wrapped alignments)
 829    */
 830   private void drawPanel(Graphics g1, int startRes, int endRes,
 831           int startSeq, int endSeq, int yOffset)
 832
 833   {
 834     updateViewport();
 835     if (!av.hasHiddenColumns())
 836     {
 837       draw(g1, startRes, endRes, startSeq, endSeq, yOffset);
 838     }
 839     else
 840     {
 841       int screenY = 0;
 842       final int screenYMax = endRes - startRes;
 843       int blockStart = startRes;
 844       int blockEnd = endRes;
 845
 846       for (int[] region : av.getAlignment().getHiddenColumns()
 847               .getHiddenColumnsCopy())
 848       {
 849         int hideStart = region[0];
 850         int hideEnd = region[1];
 851
 852         if (hideStart <= blockStart)
 853         {
 854           blockStart += (hideEnd - hideStart) + 1;
 855           continue;
 856         }
 857
 858         /*
 859          * draw up to just before the next hidden region, or the end of
 860          * the visible region, whichever comes first
 861          */
 862         blockEnd = Math.min(hideStart - 1, blockStart + screenYMax
 863                 - screenY);
 864
 865         g1.translate(screenY * charWidth, 0);
 866
 867         draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
 868
 869         /*
 870          * draw the downline of the hidden column marker (ScalePanel draws the
 871          * triangle on top) if we reached it
 872          */
 873         if (av.getShowHiddenMarkers() && blockEnd == hideStart - 1)
 874         {
 875           g1.setColor(Color.blue);
 876
 877           g1.drawLine((blockEnd - blockStart + 1) * charWidth - 1,
 878                   0 + yOffset, (blockEnd - blockStart + 1) * charWidth - 1,
 879                   (endSeq - startSeq + 1) * charHeight + yOffset);
 880         }
 881
 882         g1.translate(-screenY * charWidth, 0);
 883         screenY += blockEnd - blockStart + 1;
 884         blockStart = hideEnd + 1;
 885
 886         if (screenY > screenYMax)
 887         {
 888           // already rendered last block
 889           return;
 890         }
 891       }
 892
 893       if (screenY <= screenYMax)
 894       {
 895         // remaining visible region to render
 896         blockEnd = blockStart + screenYMax - screenY;
 897         g1.translate(screenY * charWidth, 0);
 898         draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
 899
 900         g1.translate(-screenY * charWidth, 0);
 901       }
 902     }
 903
 904   }
 905
 906
 907   /**
 908    * Draws a region of the visible alignment
 909    *
 910    * @param g1
 911    * @param startRes
 912    *          offset of the first column in the visible region (0..)
 913    * @param endRes
 914    *          offset of the last column in the visible region (0..)
 915    * @param startSeq
 916    *          offset of the first sequence in the visible region (0..)
 917    * @param endSeq
 918    *          offset of the last sequence in the visible region (0..)
 919    * @param yOffset
 920    *          vertical offset at which to draw (for wrapped alignments)
 921    */
 922   private void draw(Graphics g, int startRes, int endRes, int startSeq,
 923           int endSeq, int offset)
 924   {
 925     g.setFont(av.getFont());
 926     seqRdr.prepare(g, av.isRenderGaps());
 927
 928     SequenceI nextSeq;
 929
 930     // / First draw the sequences
 931     // ///////////////////////////
 932     for (int i = startSeq; i <= endSeq; i++)
 933     {
 934       nextSeq = av.getAlignment().getSequenceAt(i);
 935       if (nextSeq == null)
 936       {
 937         // occasionally, a race condition occurs such that the alignment row is
 938         // empty
 939         continue;
 940       }
 941       seqRdr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
 942               startRes, endRes, offset + ((i - startSeq) * charHeight));
 943
 944       if (av.isShowSequenceFeatures())
 945       {
 946         fr.drawSequence(g, nextSeq, startRes, endRes,
 947                 offset + ((i - startSeq) * charHeight), false);
 948       }
 949
 950       /*
 951        * highlight search Results once sequence has been drawn
 952        */
 953       if (av.hasSearchResults())
 954       {
 955         SearchResultsI searchResults = av.getSearchResults();
 956         int[] visibleResults = searchResults.getResults(nextSeq,
 957                 startRes, endRes);
 958         if (visibleResults != null)
 959         {
 960           for (int r = 0; r < visibleResults.length; r += 2)
 961           {
 962             seqRdr.drawHighlightedText(nextSeq, visibleResults[r],
 963                     visibleResults[r + 1], (visibleResults[r] - startRes)
 964                             * charWidth, offset
 965                             + ((i - startSeq) * charHeight));
 966           }
 967         }
 968       }
 969
 970       if (av.cursorMode && cursorY == i && cursorX >= startRes
 971               && cursorX <= endRes)
 972       {
 973         seqRdr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth,
 974                 offset + ((i - startSeq) * charHeight));
 975       }
 976     }
 977
 978     if (av.getSelectionGroup() != null
 979             || av.getAlignment().getGroups().size() > 0)
 980     {
 981       drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);
 982     }
 983
 984   }
 985
 986   void drawGroupsBoundaries(Graphics g1, int startRes, int endRes,
 987           int startSeq, int endSeq, int offset)
 988   {
 989     Graphics2D g = (Graphics2D) g1;
 990     //
 991     // ///////////////////////////////////
 992     // Now outline any areas if necessary
 993     // ///////////////////////////////////
 994
 995     SequenceGroup group = null;
 996     int groupIndex = -1;
 997
 998     if (av.getAlignment().getGroups().size() > 0)
 999     {
1000       group = av.getAlignment().getGroups().get(0);
1001       groupIndex = 0;
1002     }
1003
1004     if (group != null)
1005     {
1006       g.setStroke(new BasicStroke());
1007       g.setColor(group.getOutlineColour());
1008
1009       do
1010       {
1011         drawPartialGroupOutline(g, group, startRes, endRes, startSeq,
1012                 endSeq, offset);
1013
1014         groupIndex++;
1015
1016         g.setStroke(new BasicStroke());
1017
1018         if (groupIndex >= av.getAlignment().getGroups().size())
1019         {
1020           break;
1021         }
1022
1023         group = av.getAlignment().getGroups().get(groupIndex);
1024
1025       } while (groupIndex < av.getAlignment().getGroups().size());
1026
1027     }
1028
1029   }
1030
1031
1032   /*
1033    * Draw the selection group as a separate image and overlay
1034    */
1035   private BufferedImage drawSelectionGroup(int startRes, int endRes,
1036           int startSeq, int endSeq)
1037   {
1038     // get a new image of the correct size
1039     BufferedImage selectionImage = setupImage();
1040
1041     if (selectionImage == null)
1042     {
1043       return null;
1044     }
1045
1046     SequenceGroup group = av.getSelectionGroup();
1047     if (group == null)
1048     {
1049       // nothing to draw
1050       return null;
1051     }
1052
1053     // set up drawing colour
1054     Graphics2D g = (Graphics2D) selectionImage.getGraphics();
1055
1056     setupSelectionGroup(g, selectionImage);
1057
1058     if (!av.getWrapAlignment())
1059     {
1060       drawUnwrappedSelection(g, group, startRes, endRes, startSeq, endSeq,
1061               0);
1062     }
1063     else
1064     {
1065       drawWrappedSelection(g, group, getWidth(), getHeight(),
1066               av.getRanges().getStartRes());
1067     }
1068
1069     g.dispose();
1070     return selectionImage;
1071   }
1072
1073   /*
1074    * Set up graphics for selection group
1075    */
1076   private void setupSelectionGroup(Graphics2D g,
1077           BufferedImage selectionImage)
1078   {
1079     // set background to transparent
1080     g.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
1081     g.fillRect(0, 0, selectionImage.getWidth(), selectionImage.getHeight());
1082
1083     // set up foreground to draw red dashed line
1084     g.setComposite(AlphaComposite.Src);
1085     g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
1086             BasicStroke.JOIN_ROUND, 3f, new float[]
1087     { 5f, 3f }, 0f));
1088     g.setColor(Color.RED);
1089   }
1090
1091   /*
1092    * Draw a selection group over an unwrapped alignment
1093    * @param g graphics object to draw with
1094    * @param group selection group
1095    * @param startRes start residue of area to draw
1096    * @param endRes end residue of area to draw
1097    * @param startSeq start sequence of area to draw
1098    * @param endSeq end sequence of area to draw
1099    * @param offset vertical offset (used when called from wrapped alignment code)
1100    */
1101   private void drawUnwrappedSelection(Graphics2D g, SequenceGroup group,
1102           int startRes, int endRes, int startSeq, int endSeq, int offset)
1103   {
1104     if (!av.hasHiddenColumns())
1105     {
1106       drawPartialGroupOutline(g, group, startRes, endRes, startSeq, endSeq,
1107               offset);
1108     }
1109     else
1110     {
1111       // package into blocks of visible columns
1112       int screenY = 0;
1113       int blockStart = startRes;
1114       int blockEnd = endRes;
1115
1116       for (int[] region : av.getAlignment().getHiddenColumns()
1117               .getHiddenColumnsCopy())
1118       {
1119         int hideStart = region[0];
1120         int hideEnd = region[1];
1121
1122         if (hideStart <= blockStart)
1123         {
1124           blockStart += (hideEnd - hideStart) + 1;
1125           continue;
1126         }
1127
1128         blockEnd = hideStart - 1;
1129
1130         g.translate(screenY * charWidth, 0);
1131         drawPartialGroupOutline(g, group,
1132                 blockStart, blockEnd, startSeq, endSeq, offset);
1133
1134         g.translate(-screenY * charWidth, 0);
1135         screenY += blockEnd - blockStart + 1;
1136         blockStart = hideEnd + 1;
1137
1138         if (screenY > (endRes - startRes))
1139         {
1140           // already rendered last block
1141           break;
1142         }
1143       }
1144
1145       if (screenY <= (endRes - startRes))
1146       {
1147         // remaining visible region to render
1148         blockEnd = blockStart + (endRes - startRes) - screenY;
1149         g.translate(screenY * charWidth, 0);
1150         drawPartialGroupOutline(g, group,
1151                 blockStart, blockEnd, startSeq, endSeq, offset);
1152
1153         g.translate(-screenY * charWidth, 0);
1154       }
1155     }
1156   }
1157
1158   /*
1159    * Draw the selection group as a separate image and overlay
1160    */
1161   private void drawPartialGroupOutline(Graphics2D g, SequenceGroup group,
1162           int startRes, int endRes, int startSeq, int endSeq,
1163           int verticalOffset)
1164   {
1165     int visWidth = (endRes - startRes + 1) * charWidth;
1166
1167     int oldY = -1;
1168     int i = 0;
1169     boolean inGroup = false;
1170     int top = -1;
1171     int bottom = -1;
1172
1173     int sx = -1;
1174     int sy = -1;
1175     int xwidth = -1;
1176
1177     for (i = startSeq; i <= endSeq; i++)
1178     {
1179       // position of start residue of group relative to startRes, in pixels
1180       sx = (group.getStartRes() - startRes) * charWidth;
1181
1182       // width of group in pixels
1183       xwidth = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth)
1184               - 1;
1185
1186       sy = verticalOffset + (i - startSeq) * charHeight;
1187
1188       if (sx + xwidth < 0 || sx > visWidth)
1189       {
1190         continue;
1191       }
1192
1193       if ((sx <= (endRes - startRes) * charWidth)
1194               && group.getSequences(null)
1195                       .contains(av.getAlignment().getSequenceAt(i)))
1196       {
1197         if ((bottom == -1) && !group.getSequences(null)
1198                 .contains(av.getAlignment().getSequenceAt(i + 1)))
1199         {
1200           bottom = sy + charHeight;
1201         }
1202
1203         if (!inGroup)
1204         {
1205           if (((top == -1) && (i == 0)) || !group.getSequences(null)
1206                   .contains(av.getAlignment().getSequenceAt(i - 1)))
1207           {
1208             top = sy;
1209           }
1210
1211           oldY = sy;
1212           inGroup = true;
1213         }
1214       }
1215       else
1216       {
1217         if (inGroup)
1218         {
1219           // if start position is visible, draw vertical line to left of
1220           // group
1221           if (sx >= 0 && sx < visWidth)
1222           {
1223             g.drawLine(sx, oldY, sx, sy);
1224           }
1225
1226           // if end position is visible, draw vertical line to right of
1227           // group
1228           if (sx + xwidth < visWidth)
1229           {
1230             g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
1231           }
1232
1233           if (sx < 0)
1234           {
1235             xwidth += sx;
1236             sx = 0;
1237           }
1238
1239           // don't let width extend beyond current block, or group extent
1240           // fixes JAL-2672
1241           if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
1242           {
1243             xwidth = (endRes - startRes + 1) * charWidth - sx;
1244           }
1245
1246           // draw horizontal line at top of group
1247           if (top != -1)
1248           {
1249             g.drawLine(sx, top, sx + xwidth, top);
1250             top = -1;
1251           }
1252
1253           // draw horizontal line at bottom of group
1254           if (bottom != -1)
1255           {
1256             g.drawLine(sx, bottom, sx + xwidth, bottom);
1257             bottom = -1;
1258           }
1259
1260           inGroup = false;
1261         }
1262       }
1263     }
1264
1265     if (inGroup)
1266     {
1267       sy = verticalOffset + ((i - startSeq) * charHeight);
1268       if (sx >= 0 && sx < visWidth)
1269       {
1270         g.drawLine(sx, oldY, sx, sy);
1271       }
1272
1273       if (sx + xwidth < visWidth)
1274       {
1275         g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
1276       }
1277
1278       if (sx < 0)
1279       {
1280         xwidth += sx;
1281         sx = 0;
1282       }
1283
1284       if (sx + xwidth > visWidth)
1285       {
1286         xwidth = visWidth;
1287       }
1288       else if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
1289       {
1290         xwidth = (endRes - startRes + 1) * charWidth;
1291       }
1292
1293       if (top != -1)
1294       {
1295         g.drawLine(sx, top, sx + xwidth, top);
1296         top = -1;
1297       }
1298
1299       if (bottom != -1)
1300       {
1301         g.drawLine(sx, bottom - 1, sx + xwidth, bottom - 1);
1302         bottom = -1;
1303       }
1304
1305       inGroup = false;
1306     }
1307   }
1308
1309   /**
1310    * Highlights search results in the visible region by rendering as white text
1311    * on a black background. Any previous highlighting is removed. Answers true
1312    * if any highlight was left on the visible alignment (so status bar should be
1313    * set to match), else false.
1314    * <p>
1315    * Currently fastPaint is not implemented for wrapped alignments. If a wrapped
1316    * alignment had to be scrolled to show the highlighted region, then it should
1317    * be fully redrawn, otherwise a fast paint can be performed. This argument
1318    * could be removed if fast paint of scrolled wrapped alignment is coded in
1319    * future (JAL-2609).
1320    *
1321    * @param results
1322    * @param noFastPaint
1323    * @return
1324    */
1325   public boolean highlightSearchResults(SearchResultsI results,
1326           boolean noFastPaint)
1327   {
1328     if (fastpainting)
1329     {
1330       return false;
1331     }
1332     boolean wrapped = av.getWrapAlignment();
1333
1334     try
1335     {
1336       fastPaint = !noFastPaint;
1337       fastpainting = fastPaint;
1338
1339       updateViewport();
1340
1341       /*
1342        * to avoid redrawing the whole visible region, we instead
1343        * redraw just the minimal regions to remove previous highlights
1344        * and add new ones
1345        */
1346       SearchResultsI previous = av.getSearchResults();
1347       av.setSearchResults(results);
1348       boolean redrawn = false;
1349       boolean drawn = false;
1350       if (wrapped)
1351       {
1352         redrawn = drawMappedPositionsWrapped(previous);
1353         drawn = drawMappedPositionsWrapped(results);
1354         redrawn |= drawn;
1355       }
1356       else
1357       {
1358         redrawn = drawMappedPositions(previous);
1359         drawn = drawMappedPositions(results);
1360         redrawn |= drawn;
1361       }
1362
1363       /*
1364        * if highlights were either removed or added, repaint
1365        */
1366       if (redrawn)
1367       {
1368         repaint();
1369       }
1370
1371       /*
1372        * return true only if highlights were added
1373        */
1374       return drawn;
1375
1376     } finally
1377     {
1378       fastpainting = false;
1379     }
1380   }
1381
1382   /**
1383    * Redraws the minimal rectangle in the visible region (if any) that includes
1384    * mapped positions of the given search results. Whether or not positions are
1385    * highlighted depends on the SearchResults set on the Viewport. This allows
1386    * this method to be called to either clear or set highlighting. Answers true
1387    * if any positions were drawn (in which case a repaint is still required),
1388    * else false.
1389    *
1390    * @param results
1391    * @return
1392    */
1393   protected boolean drawMappedPositions(SearchResultsI results)
1394   {
1395     if (results == null)
1396     {
1397       return false;
1398     }
1399
1400     /*
1401      * calculate the minimal rectangle to redraw that
1402      * includes both new and existing search results
1403      */
1404     int firstSeq = Integer.MAX_VALUE;
1405     int lastSeq = -1;
1406     int firstCol = Integer.MAX_VALUE;
1407     int lastCol = -1;
1408     boolean matchFound = false;
1409
1410     ViewportRanges ranges = av.getRanges();
1411     int firstVisibleColumn = ranges.getStartRes();
1412     int lastVisibleColumn = ranges.getEndRes();
1413     AlignmentI alignment = av.getAlignment();
1414     if (av.hasHiddenColumns())
1415     {
1416       firstVisibleColumn = alignment.getHiddenColumns()
1417               .adjustForHiddenColumns(firstVisibleColumn);
1418       lastVisibleColumn = alignment.getHiddenColumns()
1419               .adjustForHiddenColumns(lastVisibleColumn);
1420     }
1421
1422     for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
1423             .getEndSeq(); seqNo++)
1424     {
1425       SequenceI seq = alignment.getSequenceAt(seqNo);
1426
1427       int[] visibleResults = results.getResults(seq, firstVisibleColumn,
1428               lastVisibleColumn);
1429       if (visibleResults != null)
1430       {
1431         for (int i = 0; i < visibleResults.length - 1; i += 2)
1432         {
1433           int firstMatchedColumn = visibleResults[i];
1434           int lastMatchedColumn = visibleResults[i + 1];
1435           if (firstMatchedColumn <= lastVisibleColumn
1436                   && lastMatchedColumn >= firstVisibleColumn)
1437           {
1438             /*
1439              * found a search results match in the visible region -
1440              * remember the first and last sequence matched, and the first
1441              * and last visible columns in the matched positions
1442              */
1443             matchFound = true;
1444             firstSeq = Math.min(firstSeq, seqNo);
1445             lastSeq = Math.max(lastSeq, seqNo);
1446             firstMatchedColumn = Math.max(firstMatchedColumn,
1447                     firstVisibleColumn);
1448             lastMatchedColumn = Math.min(lastMatchedColumn,
1449                     lastVisibleColumn);
1450             firstCol = Math.min(firstCol, firstMatchedColumn);
1451             lastCol = Math.max(lastCol, lastMatchedColumn);
1452           }
1453         }
1454       }
1455     }
1456
1457     if (matchFound)
1458     {
1459       if (av.hasHiddenColumns())
1460       {
1461         firstCol = alignment.getHiddenColumns()
1462                 .findColumnPosition(firstCol);
1463         lastCol = alignment.getHiddenColumns().findColumnPosition(lastCol);
1464       }
1465       int transX = (firstCol - ranges.getStartRes()) * av.getCharWidth();
1466       int transY = (firstSeq - ranges.getStartSeq()) * av.getCharHeight();
1467       gg.translate(transX, transY);
1468       drawPanel(gg, firstCol, lastCol, firstSeq, lastSeq, 0);
1469       gg.translate(-transX, -transY);
1470     }
1471
1472     return matchFound;
1473   }
1474
1475   @Override
1476   public void propertyChange(PropertyChangeEvent evt)
1477   {
1478     String eventName = evt.getPropertyName();
1479
1480     if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
1481     {
1482       fastPaint = true;
1483       repaint();
1484     }
1485     else if (av.getWrapAlignment())
1486     {
1487       if (eventName.equals(ViewportRanges.STARTRES))
1488       {
1489         repaint();
1490       }
1491     }
1492     else
1493     {
1494       int scrollX = 0;
1495       if (eventName.equals(ViewportRanges.STARTRES))
1496       {
1497         // Make sure we're not trying to draw a panel
1498         // larger than the visible window
1499         ViewportRanges vpRanges = av.getRanges();
1500         scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
1501         int range = vpRanges.getEndRes() - vpRanges.getStartRes();
1502         if (scrollX > range)
1503         {
1504           scrollX = range;
1505         }
1506         else if (scrollX < -range)
1507         {
1508           scrollX = -range;
1509         }
1510       }
1511
1512       // Both scrolling and resizing change viewport ranges: scrolling changes
1513       // both start and end points, but resize only changes end values.
1514       // Here we only want to fastpaint on a scroll, with resize using a normal
1515       // paint, so scroll events are identified as changes to the horizontal or
1516       // vertical start value.
1517       if (eventName.equals(ViewportRanges.STARTRES))
1518       {
1519         // scroll - startres and endres both change
1520         fastPaint(scrollX, 0);
1521       }
1522       else if (eventName.equals(ViewportRanges.STARTSEQ))
1523       {
1524         // scroll
1525         fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
1526       }
1527     }
1528   }
1529
1530   /**
1531    * Redraws any positions in the search results in the visible region of a
1532    * wrapped alignment. Any highlights are drawn depending on the search results
1533    * set on the Viewport, not the <code>results</code> argument. This allows
1534    * this method to be called either to clear highlights (passing the previous
1535    * search results), or to draw new highlights.
1536    *
1537    * @param results
1538    * @return
1539    */
1540   protected boolean drawMappedPositionsWrapped(SearchResultsI results)
1541   {
1542     if (results == null)
1543     {
1544       return false;
1545     }
1546
1547     boolean matchFound = false;
1548
1549     int wrappedWidth = av.getWrappedWidth();
1550     int wrappedHeight = getRepeatHeightWrapped();
1551
1552     ViewportRanges ranges = av.getRanges();
1553     int canvasHeight = getHeight();
1554     int repeats = canvasHeight / wrappedHeight;
1555     if (canvasHeight / wrappedHeight > 0)
1556     {
1557       repeats++;
1558     }
1559
1560     int firstVisibleColumn = ranges.getStartRes();
1561     int lastVisibleColumn = ranges.getStartRes() + repeats
1562             * ranges.getViewportWidth() - 1;
1563
1564     AlignmentI alignment = av.getAlignment();
1565     if (av.hasHiddenColumns())
1566     {
1567       firstVisibleColumn = alignment.getHiddenColumns()
1568               .adjustForHiddenColumns(firstVisibleColumn);
1569       lastVisibleColumn = alignment.getHiddenColumns()
1570               .adjustForHiddenColumns(lastVisibleColumn);
1571     }
1572
1573     int gapHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
1574
1575     for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
1576             .getEndSeq(); seqNo++)
1577     {
1578       SequenceI seq = alignment.getSequenceAt(seqNo);
1579
1580       int[] visibleResults = results.getResults(seq, firstVisibleColumn,
1581               lastVisibleColumn);
1582       if (visibleResults != null)
1583       {
1584         for (int i = 0; i < visibleResults.length - 1; i += 2)
1585         {
1586           int firstMatchedColumn = visibleResults[i];
1587           int lastMatchedColumn = visibleResults[i + 1];
1588           if (firstMatchedColumn <= lastVisibleColumn
1589                   && lastMatchedColumn >= firstVisibleColumn)
1590           {
1591             /*
1592              * found a search results match in the visible region
1593              */
1594             firstMatchedColumn = Math.max(firstMatchedColumn,
1595                     firstVisibleColumn);
1596             lastMatchedColumn = Math.min(lastMatchedColumn,
1597                     lastVisibleColumn);
1598
1599             /*
1600              * draw each mapped position separately (as contiguous positions may
1601              * wrap across lines)
1602              */
1603             for (int mappedPos = firstMatchedColumn; mappedPos <= lastMatchedColumn; mappedPos++)
1604             {
1605               int displayColumn = mappedPos;
1606               if (av.hasHiddenColumns())
1607               {
1608                 displayColumn = alignment.getHiddenColumns()
1609                         .findColumnPosition(displayColumn);
1610               }
1611
1612               /*
1613                * transX: offset from left edge of canvas to residue position
1614                */
1615               int transX = labelWidthWest
1616                       + ((displayColumn - ranges.getStartRes()) % wrappedWidth)
1617                       * av.getCharWidth();
1618
1619               /*
1620                * transY: offset from top edge of canvas to residue position
1621                */
1622               int transY = gapHeight;
1623               transY += (displayColumn - ranges.getStartRes())
1624                       / wrappedWidth * wrappedHeight;
1625               transY += (seqNo - ranges.getStartSeq()) * av.getCharHeight();
1626
1627               /*
1628                * yOffset is from graphics origin to start of visible region
1629                */
1630               int yOffset = 0;// (displayColumn / wrappedWidth) * wrappedHeight;
1631               if (transY < getHeight())
1632               {
1633                 matchFound = true;
1634                 gg.translate(transX, transY);
1635                 drawPanel(gg, displayColumn, displayColumn, seqNo, seqNo,
1636                         yOffset);
1637                 gg.translate(-transX, -transY);
1638               }
1639             }
1640           }
1641         }
1642       }
1643     }
1644
1645     return matchFound;
1646   }
1647
1648   /**
1649    * Answers the height in pixels of a repeating section of the wrapped
1650    * alignment, including space above, scale above if shown, sequences, and
1651    * annotation panel if shown
1652    *
1653    * @return
1654    */
1655   protected int getRepeatHeightWrapped()
1656   {
1657     // gap (and maybe scale) above
1658     int repeatHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
1659
1660     // add sequences
1661     repeatHeight += av.getRanges().getViewportHeight() * charHeight;
1662
1663     // add annotations panel height if shown
1664     repeatHeight += getAnnotationHeight();
1665
1666     return repeatHeight;
1667   }
1668 }