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 || img == 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     drawPanel(g1, startRes, endRes, startSeq, endSeq, 0);
 433
 434     BufferedImage selectImage = drawSelectionGroup(startRes, endRes,
 435             startSeq, endSeq);
 436     if (selectImage != null)
 437     {
 438       ((Graphics2D) g1).setComposite(AlphaComposite
 439               .getInstance(AlphaComposite.SRC_OVER));
 440       g1.drawImage(selectImage, 0, 0, this);
 441     }
 442   }
 443
 444   /**
 445    * Draw a wrapped alignment panel for printing
 446    *
 447    * @param g
 448    *          Graphics object to draw with
 449    * @param canvasWidth
 450    *          width of drawing area
 451    * @param canvasHeight
 452    *          height of drawing area
 453    * @param startRes
 454    *          start residue of print area
 455    */
 456   public void drawWrappedPanelForPrinting(Graphics g, int canvasWidth,
 457           int canvasHeight, int startRes)
 458   {
 459     SequenceGroup group = av.getSelectionGroup();
 460
 461     drawWrappedPanel(g, canvasWidth, canvasHeight, startRes);
 462
 463     if (group != null)
 464     {
 465       BufferedImage selectImage = null;
 466       try
 467       {
 468         selectImage = new BufferedImage(canvasWidth, canvasHeight,
 469                 BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
 470       } catch (OutOfMemoryError er)
 471       {
 472         System.gc();
 473         System.err.println("Print image OutOfMemory Error.\n" + er);
 474         new OOMWarning("Creating wrapped alignment image for printing", er);
 475       }
 476       if (selectImage != null)
 477       {
 478         Graphics2D g2 = selectImage.createGraphics();
 479         setupSelectionGroup(g2, selectImage);
 480         drawWrappedSelection(g2, group, canvasWidth, canvasHeight,
 481                 startRes);
 482
 483         g2.setComposite(
 484                 AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
 485         g.drawImage(selectImage, 0, 0, this);
 486         g2.dispose();
 487       }
 488     }
 489   }
 490
 491   /*
 492    * Make a local image by combining the cached image img
 493    * with any selection
 494    */
 495   private BufferedImage buildLocalImage(BufferedImage selectImage)
 496   {
 497     // clone the cached image
 498     BufferedImage lcimg = new BufferedImage(img.getWidth(), img.getHeight(),
 499             img.getType());
 500     Graphics2D g2d = lcimg.createGraphics();
 501     g2d.drawImage(img, 0, 0, null);
 502
 503     // overlay selection group on lcimg
 504     if (selectImage != null)
 505     {
 506       g2d.setComposite(
 507               AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
 508       g2d.drawImage(selectImage, 0, 0, this);
 509     }
 510     g2d.dispose();
 511
 512     return lcimg;
 513   }
 514
 515   /*
 516    * Set up a buffered image of the correct height and size for the sequence canvas
 517    */
 518   private BufferedImage setupImage()
 519   {
 520     BufferedImage lcimg = null;
 521
 522     int width = getWidth();
 523     int height = getHeight();
 524
 525     width -= (width % charWidth);
 526     height -= (height % charHeight);
 527
 528     if ((width < 1) || (height < 1))
 529     {
 530       return null;
 531     }
 532
 533     try
 534     {
 535       lcimg = new BufferedImage(width, height,
 536               BufferedImage.TYPE_INT_ARGB); // ARGB so alpha compositing works
 537     } catch (OutOfMemoryError er)
 538     {
 539       System.gc();
 540       System.err.println(
 541               "Group image OutOfMemory Redraw Error.\n" + er);
 542       new OOMWarning("Creating alignment image for display", er);
 543
 544       return null;
 545     }
 546
 547     return lcimg;
 548   }
 549
 550   /**
 551    * Returns the visible width of the canvas in residues, after allowing for
 552    * East or West scales (if shown)
 553    *
 554    * @param canvasWidth
 555    *          the width in pixels (possibly including scales)
 556    *
 557    * @return
 558    */
 559   public int getWrappedCanvasWidth(int canvasWidth)
 560   {
 561     FontMetrics fm = getFontMetrics(av.getFont());
 562
 563     labelWidthEast = 0;
 564     labelWidthWest = 0;
 565
 566     if (av.getScaleRightWrapped())
 567     {
 568       labelWidthEast = getLabelWidth(fm);
 569     }
 570
 571     if (av.getScaleLeftWrapped())
 572     {
 573       labelWidthWest = labelWidthEast > 0 ? labelWidthEast
 574               : getLabelWidth(fm);
 575     }
 576
 577     return (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
 578   }
 579
 580   /**
 581    * Returns a pixel width suitable for showing the largest sequence coordinate
 582    * (end position) in the alignment. Returns 2 plus the number of decimal
 583    * digits to be shown (3 for 1-10, 4 for 11-99 etc).
 584    *
 585    * @param fm
 586    * @return
 587    */
 588   protected int getLabelWidth(FontMetrics fm)
 589   {
 590     /*
 591      * find the biggest sequence end position we need to show
 592      * (note this is not necessarily the sequence length)
 593      */
 594     int maxWidth = 0;
 595     AlignmentI alignment = av.getAlignment();
 596     for (int i = 0; i < alignment.getHeight(); i++)
 597     {
 598       maxWidth = Math.max(maxWidth, alignment.getSequenceAt(i).getEnd());
 599     }
 600
 601     int length = 2;
 602     for (int i = maxWidth; i > 0; i /= 10)
 603     {
 604       length++;
 605     }
 606
 607     return fm.stringWidth(ZEROS.substring(0, length));
 608   }
 609
 610   /**
 611    * DOCUMENT ME!
 612    *
 613    * @param g
 614    *          DOCUMENT ME!
 615    * @param canvasWidth
 616    *          DOCUMENT ME!
 617    * @param canvasHeight
 618    *          DOCUMENT ME!
 619    * @param startRes
 620    *          DOCUMENT ME!
 621    */
 622   private void drawWrappedPanel(Graphics g, int canvasWidth,
 623           int canvasHeight, int startRes)
 624   {
 625     updateViewport();
 626     AlignmentI al = av.getAlignment();
 627
 628     int labelWidth = 0;
 629     if (av.getScaleRightWrapped() || av.getScaleLeftWrapped())
 630     {
 631       FontMetrics fm = getFontMetrics(av.getFont());
 632       labelWidth = getLabelWidth(fm);
 633     }
 634
 635     labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0;
 636     labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0;
 637
 638     int hgap = charHeight;
 639     if (av.getScaleAboveWrapped())
 640     {
 641       hgap += charHeight;
 642     }
 643
 644     int cWidth = (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
 645     int cHeight = av.getAlignment().getHeight() * charHeight;
 646
 647     av.setWrappedWidth(cWidth);
 648
 649     av.getRanges().setViewportStartAndWidth(startRes, cWidth);
 650
 651     int endx;
 652     int ypos = hgap;
 653     int maxwidth = av.getAlignment().getWidth();
 654
 655     if (av.hasHiddenColumns())
 656     {
 657       maxwidth = av.getAlignment().getHiddenColumns()
 658               .findColumnPosition(maxwidth);
 659     }
 660
 661     int annotationHeight = getAnnotationHeight();
 662
 663     while ((ypos <= canvasHeight) && (startRes < maxwidth))
 664     {
 665       endx = startRes + cWidth - 1;
 666
 667       if (endx > maxwidth)
 668       {
 669         endx = maxwidth;
 670       }
 671
 672       g.setFont(av.getFont());
 673       g.setColor(Color.black);
 674
 675       if (av.getScaleLeftWrapped())
 676       {
 677         drawWestScale(g, startRes, endx, ypos);
 678       }
 679
 680       if (av.getScaleRightWrapped())
 681       {
 682         g.translate(canvasWidth - labelWidthEast, 0);
 683         drawEastScale(g, startRes, endx, ypos);
 684         g.translate(-(canvasWidth - labelWidthEast), 0);
 685       }
 686
 687       g.translate(labelWidthWest, 0);
 688
 689       if (av.getScaleAboveWrapped())
 690       {
 691         drawNorthScale(g, startRes, endx, ypos);
 692       }
 693
 694       if (av.hasHiddenColumns() && av.getShowHiddenMarkers())
 695       {
 696         g.setColor(Color.blue);
 697         int res;
 698         HiddenColumns hidden = av.getAlignment().getHiddenColumns();
 699         List<Integer> positions = hidden.findHiddenRegionPositions();
 700         for (int pos : positions)
 701         {
 702           res = pos - startRes;
 703
 704           if (res < 0 || res > endx - startRes)
 705           {
 706             continue;
 707           }
 708
 709           gg.fillPolygon(
 710                   new int[]
 711                   { res * charWidth - charHeight / 4,
 712                       res * charWidth + charHeight / 4, res * charWidth },
 713                   new int[]
 714                   { ypos - (charHeight / 2), ypos - (charHeight / 2),
 715                       ypos - (charHeight / 2) + 8 },
 716                   3);
 717
 718         }
 719       }
 720
 721       // When printing we have an extra clipped region,
 722       // the Printable page which we need to account for here
 723       Shape clip = g.getClip();
 724
 725       if (clip == null)
 726       {
 727         g.setClip(0, 0, cWidth * charWidth, canvasHeight);
 728       }
 729       else
 730       {
 731         g.setClip(0, (int) clip.getBounds().getY(), cWidth * charWidth,
 732                 (int) clip.getBounds().getHeight());
 733       }
 734
 735       drawPanel(g, startRes, endx, 0, al.getHeight() - 1, ypos);
 736
 737       if (av.isShowAnnotation())
 738       {
 739         g.translate(0, cHeight + ypos + 3);
 740         if (annotations == null)
 741         {
 742           annotations = new AnnotationPanel(av);
 743         }
 744
 745         annotations.renderer.drawComponent(annotations, av, g, -1, startRes,
 746                 endx + 1);
 747         g.translate(0, -cHeight - ypos - 3);
 748       }
 749       g.setClip(clip);
 750       g.translate(-labelWidthWest, 0);
 751
 752       ypos += cHeight + annotationHeight + hgap;
 753
 754       startRes += cWidth;
 755     }
 756   }
 757
 758   /*
 759    * Draw a selection group over a wrapped alignment
 760    */
 761   private void drawWrappedSelection(Graphics2D g, SequenceGroup group,
 762           int canvasWidth,
 763           int canvasHeight, int startRes)
 764   {
 765     // height gap above each panel
 766     int hgap = charHeight;
 767     if (av.getScaleAboveWrapped())
 768     {
 769       hgap += charHeight;
 770     }
 771
 772     int cWidth = (canvasWidth - labelWidthEast - labelWidthWest)
 773             / charWidth;
 774     int cHeight = av.getAlignment().getHeight() * charHeight;
 775
 776     int startx = startRes;
 777     int endx;
 778     int ypos = hgap; // vertical offset
 779     int maxwidth = av.getAlignment().getWidth();
 780
 781     if (av.hasHiddenColumns())
 782     {
 783       maxwidth = av.getAlignment().getHiddenColumns()
 784               .findColumnPosition(maxwidth);
 785     }
 786
 787     // chop the wrapped alignment extent up into panel-sized blocks and treat
 788     // each block as if it were a block from an unwrapped alignment
 789     while ((ypos <= canvasHeight) && (startx < maxwidth))
 790     {
 791       // set end value to be start + width, or maxwidth, whichever is smaller
 792       endx = startx + cWidth - 1;
 793
 794       if (endx > maxwidth)
 795       {
 796         endx = maxwidth;
 797       }
 798
 799       g.translate(labelWidthWest, 0);
 800
 801       drawUnwrappedSelection(g, group, startx, endx, 0,
 802               av.getAlignment().getHeight() - 1,
 803               ypos);
 804
 805       g.translate(-labelWidthWest, 0);
 806
 807       // update vertical offset
 808       ypos += cHeight + getAnnotationHeight() + hgap;
 809
 810       // update horizontal offset
 811       startx += cWidth;
 812     }
 813   }
 814
 815   int getAnnotationHeight()
 816   {
 817     if (!av.isShowAnnotation())
 818     {
 819       return 0;
 820     }
 821
 822     if (annotations == null)
 823     {
 824       annotations = new AnnotationPanel(av);
 825     }
 826
 827     return annotations.adjustPanelHeight();
 828   }
 829
 830   /**
 831    * Draws the visible region of the alignment on the graphics context. If there
 832    * are hidden column markers in the visible region, then each sub-region
 833    * between the markers is drawn separately, followed by the hidden column
 834    * marker.
 835    *
 836    * @param g1
 837    *          Graphics object to draw with
 838    * @param startRes
 839    *          offset of the first column in the visible region (0..)
 840    * @param endRes
 841    *          offset of the last column in the visible region (0..)
 842    * @param startSeq
 843    *          offset of the first sequence in the visible region (0..)
 844    * @param endSeq
 845    *          offset of the last sequence in the visible region (0..)
 846    * @param yOffset
 847    *          vertical offset at which to draw (for wrapped alignments)
 848    */
 849   public void drawPanel(Graphics g1, final int startRes, final int endRes,
 850           final int startSeq, final int endSeq, final int yOffset)
 851   {
 852     updateViewport();
 853     if (!av.hasHiddenColumns())
 854     {
 855       draw(g1, startRes, endRes, startSeq, endSeq, yOffset);
 856     }
 857     else
 858     {
 859       int screenY = 0;
 860       final int screenYMax = endRes - startRes;
 861       int blockStart = startRes;
 862       int blockEnd = endRes;
 863
 864       for (int[] region : av.getAlignment().getHiddenColumns()
 865               .getHiddenColumnsCopy())
 866       {
 867         int hideStart = region[0];
 868         int hideEnd = region[1];
 869
 870         if (hideStart <= blockStart)
 871         {
 872           blockStart += (hideEnd - hideStart) + 1;
 873           continue;
 874         }
 875
 876         /*
 877          * draw up to just before the next hidden region, or the end of
 878          * the visible region, whichever comes first
 879          */
 880         blockEnd = Math.min(hideStart - 1, blockStart + screenYMax
 881                 - screenY);
 882
 883         g1.translate(screenY * charWidth, 0);
 884
 885         draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
 886
 887         /*
 888          * draw the downline of the hidden column marker (ScalePanel draws the
 889          * triangle on top) if we reached it
 890          */
 891         if (av.getShowHiddenMarkers() && blockEnd == hideStart - 1)
 892         {
 893           g1.setColor(Color.blue);
 894
 895           g1.drawLine((blockEnd - blockStart + 1) * charWidth - 1,
 896                   0 + yOffset, (blockEnd - blockStart + 1) * charWidth - 1,
 897                   (endSeq - startSeq + 1) * charHeight + yOffset);
 898         }
 899
 900         g1.translate(-screenY * charWidth, 0);
 901         screenY += blockEnd - blockStart + 1;
 902         blockStart = hideEnd + 1;
 903
 904         if (screenY > screenYMax)
 905         {
 906           // already rendered last block
 907           return;
 908         }
 909       }
 910
 911       if (screenY <= screenYMax)
 912       {
 913         // remaining visible region to render
 914         blockEnd = blockStart + screenYMax - screenY;
 915         g1.translate(screenY * charWidth, 0);
 916         draw(g1, blockStart, blockEnd, startSeq, endSeq, yOffset);
 917
 918         g1.translate(-screenY * charWidth, 0);
 919       }
 920     }
 921
 922   }
 923
 924   /**
 925    * Draws a region of the visible alignment
 926    *
 927    * @param g1
 928    * @param startRes
 929    *          offset of the first column in the visible region (0..)
 930    * @param endRes
 931    *          offset of the last column in the visible region (0..)
 932    * @param startSeq
 933    *          offset of the first sequence in the visible region (0..)
 934    * @param endSeq
 935    *          offset of the last sequence in the visible region (0..)
 936    * @param yOffset
 937    *          vertical offset at which to draw (for wrapped alignments)
 938    */
 939   private void draw(Graphics g, int startRes, int endRes, int startSeq,
 940           int endSeq, int offset)
 941   {
 942     g.setFont(av.getFont());
 943     seqRdr.prepare(g, av.isRenderGaps());
 944
 945     SequenceI nextSeq;
 946
 947     // / First draw the sequences
 948     // ///////////////////////////
 949     for (int i = startSeq; i <= endSeq; i++)
 950     {
 951       nextSeq = av.getAlignment().getSequenceAt(i);
 952       if (nextSeq == null)
 953       {
 954         // occasionally, a race condition occurs such that the alignment row is
 955         // empty
 956         continue;
 957       }
 958       seqRdr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
 959               startRes, endRes, offset + ((i - startSeq) * charHeight));
 960
 961       if (av.isShowSequenceFeatures())
 962       {
 963         fr.drawSequence(g, nextSeq, startRes, endRes,
 964                 offset + ((i - startSeq) * charHeight), false);
 965       }
 966
 967       /*
 968        * highlight search Results once sequence has been drawn
 969        */
 970       if (av.hasSearchResults())
 971       {
 972         SearchResultsI searchResults = av.getSearchResults();
 973         int[] visibleResults = searchResults.getResults(nextSeq,
 974                 startRes, endRes);
 975         if (visibleResults != null)
 976         {
 977           for (int r = 0; r < visibleResults.length; r += 2)
 978           {
 979             seqRdr.drawHighlightedText(nextSeq, visibleResults[r],
 980                     visibleResults[r + 1], (visibleResults[r] - startRes)
 981                             * charWidth, offset
 982                             + ((i - startSeq) * charHeight));
 983           }
 984         }
 985       }
 986
 987       if (av.cursorMode && cursorY == i && cursorX >= startRes
 988               && cursorX <= endRes)
 989       {
 990         seqRdr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * charWidth,
 991                 offset + ((i - startSeq) * charHeight));
 992       }
 993     }
 994
 995     if (av.getSelectionGroup() != null
 996             || av.getAlignment().getGroups().size() > 0)
 997     {
 998       drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);
 999     }
1000
1001   }
1002
1003   void drawGroupsBoundaries(Graphics g1, int startRes, int endRes,
1004           int startSeq, int endSeq, int offset)
1005   {
1006     Graphics2D g = (Graphics2D) g1;
1007     //
1008     // ///////////////////////////////////
1009     // Now outline any areas if necessary
1010     // ///////////////////////////////////
1011
1012     SequenceGroup group = null;
1013     int groupIndex = -1;
1014
1015     if (av.getAlignment().getGroups().size() > 0)
1016     {
1017       group = av.getAlignment().getGroups().get(0);
1018       groupIndex = 0;
1019     }
1020
1021     if (group != null)
1022     {
1023       g.setStroke(new BasicStroke());
1024       g.setColor(group.getOutlineColour());
1025
1026       do
1027       {
1028         drawPartialGroupOutline(g, group, startRes, endRes, startSeq,
1029                 endSeq, offset);
1030
1031         groupIndex++;
1032
1033         g.setStroke(new BasicStroke());
1034
1035         if (groupIndex >= av.getAlignment().getGroups().size())
1036         {
1037           break;
1038         }
1039
1040         group = av.getAlignment().getGroups().get(groupIndex);
1041
1042       } while (groupIndex < av.getAlignment().getGroups().size());
1043
1044     }
1045
1046   }
1047
1048
1049   /*
1050    * Draw the selection group as a separate image and overlay
1051    */
1052   private BufferedImage drawSelectionGroup(int startRes, int endRes,
1053           int startSeq, int endSeq)
1054   {
1055     // get a new image of the correct size
1056     BufferedImage selectionImage = setupImage();
1057
1058     if (selectionImage == null)
1059     {
1060       return null;
1061     }
1062
1063     SequenceGroup group = av.getSelectionGroup();
1064     if (group == null)
1065     {
1066       // nothing to draw
1067       return null;
1068     }
1069
1070     // set up drawing colour
1071     Graphics2D g = (Graphics2D) selectionImage.getGraphics();
1072
1073     setupSelectionGroup(g, selectionImage);
1074
1075     if (!av.getWrapAlignment())
1076     {
1077       drawUnwrappedSelection(g, group, startRes, endRes, startSeq, endSeq,
1078               0);
1079     }
1080     else
1081     {
1082       drawWrappedSelection(g, group, getWidth(), getHeight(),
1083               av.getRanges().getStartRes());
1084     }
1085
1086     g.dispose();
1087     return selectionImage;
1088   }
1089
1090   /*
1091    * Set up graphics for selection group
1092    */
1093   private void setupSelectionGroup(Graphics2D g,
1094           BufferedImage selectionImage)
1095   {
1096     // set background to transparent
1097     g.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
1098     g.fillRect(0, 0, selectionImage.getWidth(), selectionImage.getHeight());
1099
1100     // set up foreground to draw red dashed line
1101     g.setComposite(AlphaComposite.Src);
1102     g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT,
1103             BasicStroke.JOIN_ROUND, 3f, new float[]
1104     { 5f, 3f }, 0f));
1105     g.setColor(Color.RED);
1106   }
1107
1108   /*
1109    * Draw a selection group over an unwrapped alignment
1110    * @param g graphics object to draw with
1111    * @param group selection group
1112    * @param startRes start residue of area to draw
1113    * @param endRes end residue of area to draw
1114    * @param startSeq start sequence of area to draw
1115    * @param endSeq end sequence of area to draw
1116    * @param offset vertical offset (used when called from wrapped alignment code)
1117    */
1118   private void drawUnwrappedSelection(Graphics2D g, SequenceGroup group,
1119           int startRes, int endRes, int startSeq, int endSeq, int offset)
1120   {
1121     if (!av.hasHiddenColumns())
1122     {
1123       drawPartialGroupOutline(g, group, startRes, endRes, startSeq, endSeq,
1124               offset);
1125     }
1126     else
1127     {
1128       // package into blocks of visible columns
1129       int screenY = 0;
1130       int blockStart = startRes;
1131       int blockEnd = endRes;
1132
1133       for (int[] region : av.getAlignment().getHiddenColumns()
1134               .getHiddenColumnsCopy())
1135       {
1136         int hideStart = region[0];
1137         int hideEnd = region[1];
1138
1139         if (hideStart <= blockStart)
1140         {
1141           blockStart += (hideEnd - hideStart) + 1;
1142           continue;
1143         }
1144
1145         blockEnd = hideStart - 1;
1146
1147         g.translate(screenY * charWidth, 0);
1148         drawPartialGroupOutline(g, group,
1149                 blockStart, blockEnd, startSeq, endSeq, offset);
1150
1151         g.translate(-screenY * charWidth, 0);
1152         screenY += blockEnd - blockStart + 1;
1153         blockStart = hideEnd + 1;
1154
1155         if (screenY > (endRes - startRes))
1156         {
1157           // already rendered last block
1158           break;
1159         }
1160       }
1161
1162       if (screenY <= (endRes - startRes))
1163       {
1164         // remaining visible region to render
1165         blockEnd = blockStart + (endRes - startRes) - screenY;
1166         g.translate(screenY * charWidth, 0);
1167         drawPartialGroupOutline(g, group,
1168                 blockStart, blockEnd, startSeq, endSeq, offset);
1169
1170         g.translate(-screenY * charWidth, 0);
1171       }
1172     }
1173   }
1174
1175   /*
1176    * Draw the selection group as a separate image and overlay
1177    */
1178   private void drawPartialGroupOutline(Graphics2D g, SequenceGroup group,
1179           int startRes, int endRes, int startSeq, int endSeq,
1180           int verticalOffset)
1181   {
1182     int visWidth = (endRes - startRes + 1) * charWidth;
1183
1184     int oldY = -1;
1185     int i = 0;
1186     boolean inGroup = false;
1187     int top = -1;
1188     int bottom = -1;
1189
1190     int sx = -1;
1191     int sy = -1;
1192     int xwidth = -1;
1193
1194     for (i = startSeq; i <= endSeq; i++)
1195     {
1196       // position of start residue of group relative to startRes, in pixels
1197       sx = (group.getStartRes() - startRes) * charWidth;
1198
1199       // width of group in pixels
1200       xwidth = (((group.getEndRes() + 1) - group.getStartRes()) * charWidth)
1201               - 1;
1202
1203       sy = verticalOffset + (i - startSeq) * charHeight;
1204
1205       if (sx + xwidth < 0 || sx > visWidth)
1206       {
1207         continue;
1208       }
1209
1210       if ((sx <= (endRes - startRes) * charWidth)
1211               && group.getSequences(null)
1212                       .contains(av.getAlignment().getSequenceAt(i)))
1213       {
1214         if ((bottom == -1) && !group.getSequences(null)
1215                 .contains(av.getAlignment().getSequenceAt(i + 1)))
1216         {
1217           bottom = sy + charHeight;
1218         }
1219
1220         if (!inGroup)
1221         {
1222           if (((top == -1) && (i == 0)) || !group.getSequences(null)
1223                   .contains(av.getAlignment().getSequenceAt(i - 1)))
1224           {
1225             top = sy;
1226           }
1227
1228           oldY = sy;
1229           inGroup = true;
1230         }
1231       }
1232       else
1233       {
1234         if (inGroup)
1235         {
1236           // if start position is visible, draw vertical line to left of
1237           // group
1238           if (sx >= 0 && sx < visWidth)
1239           {
1240             g.drawLine(sx, oldY, sx, sy);
1241           }
1242
1243           // if end position is visible, draw vertical line to right of
1244           // group
1245           if (sx + xwidth < visWidth)
1246           {
1247             g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
1248           }
1249
1250           if (sx < 0)
1251           {
1252             xwidth += sx;
1253             sx = 0;
1254           }
1255
1256           // don't let width extend beyond current block, or group extent
1257           // fixes JAL-2672
1258           if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
1259           {
1260             xwidth = (endRes - startRes + 1) * charWidth - sx;
1261           }
1262
1263           // draw horizontal line at top of group
1264           if (top != -1)
1265           {
1266             g.drawLine(sx, top, sx + xwidth, top);
1267             top = -1;
1268           }
1269
1270           // draw horizontal line at bottom of group
1271           if (bottom != -1)
1272           {
1273             g.drawLine(sx, bottom, sx + xwidth, bottom);
1274             bottom = -1;
1275           }
1276
1277           inGroup = false;
1278         }
1279       }
1280     }
1281
1282     if (inGroup)
1283     {
1284       sy = verticalOffset + ((i - startSeq) * charHeight);
1285       if (sx >= 0 && sx < visWidth)
1286       {
1287         g.drawLine(sx, oldY, sx, sy);
1288       }
1289
1290       if (sx + xwidth < visWidth)
1291       {
1292         g.drawLine(sx + xwidth, oldY, sx + xwidth, sy);
1293       }
1294
1295       if (sx < 0)
1296       {
1297         xwidth += sx;
1298         sx = 0;
1299       }
1300
1301       if (sx + xwidth > visWidth)
1302       {
1303         xwidth = visWidth;
1304       }
1305       else if (sx + xwidth >= (endRes - startRes + 1) * charWidth)
1306       {
1307         xwidth = (endRes - startRes + 1) * charWidth;
1308       }
1309
1310       if (top != -1)
1311       {
1312         g.drawLine(sx, top, sx + xwidth, top);
1313         top = -1;
1314       }
1315
1316       if (bottom != -1)
1317       {
1318         g.drawLine(sx, bottom - 1, sx + xwidth, bottom - 1);
1319         bottom = -1;
1320       }
1321
1322       inGroup = false;
1323     }
1324   }
1325
1326   /**
1327    * Highlights search results in the visible region by rendering as white text
1328    * on a black background. Any previous highlighting is removed. Answers true
1329    * if any highlight was left on the visible alignment (so status bar should be
1330    * set to match), else false.
1331    * <p>
1332    * Currently fastPaint is not implemented for wrapped alignments. If a wrapped
1333    * alignment had to be scrolled to show the highlighted region, then it should
1334    * be fully redrawn, otherwise a fast paint can be performed. This argument
1335    * could be removed if fast paint of scrolled wrapped alignment is coded in
1336    * future (JAL-2609).
1337    *
1338    * @param results
1339    * @param noFastPaint
1340    * @return
1341    */
1342   public boolean highlightSearchResults(SearchResultsI results,
1343           boolean noFastPaint)
1344   {
1345     if (fastpainting)
1346     {
1347       return false;
1348     }
1349     boolean wrapped = av.getWrapAlignment();
1350
1351     try
1352     {
1353       fastPaint = !noFastPaint;
1354       fastpainting = fastPaint;
1355
1356       updateViewport();
1357
1358       /*
1359        * to avoid redrawing the whole visible region, we instead
1360        * redraw just the minimal regions to remove previous highlights
1361        * and add new ones
1362        */
1363       SearchResultsI previous = av.getSearchResults();
1364       av.setSearchResults(results);
1365       boolean redrawn = false;
1366       boolean drawn = false;
1367       if (wrapped)
1368       {
1369         redrawn = drawMappedPositionsWrapped(previous);
1370         drawn = drawMappedPositionsWrapped(results);
1371         redrawn |= drawn;
1372       }
1373       else
1374       {
1375         redrawn = drawMappedPositions(previous);
1376         drawn = drawMappedPositions(results);
1377         redrawn |= drawn;
1378       }
1379
1380       /*
1381        * if highlights were either removed or added, repaint
1382        */
1383       if (redrawn)
1384       {
1385         repaint();
1386       }
1387
1388       /*
1389        * return true only if highlights were added
1390        */
1391       return drawn;
1392
1393     } finally
1394     {
1395       fastpainting = false;
1396     }
1397   }
1398
1399   /**
1400    * Redraws the minimal rectangle in the visible region (if any) that includes
1401    * mapped positions of the given search results. Whether or not positions are
1402    * highlighted depends on the SearchResults set on the Viewport. This allows
1403    * this method to be called to either clear or set highlighting. Answers true
1404    * if any positions were drawn (in which case a repaint is still required),
1405    * else false.
1406    *
1407    * @param results
1408    * @return
1409    */
1410   protected boolean drawMappedPositions(SearchResultsI results)
1411   {
1412     if (results == null)
1413     {
1414       return false;
1415     }
1416
1417     /*
1418      * calculate the minimal rectangle to redraw that
1419      * includes both new and existing search results
1420      */
1421     int firstSeq = Integer.MAX_VALUE;
1422     int lastSeq = -1;
1423     int firstCol = Integer.MAX_VALUE;
1424     int lastCol = -1;
1425     boolean matchFound = false;
1426
1427     ViewportRanges ranges = av.getRanges();
1428     int firstVisibleColumn = ranges.getStartRes();
1429     int lastVisibleColumn = ranges.getEndRes();
1430     AlignmentI alignment = av.getAlignment();
1431     if (av.hasHiddenColumns())
1432     {
1433       firstVisibleColumn = alignment.getHiddenColumns()
1434               .adjustForHiddenColumns(firstVisibleColumn);
1435       lastVisibleColumn = alignment.getHiddenColumns()
1436               .adjustForHiddenColumns(lastVisibleColumn);
1437     }
1438
1439     for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
1440             .getEndSeq(); seqNo++)
1441     {
1442       SequenceI seq = alignment.getSequenceAt(seqNo);
1443
1444       int[] visibleResults = results.getResults(seq, firstVisibleColumn,
1445               lastVisibleColumn);
1446       if (visibleResults != null)
1447       {
1448         for (int i = 0; i < visibleResults.length - 1; i += 2)
1449         {
1450           int firstMatchedColumn = visibleResults[i];
1451           int lastMatchedColumn = visibleResults[i + 1];
1452           if (firstMatchedColumn <= lastVisibleColumn
1453                   && lastMatchedColumn >= firstVisibleColumn)
1454           {
1455             /*
1456              * found a search results match in the visible region -
1457              * remember the first and last sequence matched, and the first
1458              * and last visible columns in the matched positions
1459              */
1460             matchFound = true;
1461             firstSeq = Math.min(firstSeq, seqNo);
1462             lastSeq = Math.max(lastSeq, seqNo);
1463             firstMatchedColumn = Math.max(firstMatchedColumn,
1464                     firstVisibleColumn);
1465             lastMatchedColumn = Math.min(lastMatchedColumn,
1466                     lastVisibleColumn);
1467             firstCol = Math.min(firstCol, firstMatchedColumn);
1468             lastCol = Math.max(lastCol, lastMatchedColumn);
1469           }
1470         }
1471       }
1472     }
1473
1474     if (matchFound)
1475     {
1476       if (av.hasHiddenColumns())
1477       {
1478         firstCol = alignment.getHiddenColumns()
1479                 .findColumnPosition(firstCol);
1480         lastCol = alignment.getHiddenColumns().findColumnPosition(lastCol);
1481       }
1482       int transX = (firstCol - ranges.getStartRes()) * av.getCharWidth();
1483       int transY = (firstSeq - ranges.getStartSeq()) * av.getCharHeight();
1484       gg.translate(transX, transY);
1485       drawPanel(gg, firstCol, lastCol, firstSeq, lastSeq, 0);
1486       gg.translate(-transX, -transY);
1487     }
1488
1489     return matchFound;
1490   }
1491
1492
1493   @Override
1494   public void propertyChange(PropertyChangeEvent evt)
1495   {
1496     String eventName = evt.getPropertyName();
1497
1498     if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
1499     {
1500       fastPaint = true;
1501       repaint();
1502     }
1503     else if (av.getWrapAlignment())
1504     {
1505       if (eventName.equals(ViewportRanges.STARTRES))
1506       {
1507         repaint();
1508       }
1509     }
1510     else
1511     {
1512       int scrollX = 0;
1513       if (eventName.equals(ViewportRanges.STARTRES)
1514               || eventName.equals(ViewportRanges.STARTRESANDSEQ))
1515       {
1516         // Make sure we're not trying to draw a panel
1517         // larger than the visible window
1518         if (eventName.equals(ViewportRanges.STARTRES))
1519         {
1520           scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
1521         }
1522         else
1523         {
1524           scrollX = ((int[]) evt.getNewValue())[0]
1525                   - ((int[]) evt.getOldValue())[0];
1526         }
1527         ViewportRanges vpRanges = av.getRanges();
1528
1529         int range = vpRanges.getEndRes() - vpRanges.getStartRes();
1530         if (scrollX > range)
1531         {
1532           scrollX = range;
1533         }
1534         else if (scrollX < -range)
1535         {
1536           scrollX = -range;
1537         }
1538       }
1539
1540       // Both scrolling and resizing change viewport ranges: scrolling changes
1541       // both start and end points, but resize only changes end values.
1542       // Here we only want to fastpaint on a scroll, with resize using a normal
1543       // paint, so scroll events are identified as changes to the horizontal or
1544       // vertical start value.
1545       if (eventName.equals(ViewportRanges.STARTRES))
1546       {
1547         // scroll - startres and endres both change
1548         fastPaint(scrollX, 0);
1549       }
1550       else if (eventName.equals(ViewportRanges.STARTSEQ))
1551       {
1552         // scroll
1553         fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
1554       }
1555       else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
1556       {
1557         fastPaint(scrollX, ((int[]) evt.getNewValue())[1]
1558                 - ((int[]) evt.getOldValue())[1]);
1559       }
1560     }
1561   }
1562
1563   /**
1564    * Redraws any positions in the search results in the visible region of a
1565    * wrapped alignment. Any highlights are drawn depending on the search results
1566    * set on the Viewport, not the <code>results</code> argument. This allows
1567    * this method to be called either to clear highlights (passing the previous
1568    * search results), or to draw new highlights.
1569    *
1570    * @param results
1571    * @return
1572    */
1573   protected boolean drawMappedPositionsWrapped(SearchResultsI results)
1574   {
1575     if (results == null)
1576     {
1577       return false;
1578     }
1579
1580     boolean matchFound = false;
1581
1582     int wrappedWidth = av.getWrappedWidth();
1583     int wrappedHeight = getRepeatHeightWrapped();
1584
1585     ViewportRanges ranges = av.getRanges();
1586     int canvasHeight = getHeight();
1587     int repeats = canvasHeight / wrappedHeight;
1588     if (canvasHeight / wrappedHeight > 0)
1589     {
1590       repeats++;
1591     }
1592
1593     int firstVisibleColumn = ranges.getStartRes();
1594     int lastVisibleColumn = ranges.getStartRes() + repeats
1595             * ranges.getViewportWidth() - 1;
1596
1597     AlignmentI alignment = av.getAlignment();
1598     if (av.hasHiddenColumns())
1599     {
1600       firstVisibleColumn = alignment.getHiddenColumns()
1601               .adjustForHiddenColumns(firstVisibleColumn);
1602       lastVisibleColumn = alignment.getHiddenColumns()
1603               .adjustForHiddenColumns(lastVisibleColumn);
1604     }
1605
1606     int gapHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
1607
1608     for (int seqNo = ranges.getStartSeq(); seqNo <= ranges
1609             .getEndSeq(); seqNo++)
1610     {
1611       SequenceI seq = alignment.getSequenceAt(seqNo);
1612
1613       int[] visibleResults = results.getResults(seq, firstVisibleColumn,
1614               lastVisibleColumn);
1615       if (visibleResults != null)
1616       {
1617         for (int i = 0; i < visibleResults.length - 1; i += 2)
1618         {
1619           int firstMatchedColumn = visibleResults[i];
1620           int lastMatchedColumn = visibleResults[i + 1];
1621           if (firstMatchedColumn <= lastVisibleColumn
1622                   && lastMatchedColumn >= firstVisibleColumn)
1623           {
1624             /*
1625              * found a search results match in the visible region
1626              */
1627             firstMatchedColumn = Math.max(firstMatchedColumn,
1628                     firstVisibleColumn);
1629             lastMatchedColumn = Math.min(lastMatchedColumn,
1630                     lastVisibleColumn);
1631
1632             /*
1633              * draw each mapped position separately (as contiguous positions may
1634              * wrap across lines)
1635              */
1636             for (int mappedPos = firstMatchedColumn; mappedPos <= lastMatchedColumn; mappedPos++)
1637             {
1638               int displayColumn = mappedPos;
1639               if (av.hasHiddenColumns())
1640               {
1641                 displayColumn = alignment.getHiddenColumns()
1642                         .findColumnPosition(displayColumn);
1643               }
1644
1645               /*
1646                * transX: offset from left edge of canvas to residue position
1647                */
1648               int transX = labelWidthWest
1649                       + ((displayColumn - ranges.getStartRes()) % wrappedWidth)
1650                       * av.getCharWidth();
1651
1652               /*
1653                * transY: offset from top edge of canvas to residue position
1654                */
1655               int transY = gapHeight;
1656               transY += (displayColumn - ranges.getStartRes())
1657                       / wrappedWidth * wrappedHeight;
1658               transY += (seqNo - ranges.getStartSeq()) * av.getCharHeight();
1659
1660               /*
1661                * yOffset is from graphics origin to start of visible region
1662                */
1663               int yOffset = 0;// (displayColumn / wrappedWidth) * wrappedHeight;
1664               if (transY < getHeight())
1665               {
1666                 matchFound = true;
1667                 gg.translate(transX, transY);
1668                 drawPanel(gg, displayColumn, displayColumn, seqNo, seqNo,
1669                         yOffset);
1670                 gg.translate(-transX, -transY);
1671               }
1672             }
1673           }
1674         }
1675       }
1676     }
1677
1678     return matchFound;
1679   }
1680
1681   /**
1682    * Answers the height in pixels of a repeating section of the wrapped
1683    * alignment, including space above, scale above if shown, sequences, and
1684    * annotation panel if shown
1685    *
1686    * @return
1687    */
1688   protected int getRepeatHeightWrapped()
1689   {
1690     // gap (and maybe scale) above
1691     int repeatHeight = charHeight * (av.getScaleAboveWrapped() ? 2 : 1);
1692
1693     // add sequences
1694     repeatHeight += av.getRanges().getViewportHeight() * charHeight;
1695
1696     // add annotations panel height if shown
1697     repeatHeight += getAnnotationHeight();
1698
1699     return repeatHeight;
1700   }
1701 }