src/jalview/appletgui/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.appletgui;
  22
  23 import jalview.datamodel.AlignmentI;
  24 import jalview.datamodel.SearchResultsI;
  25 import jalview.datamodel.SequenceGroup;
  26 import jalview.datamodel.SequenceI;
  27 import jalview.renderer.ScaleRenderer;
  28 import jalview.renderer.ScaleRenderer.ScaleMark;
  29 import jalview.viewmodel.AlignmentViewport;
  30
  31 import java.awt.Color;
  32 import java.awt.FontMetrics;
  33 import java.awt.Graphics;
  34 import java.awt.Image;
  35 import java.awt.Panel;
  36
  37 public class SeqCanvas extends Panel
  38 {
  39   FeatureRenderer fr;
  40
  41   SequenceRenderer sr;
  42
  43   Image img;
  44
  45   Graphics gg;
  46
  47   int imgWidth;
  48
  49   int imgHeight;
  50
  51   AlignViewport av;
  52
  53   boolean fastPaint = false;
  54
  55   int cursorX = 0;
  56
  57   int cursorY = 0;
  58
  59   public SeqCanvas(AlignViewport av)
  60   {
  61     this.av = av;
  62     fr = new FeatureRenderer(av);
  63     sr = new SequenceRenderer(av);
  64     PaintRefresher.Register(this, av.getSequenceSetId());
  65     updateViewport();
  66   }
  67
  68   int avcharHeight = 0, avcharWidth = 0;
  69
  70   private void updateViewport()
  71   {
  72     avcharHeight = av.getCharHeight();
  73     avcharWidth = av.getCharWidth();
  74   }
  75
  76   public AlignmentViewport getViewport()
  77   {
  78     return av;
  79   }
  80
  81   public FeatureRenderer getFeatureRenderer()
  82   {
  83     return fr;
  84   }
  85
  86   public SequenceRenderer getSequenceRenderer()
  87   {
  88     return sr;
  89   }
  90
  91   private void drawNorthScale(Graphics g, int startx, int endx, int ypos)
  92   {
  93     updateViewport();
  94     g.setColor(Color.black);
  95     for (ScaleMark mark : new ScaleRenderer().calculateMarks(av, startx,
  96             endx))
  97     {
  98       int mpos = mark.column; // (i - startx - 1)
  99       if (mpos < 0)
 100       {
 101         continue;
 102       }
 103       String mstring = mark.text;
 104
 105       if (mark.major)
 106       {
 107         if (mstring != null)
 108         {
 109           g.drawString(mstring, mpos * avcharWidth, ypos
 110                   - (avcharHeight / 2));
 111         }
 112         g.drawLine((mpos * avcharWidth) + (avcharWidth / 2), (ypos + 2)
 113                 - (avcharHeight / 2), (mpos * avcharWidth)
 114                 + (avcharWidth / 2), ypos - 2);
 115       }
 116     }
 117   }
 118
 119   private void drawWestScale(Graphics g, int startx, int endx, int ypos)
 120   {
 121     FontMetrics fm = getFontMetrics(av.getFont());
 122     ypos += avcharHeight;
 123     if (av.hasHiddenColumns())
 124     {
 125       startx = av.getColumnSelection().adjustForHiddenColumns(startx);
 126       endx = av.getColumnSelection().adjustForHiddenColumns(endx);
 127     }
 128
 129     int maxwidth = av.getAlignment().getWidth();
 130     if (av.hasHiddenColumns())
 131     {
 132       maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
 133     }
 134
 135     // WEST SCALE
 136     for (int i = 0; i < av.getAlignment().getHeight(); i++)
 137     {
 138       SequenceI seq = av.getAlignment().getSequenceAt(i);
 139       int index = startx;
 140       int value = -1;
 141
 142       while (index < endx)
 143       {
 144         if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
 145         {
 146           index++;
 147
 148           continue;
 149         }
 150
 151         value = av.getAlignment().getSequenceAt(i).findPosition(index);
 152
 153         break;
 154       }
 155
 156       if (value != -1)
 157       {
 158         int x = LABEL_WEST - fm.stringWidth(String.valueOf(value))
 159                 - avcharWidth / 2;
 160         g.drawString(value + "", x, (ypos + (i * avcharHeight))
 161                 - (avcharHeight / 5));
 162       }
 163     }
 164   }
 165
 166   private void drawEastScale(Graphics g, int startx, int endx, int ypos)
 167   {
 168     ypos += avcharHeight;
 169
 170     if (av.hasHiddenColumns())
 171     {
 172       endx = av.getColumnSelection().adjustForHiddenColumns(endx);
 173     }
 174
 175     SequenceI seq;
 176     // EAST SCALE
 177     for (int i = 0; i < av.getAlignment().getHeight(); i++)
 178     {
 179       seq = av.getAlignment().getSequenceAt(i);
 180       int index = endx;
 181       int value = -1;
 182
 183       while (index > startx)
 184       {
 185         if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
 186         {
 187           index--;
 188
 189           continue;
 190         }
 191
 192         value = seq.findPosition(index);
 193
 194         break;
 195       }
 196
 197       if (value != -1)
 198       {
 199         g.drawString(String.valueOf(value), 0, (ypos + (i * avcharHeight))
 200                 - (avcharHeight / 5));
 201       }
 202     }
 203   }
 204
 205   int lastsr = 0;
 206
 207   void fastPaint(int horizontal, int vertical)
 208   {
 209     if (fastPaint || gg == null)
 210     {
 211       return;
 212     }
 213
 214     updateViewport();
 215
 216     // Its possible on certain browsers that the call to fastpaint
 217     // is faster than it can paint, so this check here catches
 218     // this possibility
 219     if (lastsr + horizontal != av.startRes)
 220     {
 221       horizontal = av.startRes - lastsr;
 222     }
 223
 224     lastsr = av.startRes;
 225
 226     fastPaint = true;
 227     gg.copyArea(horizontal * avcharWidth, vertical * avcharHeight, imgWidth
 228             - horizontal * avcharWidth,
 229             imgHeight - vertical * avcharHeight, -horizontal * avcharWidth,
 230             -vertical * avcharHeight);
 231
 232     int sr = av.startRes, er = av.endRes, ss = av.startSeq, es = av.endSeq, transX = 0, transY = 0;
 233
 234     if (horizontal > 0) // scrollbar pulled right, image to the left
 235     {
 236       transX = (er - sr - horizontal) * avcharWidth;
 237       sr = er - horizontal;
 238     }
 239     else if (horizontal < 0)
 240     {
 241       er = sr - horizontal;
 242     }
 243
 244     else if (vertical > 0) // scroll down
 245     {
 246       ss = es - vertical;
 247       if (ss < av.startSeq) // ie scrolling too fast, more than a page at a time
 248       {
 249         ss = av.startSeq;
 250       }
 251       else
 252       {
 253         transY = imgHeight - vertical * avcharHeight;
 254       }
 255     }
 256     else if (vertical < 0)
 257     {
 258       es = ss - vertical;
 259       if (es > av.endSeq)
 260       {
 261         es = av.endSeq;
 262       }
 263     }
 264
 265     gg.translate(transX, transY);
 266
 267     drawPanel(gg, sr, er, ss, es, 0);
 268     gg.translate(-transX, -transY);
 269
 270     repaint();
 271
 272   }
 273
 274   /**
 275    * Definitions of startx and endx (hopefully): SMJS This is what I'm working
 276    * towards! startx is the first residue (starting at 0) to display. endx is
 277    * the last residue to display (starting at 0). starty is the first sequence
 278    * to display (starting at 0). endy is the last sequence to display (starting
 279    * at 0). NOTE 1: The av limits are set in setFont in this class and in the
 280    * adjustment listener in SeqPanel when the scrollbars move.
 281    */
 282   @Override
 283   public void update(Graphics g)
 284   {
 285     paint(g);
 286   }
 287
 288   @Override
 289   public void paint(Graphics g)
 290   {
 291
 292     if (img != null
 293             && (fastPaint || (getSize().width != g.getClipBounds().width) || (getSize().height != g
 294                     .getClipBounds().height)))
 295     {
 296       g.drawImage(img, 0, 0, this);
 297       fastPaint = false;
 298       return;
 299     }
 300
 301     if (fastPaint)
 302     {
 303       g.drawImage(img, 0, 0, this);
 304       fastPaint = false;
 305       return;
 306     }
 307
 308     updateViewport();
 309     // this draws the whole of the alignment
 310     imgWidth = this.getSize().width;
 311     imgHeight = this.getSize().height;
 312
 313     imgWidth -= imgWidth % avcharWidth;
 314     imgHeight -= imgHeight % avcharHeight;
 315
 316     if (imgWidth < 1 || imgHeight < 1)
 317     {
 318       return;
 319     }
 320
 321     if (img == null || imgWidth != img.getWidth(this)
 322             || imgHeight != img.getHeight(this))
 323     {
 324       img = createImage(imgWidth, imgHeight);
 325       gg = img.getGraphics();
 326       gg.setFont(av.getFont());
 327     }
 328
 329     gg.setColor(Color.white);
 330     gg.fillRect(0, 0, imgWidth, imgHeight);
 331
 332     if (av.getWrapAlignment())
 333     {
 334       drawWrappedPanel(gg, imgWidth, imgHeight, av.startRes);
 335     }
 336     else
 337     {
 338       drawPanel(gg, av.startRes, av.endRes, av.startSeq, av.endSeq, 0);
 339     }
 340
 341     g.drawImage(img, 0, 0, this);
 342
 343   }
 344
 345   int LABEL_WEST, LABEL_EAST;
 346
 347   public int getWrappedCanvasWidth(int cwidth)
 348   {
 349     cwidth -= cwidth % av.getCharWidth();
 350
 351     FontMetrics fm = getFontMetrics(av.getFont());
 352
 353     LABEL_EAST = 0;
 354     LABEL_WEST = 0;
 355
 356     if (av.getScaleRightWrapped())
 357     {
 358       LABEL_EAST = fm.stringWidth(getMask());
 359     }
 360
 361     if (av.getScaleLeftWrapped())
 362     {
 363       LABEL_WEST = fm.stringWidth(getMask());
 364     }
 365
 366     return (cwidth - LABEL_EAST - LABEL_WEST) / av.getCharWidth();
 367   }
 368
 369   /**
 370    * Generates a string of zeroes.
 371    *
 372    * @return String
 373    */
 374   String getMask()
 375   {
 376     String mask = "0";
 377     int maxWidth = 0;
 378     int tmp;
 379     AlignmentI alignment = av.getAlignment();
 380     for (int i = 0; i < alignment.getHeight(); i++)
 381     {
 382       tmp = alignment.getSequenceAt(i).getEnd();
 383       if (tmp > maxWidth)
 384       {
 385         maxWidth = tmp;
 386       }
 387     }
 388
 389     for (int i = maxWidth; i > 0; i /= 10)
 390     {
 391       mask += "0";
 392     }
 393     return mask;
 394   }
 395
 396   private void drawWrappedPanel(Graphics g, int canvasWidth,
 397           int canvasHeight, int startRes)
 398   {
 399     AlignmentI al = av.getAlignment();
 400
 401     FontMetrics fm = getFontMetrics(av.getFont());
 402
 403     if (av.getScaleRightWrapped())
 404     {
 405       LABEL_EAST = fm.stringWidth(getMask());
 406     }
 407
 408     if (av.getScaleLeftWrapped())
 409     {
 410       LABEL_WEST = fm.stringWidth(getMask());
 411     }
 412
 413     int hgap = avcharHeight;
 414     if (av.getScaleAboveWrapped())
 415     {
 416       hgap += avcharHeight;
 417     }
 418
 419     int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / avcharWidth;
 420     int cHeight = av.getAlignment().getHeight() * avcharHeight;
 421
 422     av.setWrappedWidth(cWidth);
 423
 424     av.endRes = av.startRes + cWidth;
 425
 426     int endx;
 427     int ypos = hgap;
 428
 429     int maxwidth = av.getAlignment().getWidth() - 1;
 430
 431     if (av.hasHiddenColumns())
 432     {
 433       maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
 434     }
 435
 436     while ((ypos <= canvasHeight) && (startRes < maxwidth))
 437     {
 438       endx = startRes + cWidth - 1;
 439
 440       if (endx > maxwidth)
 441       {
 442         endx = maxwidth;
 443       }
 444
 445       g.setColor(Color.black);
 446
 447       if (av.getScaleLeftWrapped())
 448       {
 449         drawWestScale(g, startRes, endx, ypos);
 450       }
 451
 452       if (av.getScaleRightWrapped())
 453       {
 454         g.translate(canvasWidth - LABEL_EAST, 0);
 455         drawEastScale(g, startRes, endx, ypos);
 456         g.translate(-(canvasWidth - LABEL_EAST), 0);
 457       }
 458
 459       g.translate(LABEL_WEST, 0);
 460
 461       if (av.getScaleAboveWrapped())
 462       {
 463         drawNorthScale(g, startRes, endx, ypos);
 464       }
 465       if (av.hasHiddenColumns() && av.getShowHiddenMarkers())
 466       {
 467         g.setColor(Color.blue);
 468         int res;
 469         for (int i = 0; i < av.getColumnSelection().getHiddenColumns()
 470                 .size(); i++)
 471         {
 472           res = av.getColumnSelection().findHiddenRegionPosition(i)
 473                   - startRes;
 474
 475           if (res < 0 || res > endx - startRes)
 476           {
 477             continue;
 478           }
 479
 480           gg.fillPolygon(new int[] { res * avcharWidth - avcharHeight / 4,
 481               res * avcharWidth + avcharHeight / 4, res * avcharWidth },
 482                   new int[] { ypos - (avcharHeight / 2),
 483                       ypos - (avcharHeight / 2),
 484                       ypos - (avcharHeight / 2) + 8 }, 3);
 485
 486         }
 487       }
 488
 489       if (g.getClip() == null)
 490       {
 491         g.setClip(0, 0, cWidth * avcharWidth, canvasHeight);
 492       }
 493
 494       drawPanel(g, startRes, endx, 0, al.getHeight(), ypos);
 495       g.setClip(null);
 496
 497       if (av.isShowAnnotation())
 498       {
 499         g.translate(0, cHeight + ypos + 4);
 500         if (annotations == null)
 501         {
 502           annotations = new AnnotationPanel(av);
 503         }
 504
 505         annotations.drawComponent(g, startRes, endx + 1);
 506         g.translate(0, -cHeight - ypos - 4);
 507       }
 508       g.translate(-LABEL_WEST, 0);
 509
 510       ypos += cHeight + getAnnotationHeight() + hgap;
 511
 512       startRes += cWidth;
 513     }
 514
 515   }
 516
 517   AnnotationPanel annotations;
 518
 519   int getAnnotationHeight()
 520   {
 521     if (!av.isShowAnnotation())
 522     {
 523       return 0;
 524     }
 525
 526     if (annotations == null)
 527     {
 528       annotations = new AnnotationPanel(av);
 529     }
 530
 531     return annotations.adjustPanelHeight();
 532   }
 533
 534   private void drawPanel(Graphics g1, int startRes, int endRes,
 535           int startSeq, int endSeq, int offset)
 536   {
 537
 538     if (!av.hasHiddenColumns())
 539     {
 540       draw(g1, startRes, endRes, startSeq, endSeq, offset);
 541     }
 542     else
 543     {
 544
 545       int screenY = 0;
 546       int blockStart = startRes;
 547       int blockEnd = endRes;
 548
 549       if (av.hasHiddenColumns())
 550       {
 551         for (int[] region : av.getColumnSelection().getHiddenColumns())
 552         {
 553           int hideStart = region[0];
 554           int hideEnd = region[1];
 555
 556           if (hideStart <= blockStart)
 557           {
 558             blockStart += (hideEnd - hideStart) + 1;
 559             continue;
 560           }
 561
 562           blockEnd = hideStart - 1;
 563
 564           g1.translate(screenY * avcharWidth, 0);
 565
 566           draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
 567
 568           if (av.getShowHiddenMarkers())
 569           {
 570             g1.setColor(Color.blue);
 571             g1.drawLine((blockEnd - blockStart + 1) * avcharWidth - 1,
 572                     0 + offset, (blockEnd - blockStart + 1) * avcharWidth
 573                             - 1, (endSeq - startSeq) * avcharHeight
 574                             + offset);
 575           }
 576
 577           g1.translate(-screenY * avcharWidth, 0);
 578           screenY += blockEnd - blockStart + 1;
 579           blockStart = hideEnd + 1;
 580
 581           if (screenY > (endRes - startRes))
 582           {
 583             // already rendered last block
 584             return;
 585           }
 586         }
 587       }
 588       if (screenY <= (endRes - startRes))
 589       {
 590         // remaining visible region to render
 591         blockEnd = blockStart + (endRes - startRes) - screenY;
 592         g1.translate(screenY * avcharWidth, 0);
 593         draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
 594
 595         g1.translate(-screenY * avcharWidth, 0);
 596       }
 597     }
 598
 599   }
 600
 601   // int startRes, int endRes, int startSeq, int endSeq, int x, int y,
 602   // int x1, int x2, int y1, int y2, int startx, int starty,
 603   void draw(Graphics g, int startRes, int endRes, int startSeq, int endSeq,
 604           int offset)
 605   {
 606     g.setFont(av.getFont());
 607     sr.prepare(g, av.isRenderGaps());
 608     updateViewport();
 609     SequenceI nextSeq;
 610
 611     // / First draw the sequences
 612     // ///////////////////////////
 613     for (int i = startSeq; i < endSeq; i++)
 614     {
 615       nextSeq = av.getAlignment().getSequenceAt(i);
 616
 617       if (nextSeq == null)
 618       {
 619         continue;
 620       }
 621
 622       sr.drawSequence(nextSeq, av.getAlignment().findAllGroups(nextSeq),
 623               startRes, endRes, offset + ((i - startSeq) * avcharHeight));
 624
 625       if (av.isShowSequenceFeatures())
 626       {
 627         fr.drawSequence(g, nextSeq, startRes, endRes, offset
 628                 + ((i - startSeq) * avcharHeight));
 629       }
 630
 631       // / Highlight search Results once all sequences have been drawn
 632       // ////////////////////////////////////////////////////////
 633       if (av.hasSearchResults())
 634       {
 635         int[] visibleResults = av.getSearchResults().getResults(nextSeq,
 636                 startRes,
 637                 endRes);
 638         if (visibleResults != null)
 639         {
 640           for (int r = 0; r < visibleResults.length; r += 2)
 641           {
 642             sr.drawHighlightedText(nextSeq, visibleResults[r],
 643                     visibleResults[r + 1], (visibleResults[r] - startRes)
 644                             * avcharWidth, offset
 645                             + ((i - startSeq) * avcharHeight));
 646           }
 647         }
 648       }
 649
 650       if (av.cursorMode && cursorY == i && cursorX >= startRes
 651               && cursorX <= endRes)
 652       {
 653         sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * avcharWidth,
 654                 offset + ((i - startSeq) * avcharHeight));
 655       }
 656     }
 657
 658     if (av.getSelectionGroup() != null
 659             || av.getAlignment().getGroups().size() > 0)
 660     {
 661       drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);
 662     }
 663
 664   }
 665
 666   private void drawGroupsBoundaries(Graphics g, int startRes, int endRes,
 667           int startSeq, int endSeq, int offset)
 668   {
 669     //
 670     // ///////////////////////////////////
 671     // Now outline any areas if necessary
 672     // ///////////////////////////////////
 673     SequenceGroup group = av.getSelectionGroup();
 674
 675     int sx = -1;
 676     int sy = -1;
 677     int ex = -1;
 678     int groupIndex = -1;
 679
 680     if ((group == null) && (av.getAlignment().getGroups().size() > 0))
 681     {
 682       group = av.getAlignment().getGroups().get(0);
 683       groupIndex = 0;
 684     }
 685
 686     if (group != null)
 687     {
 688       do
 689       {
 690         int oldY = -1;
 691         int i = 0;
 692         boolean inGroup = false;
 693         int top = -1;
 694         int bottom = -1;
 695         int alHeight = av.getAlignment().getHeight() - 1;
 696
 697         for (i = startSeq; i < endSeq; i++)
 698         {
 699           sx = (group.getStartRes() - startRes) * avcharWidth;
 700           sy = offset + ((i - startSeq) * avcharHeight);
 701           ex = (((group.getEndRes() + 1) - group.getStartRes()) * avcharWidth) - 1;
 702
 703           if (sx + ex < 0 || sx > imgWidth)
 704           {
 705             continue;
 706           }
 707
 708           if ((sx <= (endRes - startRes) * avcharWidth)
 709                   && group.getSequences(null).contains(
 710                           av.getAlignment().getSequenceAt(i)))
 711           {
 712             if ((bottom == -1)
 713                     && (i >= alHeight || !group.getSequences(null)
 714                             .contains(
 715                                     av.getAlignment().getSequenceAt(i + 1))))
 716             {
 717               bottom = sy + avcharHeight;
 718             }
 719
 720             if (!inGroup)
 721             {
 722               if (((top == -1) && (i == 0))
 723                       || !group.getSequences(null).contains(
 724                               av.getAlignment().getSequenceAt(i - 1)))
 725               {
 726                 top = sy;
 727               }
 728
 729               oldY = sy;
 730               inGroup = true;
 731
 732               if (group == av.getSelectionGroup())
 733               {
 734                 g.setColor(Color.red);
 735               }
 736               else
 737               {
 738                 g.setColor(group.getOutlineColour());
 739               }
 740             }
 741           }
 742           else
 743           {
 744             if (inGroup)
 745             {
 746               if (sx >= 0 && sx < imgWidth)
 747               {
 748                 g.drawLine(sx, oldY, sx, sy);
 749               }
 750
 751               if (sx + ex < imgWidth)
 752               {
 753                 g.drawLine(sx + ex, oldY, sx + ex, sy);
 754               }
 755
 756               if (sx < 0)
 757               {
 758                 ex += sx;
 759                 sx = 0;
 760               }
 761
 762               if (sx + ex > imgWidth)
 763               {
 764                 ex = imgWidth;
 765               }
 766
 767               else if (sx + ex >= (endRes - startRes + 1) * avcharWidth)
 768               {
 769                 ex = (endRes - startRes + 1) * avcharWidth;
 770               }
 771
 772               if (top != -1)
 773               {
 774                 g.drawLine(sx, top, sx + ex, top);
 775                 top = -1;
 776               }
 777
 778               if (bottom != -1)
 779               {
 780                 g.drawLine(sx, bottom, sx + ex, bottom);
 781                 bottom = -1;
 782               }
 783
 784               inGroup = false;
 785             }
 786           }
 787         }
 788
 789         if (inGroup)
 790         {
 791           sy = offset + ((i - startSeq) * avcharHeight);
 792           if (sx >= 0 && sx < imgWidth)
 793           {
 794             g.drawLine(sx, oldY, sx, sy);
 795           }
 796
 797           if (sx + ex < imgWidth)
 798           {
 799             g.drawLine(sx + ex, oldY, sx + ex, sy);
 800           }
 801
 802           if (sx < 0)
 803           {
 804             ex += sx;
 805             sx = 0;
 806           }
 807
 808           if (sx + ex > imgWidth)
 809           {
 810             ex = imgWidth;
 811           }
 812           else if (sx + ex >= (endRes - startRes + 1) * avcharWidth)
 813           {
 814             ex = (endRes - startRes + 1) * avcharWidth;
 815           }
 816
 817           if (top != -1)
 818           {
 819             g.drawLine(sx, top, sx + ex, top);
 820             top = -1;
 821           }
 822
 823           if (bottom != -1)
 824           {
 825             g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);
 826             bottom = -1;
 827           }
 828
 829           inGroup = false;
 830         }
 831
 832         groupIndex++;
 833
 834         if (groupIndex >= av.getAlignment().getGroups().size())
 835         {
 836           break;
 837         }
 838
 839         group = av.getAlignment().getGroups().get(groupIndex);
 840       } while (groupIndex < av.getAlignment().getGroups().size());
 841
 842     }
 843   }
 844
 845   public void highlightSearchResults(SearchResultsI results)
 846   {
 847     av.setSearchResults(results);
 848     repaint();
 849   }
 850
 851 }