jalview/gui/IdCanvas.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.SequenceI;
  24 import jalview.viewmodel.ViewportListenerI;
  25 import jalview.viewmodel.ViewportRanges;
  26
  27 import java.awt.BorderLayout;
  28 import java.awt.Color;
  29 import java.awt.Font;
  30 import java.awt.FontMetrics;
  31 import java.awt.Graphics;
  32 import java.awt.Graphics2D;
  33 import java.awt.RenderingHints;
  34 import java.awt.image.BufferedImage;
  35 import java.beans.PropertyChangeEvent;
  36 import java.util.List;
  37
  38 import javax.swing.JPanel;
  39
  40 /**
  41  * DOCUMENT ME!
  42  *
  43  * @author $author$
  44  * @version $Revision$
  45  */
  46 public class IdCanvas extends JPanel implements ViewportListenerI
  47 {
  48   protected AlignViewport av;
  49
  50   protected boolean showScores = true;
  51
  52   protected int maxIdLength = -1;
  53
  54   protected String maxIdStr = null;
  55
  56   BufferedImage image;
  57
  58   Graphics2D gg;
  59
  60   int imgHeight = 0;
  61
  62   boolean fastPaint = false;
  63
  64   List<SequenceI> searchResults;
  65
  66   FontMetrics fm;
  67
  68   AnnotationLabels labels = null;
  69
  70   AnnotationPanel ap;
  71
  72   private Font idfont;
  73
  74   /**
  75    * Creates a new IdCanvas object.
  76    *
  77    * @param av
  78    *          DOCUMENT ME!
  79    */
  80   public IdCanvas(AlignViewport av)
  81   {
  82     setLayout(new BorderLayout());
  83     this.av = av;
  84     PaintRefresher.Register(this, av.getSequenceSetId());
  85     av.getRanges().addPropertyChangeListener(this);
  86   }
  87
  88   /**
  89    * DOCUMENT ME!
  90    *
  91    * @param gg
  92    *          DOCUMENT ME!
  93    * @param hiddenRows
  94    *          true - check and display hidden row marker if need be
  95    * @param s
  96    *          DOCUMENT ME!
  97    * @param i
  98    *          DOCUMENT ME!
  99    * @param starty
 100    *          DOCUMENT ME!
 101    * @param ypos
 102    *          DOCUMENT ME!
 103    */
 104   public void drawIdString(Graphics2D gg, boolean hiddenRows, SequenceI s,
 105           int i, int starty, int ypos)
 106   {
 107     int xPos = 0;
 108     int panelWidth = getWidth();
 109     int charHeight = av.getCharHeight();
 110
 111     if ((searchResults != null) && searchResults.contains(s))
 112     {
 113       gg.setColor(Color.black);
 114       gg.fillRect(0, ((i - starty) * charHeight) + ypos, getWidth(),
 115               charHeight);
 116       gg.setColor(Color.white);
 117     }
 118     else if ((av.getSelectionGroup() != null)
 119             && av.getSelectionGroup().getSequences(null).contains(s))
 120     {
 121       gg.setColor(Color.lightGray);
 122       gg.fillRect(0, ((i - starty) * charHeight) + ypos, getWidth(),
 123               charHeight);
 124       gg.setColor(Color.white);
 125     }
 126     else
 127     {
 128       gg.setColor(av.getSequenceColour(s));
 129       gg.fillRect(0, ((i - starty) * charHeight) + ypos, getWidth(),
 130               charHeight);
 131       gg.setColor(Color.black);
 132     }
 133
 134     if (av.isRightAlignIds())
 135     {
 136       xPos = panelWidth
 137               - fm.stringWidth(s.getDisplayId(av.getShowJVSuffix())) - 4;
 138     }
 139
 140     gg.drawString(s.getDisplayId(av.getShowJVSuffix()), xPos,
 141             (((i - starty + 1) * charHeight) + ypos) - (charHeight / 5));
 142
 143     if (hiddenRows)
 144     {
 145       drawMarker(i, starty, ypos);
 146     }
 147
 148   }
 149
 150   /**
 151    * DOCUMENT ME!
 152    *
 153    * @param vertical
 154    *          DOCUMENT ME!
 155    */
 156   public void fastPaint(int vertical)
 157   {
 158     /*
 159      * for now, not attempting fast paint of wrapped ids...
 160      */
 161     if (gg == null || av.getWrapAlignment())
 162     {
 163       repaint();
 164
 165       return;
 166     }
 167
 168     ViewportRanges ranges = av.getRanges();
 169
 170     gg.copyArea(0, 0, getWidth(), imgHeight, 0,
 171             -vertical * av.getCharHeight());
 172
 173     int ss = ranges.getStartSeq();
 174     int es = ranges.getEndSeq();
 175     int transY = 0;
 176
 177     if (vertical > 0) // scroll down
 178     {
 179       ss = es - vertical;
 180
 181       if (ss < ranges.getStartSeq())
 182       { // ie scrolling too fast, more than a page at a time
 183         ss = ranges.getStartSeq();
 184       }
 185       else
 186       {
 187         transY = imgHeight - ((vertical + 1) * av.getCharHeight());
 188       }
 189     }
 190     else if (vertical < 0) // scroll up
 191     {
 192       es = ss - vertical;
 193
 194       if (es > ranges.getEndSeq())
 195       {
 196         es = ranges.getEndSeq();
 197       }
 198     }
 199
 200     gg.translate(0, transY);
 201
 202     drawIds(ss, es);
 203
 204     gg.translate(0, -transY);
 205
 206     fastPaint = true;
 207     repaint();
 208   }
 209
 210   /**
 211    * DOCUMENT ME!
 212    *
 213    * @param g
 214    *          DOCUMENT ME!
 215    */
 216   @Override
 217   public void paintComponent(Graphics g)
 218   {
 219     g.setColor(Color.white);
 220     g.fillRect(0, 0, getWidth(), getHeight());
 221
 222     if (fastPaint)
 223     {
 224       fastPaint = false;
 225       g.drawImage(image, 0, 0, this);
 226
 227       return;
 228     }
 229
 230     int oldHeight = imgHeight;
 231
 232     imgHeight = getHeight();
 233     imgHeight -= (imgHeight % av.getCharHeight());
 234
 235     if (imgHeight < 1)
 236     {
 237       return;
 238     }
 239
 240     if (oldHeight != imgHeight || image.getWidth(this) != getWidth())
 241     {
 242       image = new BufferedImage(getWidth(), imgHeight,
 243               BufferedImage.TYPE_INT_RGB);
 244     }
 245
 246     gg = (Graphics2D) image.getGraphics();
 247
 248     // Fill in the background
 249     gg.setColor(Color.white);
 250     gg.fillRect(0, 0, getWidth(), imgHeight);
 251
 252     drawIds(av.getRanges().getStartSeq(), av.getRanges().getEndSeq());
 253
 254     g.drawImage(image, 0, 0, this);
 255   }
 256
 257   /**
 258    * DOCUMENT ME!
 259    *
 260    * @param starty
 261    *          DOCUMENT ME!
 262    * @param endy
 263    *          DOCUMENT ME!
 264    */
 265   void drawIds(int starty, int endy)
 266   {
 267     if (av.isSeqNameItalics())
 268     {
 269       setIdfont(new Font(av.getFont().getName(), Font.ITALIC, av.getFont()
 270               .getSize()));
 271     }
 272     else
 273     {
 274       setIdfont(av.getFont());
 275     }
 276
 277     gg.setFont(getIdfont());
 278     fm = gg.getFontMetrics();
 279
 280     if (av.antiAlias)
 281     {
 282       gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 283               RenderingHints.VALUE_ANTIALIAS_ON);
 284     }
 285
 286     Color currentColor = Color.white;
 287     Color currentTextColor = Color.black;
 288
 289     boolean hasHiddenRows = av.hasHiddenRows();
 290
 291     if (av.getWrapAlignment())
 292     {
 293       drawIdsWrapped(starty, hasHiddenRows);
 294       return;
 295     }
 296
 297     // No need to hang on to labels if we're not wrapped
 298     labels = null;
 299
 300     // Now draw the id strings
 301     int panelWidth = getWidth();
 302     int xPos = 0;
 303
 304     SequenceI sequence;
 305     // Now draw the id strings
 306     for (int i = starty; i <= endy; i++)
 307     {
 308       sequence = av.getAlignment().getSequenceAt(i);
 309
 310       if (sequence == null)
 311       {
 312         continue;
 313       }
 314
 315       if (hasHiddenRows || av.isDisplayReferenceSeq())
 316       {
 317         setHiddenFont(sequence);
 318       }
 319
 320       // Selected sequence colours
 321       if ((searchResults != null) && searchResults.contains(sequence))
 322       {
 323         currentColor = Color.black;
 324         currentTextColor = Color.white;
 325       }
 326       else if ((av.getSelectionGroup() != null)
 327               && av.getSelectionGroup().getSequences(null)
 328                       .contains(sequence))
 329       {
 330         currentColor = Color.lightGray;
 331         currentTextColor = Color.black;
 332       }
 333       else
 334       {
 335         currentColor = av.getSequenceColour(sequence);
 336         currentTextColor = Color.black;
 337       }
 338
 339       gg.setColor(currentColor);
 340
 341       gg.fillRect(0, (i - starty) * av.getCharHeight(), getWidth(),
 342               av.getCharHeight());
 343
 344       gg.setColor(currentTextColor);
 345
 346       String string = sequence.getDisplayId(av.getShowJVSuffix());
 347
 348       if (av.isRightAlignIds())
 349       {
 350         xPos = panelWidth - fm.stringWidth(string) - 4;
 351       }
 352
 353       gg.drawString(string, xPos,
 354               (((i - starty) * av.getCharHeight()) + av.getCharHeight())
 355                       - (av.getCharHeight() / 5));
 356
 357       if (hasHiddenRows)
 358       {
 359         drawMarker(i, starty, 0);
 360       }
 361     }
 362   }
 363
 364   /**
 365    * Draws sequence ids in wrapped mode
 366    *
 367    * @param starty
 368    * @param hasHiddenRows
 369    */
 370   protected void drawIdsWrapped(int starty, boolean hasHiddenRows)
 371   {
 372     int maxwidth = av.getAlignment().getWidth();
 373     int alheight = av.getAlignment().getHeight();
 374
 375     if (av.hasHiddenColumns())
 376     {
 377       maxwidth = av.getAlignment().getHiddenColumns()
 378               .findColumnPosition(maxwidth) - 1;
 379     }
 380
 381     int annotationHeight = 0;
 382
 383     if (av.isShowAnnotation())
 384     {
 385       if (ap == null)
 386       {
 387         ap = new AnnotationPanel(av);
 388       }
 389
 390       annotationHeight = ap.adjustPanelHeight();
 391       if (labels == null)
 392       {
 393         labels = new AnnotationLabels(av);
 394       }
 395     }
 396
 397     int hgap = av.getCharHeight();
 398     if (av.getScaleAboveWrapped())
 399     {
 400       hgap += av.getCharHeight();
 401     }
 402
 403     int cHeight = alheight * av.getCharHeight() + hgap + annotationHeight;
 404
 405     ViewportRanges ranges = av.getRanges();
 406
 407     int rowSize = ranges.getViewportWidth();
 408
 409     /*
 410      * draw repeating sequence ids until out of sequence data or
 411      * out of visible space, whichever comes first
 412      */
 413     int ypos = hgap;
 414     int row = ranges.getStartRes();
 415     while ((ypos <= getHeight()) && (row < maxwidth))
 416     {
 417       for (int i = starty; i < alheight; i++)
 418       {
 419         SequenceI s = av.getAlignment().getSequenceAt(i);
 420         if (hasHiddenRows || av.isDisplayReferenceSeq())
 421         {
 422           setHiddenFont(s);
 423         }
 424         else
 425         {
 426           gg.setFont(getIdfont());
 427         }
 428
 429         drawIdString(gg, hasHiddenRows, s, i, 0, ypos);
 430       }
 431
 432       if (labels != null && av.isShowAnnotation())
 433       {
 434         gg.translate(0, ypos + (alheight * av.getCharHeight()));
 435         labels.drawComponent(gg, getWidth());
 436         gg.translate(0, -ypos - (alheight * av.getCharHeight()));
 437       }
 438
 439       ypos += cHeight;
 440       row += rowSize;
 441     }
 442   }
 443
 444   void drawMarker(int i, int starty, int yoffset)
 445   {
 446
 447     SequenceI[] hseqs = av.getAlignment().getHiddenSequences().hiddenSequences;
 448     // Use this method here instead of calling hiddenSeq adjust
 449     // 3 times.
 450     int hSize = hseqs.length;
 451
 452     int hiddenIndex = i;
 453     int lastIndex = i - 1;
 454     int nextIndex = i + 1;
 455
 456     for (int j = 0; j < hSize; j++)
 457     {
 458       if (hseqs[j] != null)
 459       {
 460         if (j - 1 < hiddenIndex)
 461         {
 462           hiddenIndex++;
 463         }
 464         if (j - 1 < lastIndex)
 465         {
 466           lastIndex++;
 467         }
 468         if (j - 1 < nextIndex)
 469         {
 470           nextIndex++;
 471         }
 472       }
 473     }
 474
 475     boolean below = (hiddenIndex > lastIndex + 1);
 476     boolean above = (nextIndex > hiddenIndex + 1);
 477
 478     gg.setColor(Color.blue);
 479     if (below)
 480     {
 481       gg.fillPolygon(
 482               new int[] { getWidth() - av.getCharHeight(),
 483                   getWidth() - av.getCharHeight(), getWidth() },
 484               new int[] {
 485                   (i - starty) * av.getCharHeight() + yoffset,
 486                   (i - starty) * av.getCharHeight() + yoffset
 487                           + av.getCharHeight() / 4,
 488                   (i - starty) * av.getCharHeight() + yoffset }, 3);
 489     }
 490     if (above)
 491     {
 492       gg.fillPolygon(
 493               new int[] { getWidth() - av.getCharHeight(),
 494                   getWidth() - av.getCharHeight(), getWidth() },
 495               new int[] {
 496                   (i - starty + 1) * av.getCharHeight() + yoffset,
 497                   (i - starty + 1) * av.getCharHeight() + yoffset
 498                           - av.getCharHeight() / 4,
 499                   (i - starty + 1) * av.getCharHeight() + yoffset }, 3);
 500
 501     }
 502   }
 503
 504   void setHiddenFont(SequenceI seq)
 505   {
 506     Font bold = new Font(av.getFont().getName(), Font.BOLD, av.getFont()
 507             .getSize());
 508
 509     if (av.isReferenceSeq(seq) || av.isHiddenRepSequence(seq))
 510     {
 511       gg.setFont(bold);
 512     }
 513     else
 514     {
 515       gg.setFont(getIdfont());
 516     }
 517   }
 518
 519   /**
 520    * DOCUMENT ME!
 521    *
 522    * @param list
 523    *          DOCUMENT ME!
 524    */
 525   public void setHighlighted(List<SequenceI> list)
 526   {
 527     searchResults = list;
 528     repaint();
 529   }
 530
 531   public Font getIdfont()
 532   {
 533     return idfont;
 534   }
 535
 536   public void setIdfont(Font idfont)
 537   {
 538     this.idfont = idfont;
 539   }
 540
 541   /**
 542    * Respond to viewport range changes (e.g. alignment panel was scrolled). Both
 543    * scrolling and resizing change viewport ranges. Scrolling changes both start
 544    * and end points, but resize only changes end values. Here we only want to
 545    * fastpaint on a scroll, with resize using a normal paint, so scroll events
 546    * are identified as changes to the horizontal or vertical start value.
 547    * <p>
 548    * In unwrapped mode, only responds to a vertical scroll, as horizontal scroll
 549    * leaves sequence ids unchanged. In wrapped mode, only vertical scroll is
 550    * provided, but it generates a change of "startres" which does require an
 551    * update here.
 552    */
 553   @Override
 554   public void propertyChange(PropertyChangeEvent evt)
 555   {
 556     String propertyName = evt.getPropertyName();
 557     if (propertyName.equals(ViewportRanges.STARTSEQ)
 558             || (av.getWrapAlignment() && propertyName
 559                     .equals(ViewportRanges.STARTRES)))
 560     {
 561       fastPaint((int) evt.getNewValue() - (int) evt.getOldValue());
 562     }
 563   }
 564 }