src/jalview/gui/AnnotationPanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 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.AlignmentAnnotation;
  24 import jalview.datamodel.Annotation;
  25 import jalview.datamodel.ColumnSelection;
  26 import jalview.datamodel.SequenceI;
  27 import jalview.renderer.AnnotationRenderer;
  28 import jalview.renderer.AwtRenderPanelI;
  29 import jalview.util.MessageManager;
  30
  31 import java.awt.AlphaComposite;
  32 import java.awt.Color;
  33 import java.awt.Dimension;
  34 import java.awt.FontMetrics;
  35 import java.awt.Graphics;
  36 import java.awt.Graphics2D;
  37 import java.awt.Image;
  38 import java.awt.Rectangle;
  39 import java.awt.RenderingHints;
  40 import java.awt.event.ActionEvent;
  41 import java.awt.event.ActionListener;
  42 import java.awt.event.AdjustmentEvent;
  43 import java.awt.event.AdjustmentListener;
  44 import java.awt.event.MouseEvent;
  45 import java.awt.event.MouseListener;
  46 import java.awt.event.MouseMotionListener;
  47 import java.awt.event.MouseWheelEvent;
  48 import java.awt.event.MouseWheelListener;
  49 import java.awt.image.BufferedImage;
  50
  51 import javax.swing.JColorChooser;
  52 import javax.swing.JMenuItem;
  53 import javax.swing.JOptionPane;
  54 import javax.swing.JPanel;
  55 import javax.swing.JPopupMenu;
  56 import javax.swing.Scrollable;
  57 import javax.swing.SwingUtilities;
  58 import javax.swing.ToolTipManager;
  59
  60 /**
  61  * AnnotationPanel displays visible portion of annotation rows below unwrapped
  62  * alignment
  63  *
  64  * @author $author$
  65  * @version $Revision$
  66  */
  67 public class AnnotationPanel extends JPanel implements AwtRenderPanelI,
  68         MouseListener, MouseWheelListener, MouseMotionListener,
  69         ActionListener, AdjustmentListener, Scrollable
  70 {
  71   String HELIX = MessageManager.getString("label.helix");
  72
  73   String SHEET = MessageManager.getString("label.sheet");
  74
  75   /**
  76    * For RNA secondary structure "stems" aka helices
  77    */
  78   String STEM = MessageManager.getString("label.rna_helix");
  79
  80   String LABEL = MessageManager.getString("label.label");
  81
  82   String REMOVE = MessageManager.getString("label.remove_annotation");
  83
  84   String COLOUR = MessageManager.getString("action.colour");
  85
  86   public final Color HELIX_COLOUR = Color.red.darker();
  87
  88   public final Color SHEET_COLOUR = Color.green.darker().darker();
  89
  90   public final Color STEM_COLOUR = Color.blue.darker();
  91
  92   /** DOCUMENT ME!! */
  93   public AlignViewport av;
  94
  95   AlignmentPanel ap;
  96
  97   public int activeRow = -1;
  98
  99   public BufferedImage image;
 100
 101   public volatile BufferedImage fadedImage;
 102
 103   Graphics2D gg;
 104
 105   public FontMetrics fm;
 106
 107   public int imgWidth = 0;
 108
 109   boolean fastPaint = false;
 110
 111   // Used For mouse Dragging and resizing graphs
 112   int graphStretch = -1;
 113
 114   int graphStretchY = -1;
 115
 116   int min; // used by mouseDragged to see if user
 117
 118   int max; // used by mouseDragged to see if user
 119
 120   boolean mouseDragging = false;
 121
 122   boolean MAC = false;
 123
 124   // for editing cursor
 125   int cursorX = 0;
 126
 127   int cursorY = 0;
 128
 129   public final AnnotationRenderer renderer;
 130
 131   private MouseWheelListener[] _mwl;
 132
 133   /**
 134    * Creates a new AnnotationPanel object.
 135    *
 136    * @param ap
 137    *          DOCUMENT ME!
 138    */
 139   public AnnotationPanel(AlignmentPanel ap)
 140   {
 141
 142     MAC = new jalview.util.Platform().isAMac();
 143
 144     ToolTipManager.sharedInstance().registerComponent(this);
 145     ToolTipManager.sharedInstance().setInitialDelay(0);
 146     ToolTipManager.sharedInstance().setDismissDelay(10000);
 147     this.ap = ap;
 148     av = ap.av;
 149     this.setLayout(null);
 150     addMouseListener(this);
 151     addMouseMotionListener(this);
 152     ap.annotationScroller.getVerticalScrollBar()
 153             .addAdjustmentListener(this);
 154     // save any wheel listeners on the scroller, so we can propagate scroll
 155     // events to them.
 156     _mwl = ap.annotationScroller.getMouseWheelListeners();
 157     // and then set our own listener to consume all mousewheel events
 158     ap.annotationScroller.addMouseWheelListener(this);
 159     renderer = new AnnotationRenderer();
 160   }
 161
 162   public AnnotationPanel(AlignViewport av)
 163   {
 164     this.av = av;
 165     renderer = new AnnotationRenderer();
 166   }
 167
 168   @Override
 169   public void mouseWheelMoved(MouseWheelEvent e)
 170   {
 171     if (e.isShiftDown())
 172     {
 173       e.consume();
 174       if (e.getWheelRotation() > 0)
 175       {
 176         ap.scrollRight(true);
 177       }
 178       else
 179       {
 180         ap.scrollRight(false);
 181       }
 182     }
 183     else
 184     {
 185       // TODO: find the correct way to let the event bubble up to
 186       // ap.annotationScroller
 187       for (MouseWheelListener mwl : _mwl)
 188       {
 189         if (mwl != null)
 190         {
 191           mwl.mouseWheelMoved(e);
 192         }
 193         if (e.isConsumed())
 194         {
 195           break;
 196         }
 197       }
 198     }
 199   }
 200
 201   @Override
 202   public Dimension getPreferredScrollableViewportSize()
 203   {
 204     return getPreferredSize();
 205   }
 206
 207   @Override
 208   public int getScrollableBlockIncrement(Rectangle visibleRect,
 209           int orientation, int direction)
 210   {
 211     return 30;
 212   }
 213
 214   @Override
 215   public boolean getScrollableTracksViewportHeight()
 216   {
 217     return false;
 218   }
 219
 220   @Override
 221   public boolean getScrollableTracksViewportWidth()
 222   {
 223     return true;
 224   }
 225
 226   @Override
 227   public int getScrollableUnitIncrement(Rectangle visibleRect,
 228           int orientation, int direction)
 229   {
 230     return 30;
 231   }
 232
 233   /*
 234    * (non-Javadoc)
 235    *
 236    * @see
 237    * java.awt.event.AdjustmentListener#adjustmentValueChanged(java.awt.event
 238    * .AdjustmentEvent)
 239    */
 240   @Override
 241   public void adjustmentValueChanged(AdjustmentEvent evt)
 242   {
 243     // update annotation label display
 244     ap.alabels.setScrollOffset(-evt.getValue());
 245   }
 246
 247   /**
 248    * Calculates the height of the annotation displayed in the annotation panel.
 249    * Callers should normally call the ap.adjustAnnotationHeight method to ensure
 250    * all annotation associated components are updated correctly.
 251    *
 252    */
 253   public int adjustPanelHeight()
 254   {
 255     int height = av.calcPanelHeight();
 256     this.setPreferredSize(new Dimension(1, height));
 257     if (ap != null)
 258     {
 259       // revalidate only when the alignment panel is fully constructed
 260       ap.validate();
 261     }
 262
 263     return height;
 264   }
 265
 266   /**
 267    * DOCUMENT ME!
 268    *
 269    * @param evt
 270    *          DOCUMENT ME!
 271    */
 272   @Override
 273   public void actionPerformed(ActionEvent evt)
 274   {
 275     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 276     if (aa == null)
 277     {
 278       return;
 279     }
 280     Annotation[] anot = aa[activeRow].annotations;
 281
 282     if (anot.length < av.getColumnSelection().getMax())
 283     {
 284       Annotation[] temp = new Annotation[av.getColumnSelection().getMax() + 2];
 285       System.arraycopy(anot, 0, temp, 0, anot.length);
 286       anot = temp;
 287       aa[activeRow].annotations = anot;
 288     }
 289
 290     if (evt.getActionCommand().equals(REMOVE))
 291     {
 292       for (int i = 0; i < av.getColumnSelection().size(); i++)
 293       {
 294         anot[av.getColumnSelection().columnAt(i)] = null;
 295       }
 296     }
 297     else if (evt.getActionCommand().equals(LABEL))
 298     {
 299       String exMesg = collectAnnotVals(anot, av.getColumnSelection(), LABEL);
 300       String label = JOptionPane.showInputDialog(this,
 301               MessageManager.getString("label.enter_label"), exMesg);
 302
 303       if (label == null)
 304       {
 305         return;
 306       }
 307
 308       if ((label.length() > 0) && !aa[activeRow].hasText)
 309       {
 310         aa[activeRow].hasText = true;
 311       }
 312
 313       for (int i = 0; i < av.getColumnSelection().size(); i++)
 314       {
 315         int index = av.getColumnSelection().columnAt(i);
 316
 317         if (!av.getColumnSelection().isVisible(index))
 318         {
 319           continue;
 320         }
 321
 322         if (anot[index] == null)
 323         {
 324           anot[index] = new Annotation(label, "", ' ', 0); // TODO: verify that
 325           // null exceptions
 326           // aren't raised
 327           // elsewhere.
 328         }
 329         else
 330         {
 331           anot[index].displayCharacter = label;
 332         }
 333       }
 334     }
 335     else if (evt.getActionCommand().equals(COLOUR))
 336     {
 337       Color col = JColorChooser.showDialog(this,
 338               MessageManager.getString("label.select_foreground_colour"), Color.black);
 339
 340       for (int i = 0; i < av.getColumnSelection().size(); i++)
 341       {
 342         int index = av.getColumnSelection().columnAt(i);
 343
 344         if (!av.getColumnSelection().isVisible(index))
 345         {
 346           continue;
 347         }
 348
 349         if (anot[index] == null)
 350         {
 351           anot[index] = new Annotation("", "", ' ', 0);
 352         }
 353
 354         anot[index].colour = col;
 355       }
 356     }
 357     else
 358     // HELIX OR SHEET
 359     {
 360       char type = 0;
 361       String symbol = "\u03B1";
 362
 363       if (evt.getActionCommand().equals(HELIX))
 364       {
 365         type = 'H';
 366       }
 367       else if (evt.getActionCommand().equals(SHEET))
 368       {
 369         type = 'E';
 370         symbol = "\u03B2";
 371       }
 372
 373       // Added by LML to color stems
 374       else if (evt.getActionCommand().equals(STEM))
 375       {
 376         type = 'S';
 377         symbol = "\u03C3";
 378       }
 379
 380       if (!aa[activeRow].hasIcons)
 381       {
 382         aa[activeRow].hasIcons = true;
 383       }
 384
 385       String label = JOptionPane.showInputDialog(MessageManager
 386               .getString("label.enter_label_for_the_structure"), symbol);
 387
 388       if (label == null)
 389       {
 390         return;
 391       }
 392
 393       if ((label.length() > 0) && !aa[activeRow].hasText)
 394       {
 395         aa[activeRow].hasText = true;
 396         if (evt.getActionCommand().equals(STEM))
 397         {
 398           aa[activeRow].showAllColLabels = true;
 399         }
 400       }
 401       for (int i = 0; i < av.getColumnSelection().size(); i++)
 402       {
 403         int index = av.getColumnSelection().columnAt(i);
 404
 405         if (!av.getColumnSelection().isVisible(index))
 406         {
 407           continue;
 408         }
 409
 410         if (anot[index] == null)
 411         {
 412           anot[index] = new Annotation(label, "", type, 0);
 413         }
 414
 415
 416         anot[index].secondaryStructure = type != 'S' ? type : label
 417                 .length() == 0 ? ' ' : label.charAt(0);
 418         anot[index].displayCharacter = label;
 419
 420       }
 421     }
 422     av.getAlignment().validateAnnotation(aa[activeRow]);
 423     ap.alignmentChanged();
 424
 425     adjustPanelHeight();
 426     repaint();
 427
 428     return;
 429   }
 430
 431   private String collectAnnotVals(Annotation[] anot,
 432           ColumnSelection columnSelection, String label2)
 433   {
 434     String collatedInput = "";
 435     String last = "";
 436     ColumnSelection viscols = av.getColumnSelection();
 437     // TODO: refactor and save av.getColumnSelection for efficiency
 438     for (int i = 0; i < columnSelection.size(); i++)
 439     {
 440       int index = columnSelection.columnAt(i);
 441       // always check for current display state - just in case
 442       if (!viscols.isVisible(index))
 443       {
 444         continue;
 445       }
 446       String tlabel = null;
 447       if (anot[index] != null)
 448       { // LML added stem code
 449         if (label2.equals(HELIX) || label2.equals(SHEET)
 450                 || label2.equals(STEM) || label2.equals(LABEL))
 451         {
 452           tlabel = anot[index].description;
 453           if (tlabel == null || tlabel.length() < 1)
 454           {
 455             if (label2.equals(HELIX) || label2.equals(SHEET)
 456                     || label2.equals(STEM))
 457             {
 458               tlabel = "" + anot[index].secondaryStructure;
 459             }
 460             else
 461             {
 462               tlabel = "" + anot[index].displayCharacter;
 463             }
 464           }
 465         }
 466         if (tlabel != null && !tlabel.equals(last))
 467         {
 468           if (last.length() > 0)
 469           {
 470             collatedInput += " ";
 471           }
 472           collatedInput += tlabel;
 473         }
 474       }
 475     }
 476     return collatedInput;
 477   }
 478
 479   /**
 480    * DOCUMENT ME!
 481    *
 482    * @param evt
 483    *          DOCUMENT ME!
 484    */
 485   @Override
 486   public void mousePressed(MouseEvent evt)
 487   {
 488
 489     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 490     if (aa == null)
 491     {
 492       return;
 493     }
 494
 495     int height = 0;
 496     activeRow = -1;
 497
 498     for (int i = 0; i < aa.length; i++)
 499     {
 500       if (aa[i].visible)
 501       {
 502         height += aa[i].height;
 503       }
 504
 505       if (evt.getY() < height)
 506       {
 507         if (aa[i].editable)
 508         {
 509           activeRow = i;
 510         }
 511         else if (aa[i].graph > 0)
 512         {
 513           // Stretch Graph
 514           graphStretch = i;
 515           graphStretchY = evt.getY();
 516         }
 517
 518         break;
 519       }
 520     }
 521
 522     if (SwingUtilities.isRightMouseButton(evt) && activeRow != -1)
 523     {
 524       if (av.getColumnSelection() == null)
 525       {
 526         return;
 527       }
 528
 529       JPopupMenu pop = new JPopupMenu(
 530               MessageManager.getString("label.structure_type"));
 531       JMenuItem item;
 532       /*
 533        * Just display the needed structure options
 534        */
 535       if (av.getAlignment().isNucleotide() == true)
 536       {
 537         item = new JMenuItem(STEM);
 538         item.addActionListener(this);
 539         pop.add(item);
 540       }
 541       else
 542       {
 543         item = new JMenuItem(HELIX);
 544         item.addActionListener(this);
 545         pop.add(item);
 546         item = new JMenuItem(SHEET);
 547         item.addActionListener(this);
 548         pop.add(item);
 549       }
 550       item = new JMenuItem(LABEL);
 551       item.addActionListener(this);
 552       pop.add(item);
 553       item = new JMenuItem(COLOUR);
 554       item.addActionListener(this);
 555       pop.add(item);
 556       item = new JMenuItem(REMOVE);
 557       item.addActionListener(this);
 558       pop.add(item);
 559       pop.show(this, evt.getX(), evt.getY());
 560
 561       return;
 562     }
 563
 564     if (aa == null)
 565     {
 566       return;
 567     }
 568
 569     ap.scalePanel.mousePressed(evt);
 570
 571   }
 572
 573   /**
 574    * DOCUMENT ME!
 575    *
 576    * @param evt
 577    *          DOCUMENT ME!
 578    */
 579   @Override
 580   public void mouseReleased(MouseEvent evt)
 581   {
 582     graphStretch = -1;
 583     graphStretchY = -1;
 584     mouseDragging = false;
 585     ap.scalePanel.mouseReleased(evt);
 586   }
 587
 588   /**
 589    * DOCUMENT ME!
 590    *
 591    * @param evt
 592    *          DOCUMENT ME!
 593    */
 594   @Override
 595   public void mouseEntered(MouseEvent evt)
 596   {
 597     ap.scalePanel.mouseEntered(evt);
 598   }
 599
 600   /**
 601    * DOCUMENT ME!
 602    *
 603    * @param evt
 604    *          DOCUMENT ME!
 605    */
 606   @Override
 607   public void mouseExited(MouseEvent evt)
 608   {
 609     ap.scalePanel.mouseExited(evt);
 610   }
 611
 612   /**
 613    * DOCUMENT ME!
 614    *
 615    * @param evt
 616    *          DOCUMENT ME!
 617    */
 618   @Override
 619   public void mouseDragged(MouseEvent evt)
 620   {
 621     if (graphStretch > -1)
 622     {
 623       av.getAlignment().getAlignmentAnnotation()[graphStretch].graphHeight += graphStretchY
 624               - evt.getY();
 625       if (av.getAlignment().getAlignmentAnnotation()[graphStretch].graphHeight < 0)
 626       {
 627         av.getAlignment().getAlignmentAnnotation()[graphStretch].graphHeight = 0;
 628       }
 629       graphStretchY = evt.getY();
 630       adjustPanelHeight();
 631       ap.paintAlignment(true);
 632     }
 633     else
 634     {
 635       ap.scalePanel.mouseDragged(evt);
 636     }
 637   }
 638
 639   /**
 640    * DOCUMENT ME!
 641    *
 642    * @param evt
 643    *          DOCUMENT ME!
 644    */
 645   @Override
 646   public void mouseMoved(MouseEvent evt)
 647   {
 648     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 649
 650     if (aa == null)
 651     {
 652       this.setToolTipText(null);
 653       return;
 654     }
 655
 656     int row = -1;
 657     int height = 0;
 658
 659     for (int i = 0; i < aa.length; i++)
 660     {
 661       if (aa[i].visible)
 662       {
 663         height += aa[i].height;
 664       }
 665
 666       if (evt.getY() < height)
 667       {
 668         row = i;
 669
 670         break;
 671       }
 672     }
 673
 674     if (row == -1)
 675     {
 676       this.setToolTipText(null);
 677       return;
 678     }
 679
 680     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 681
 682     if (av.hasHiddenColumns())
 683     {
 684       res = av.getColumnSelection().adjustForHiddenColumns(res);
 685     }
 686
 687     if (row > -1 && aa[row].annotations != null
 688             && res < aa[row].annotations.length)
 689     {
 690       if (aa[row].graphGroup > -1)
 691       {
 692         StringBuffer tip = new StringBuffer("<html>");
 693         for (int gg = 0; gg < aa.length; gg++)
 694         {
 695           if (aa[gg].graphGroup == aa[row].graphGroup
 696                   && aa[gg].annotations[res] != null)
 697           {
 698             tip.append(aa[gg].label + " "
 699                     + aa[gg].annotations[res].description + "<br>");
 700           }
 701         }
 702         if (tip.length() != 6)
 703         {
 704           tip.setLength(tip.length() - 4);
 705           this.setToolTipText(tip.toString() + "</html>");
 706         }
 707       }
 708       else if (aa[row].annotations[res] != null
 709               && aa[row].annotations[res].description != null
 710               && aa[row].annotations[res].description.length() > 0)
 711       {
 712         this.setToolTipText(JvSwingUtils
 713                         .wrapTooltip(true, aa[row].annotations[res].description));
 714       }
 715       else
 716       {
 717         // clear the tooltip.
 718         this.setToolTipText(null);
 719       }
 720
 721       if (aa[row].annotations[res] != null)
 722       {
 723         StringBuffer text = new StringBuffer("Sequence position "
 724                 + (res + 1));
 725
 726         if (aa[row].annotations[res].description != null)
 727         {
 728           text.append("  " + aa[row].annotations[res].description);
 729         }
 730
 731         ap.alignFrame.statusBar.setText(text.toString());
 732       }
 733     }
 734     else
 735     {
 736       this.setToolTipText(null);
 737     }
 738   }
 739
 740   /**
 741    * DOCUMENT ME!
 742    *
 743    * @param evt
 744    *          DOCUMENT ME!
 745    */
 746   @Override
 747   public void mouseClicked(MouseEvent evt)
 748   {
 749     // if (activeRow != -1)
 750     // {
 751     // AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 752     // AlignmentAnnotation anot = aa[activeRow];
 753     // }
 754   }
 755
 756   // TODO mouseClicked-content and drawCursor are quite experimental!
 757   public void drawCursor(Graphics graphics, SequenceI seq, int res, int x1,
 758           int y1)
 759   {
 760     int pady = av.charHeight / 5;
 761     int charOffset = 0;
 762     graphics.setColor(Color.black);
 763     graphics.fillRect(x1, y1, av.charWidth, av.charHeight);
 764
 765     if (av.validCharWidth)
 766     {
 767       graphics.setColor(Color.white);
 768
 769       char s = seq.getCharAt(res);
 770
 771       charOffset = (av.charWidth - fm.charWidth(s)) / 2;
 772       graphics.drawString(String.valueOf(s), charOffset + x1,
 773               (y1 + av.charHeight) - pady);
 774     }
 775
 776   }
 777
 778   private volatile boolean imageFresh = false;
 779
 780   /**
 781    * DOCUMENT ME!
 782    *
 783    * @param g
 784    *          DOCUMENT ME!
 785    */
 786   @Override
 787   public void paintComponent(Graphics g)
 788   {
 789     g.setColor(Color.white);
 790     g.fillRect(0, 0, getWidth(), getHeight());
 791
 792     if (image != null)
 793     {
 794       if (fastPaint || (getVisibleRect().width != g.getClipBounds().width)
 795               || (getVisibleRect().height != g.getClipBounds().height))
 796       {
 797         g.drawImage(image, 0, 0, this);
 798         fastPaint = false;
 799         return;
 800       }
 801     }
 802     imgWidth = (av.endRes - av.startRes + 1) * av.charWidth;
 803     if (imgWidth < 1)
 804     {
 805       return;
 806     }
 807     if (image == null || imgWidth != image.getWidth(this)
 808             || image.getHeight(this) != getHeight())
 809     {
 810       try
 811       {
 812         image = new BufferedImage(imgWidth, ap.annotationPanel.getHeight(),
 813                 BufferedImage.TYPE_INT_RGB);
 814       } catch (OutOfMemoryError oom)
 815       {
 816         try
 817         {
 818           System.gc();
 819         } catch (Exception x)
 820         {
 821         }
 822         ;
 823         new OOMWarning(
 824                 "Couldn't allocate memory to redraw screen. Please restart Jalview",
 825                 oom);
 826         return;
 827       }
 828       gg = (Graphics2D) image.getGraphics();
 829
 830       if (av.antiAlias)
 831       {
 832         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 833                 RenderingHints.VALUE_ANTIALIAS_ON);
 834       }
 835
 836       gg.setFont(av.getFont());
 837       fm = gg.getFontMetrics();
 838       gg.setColor(Color.white);
 839       gg.fillRect(0, 0, imgWidth, image.getHeight());
 840       imageFresh = true;
 841     }
 842
 843     drawComponent(gg, av.startRes, av.endRes + 1);
 844     imageFresh = false;
 845     g.drawImage(image, 0, 0, this);
 846   }
 847
 848   /**
 849    * set true to enable redraw timing debug output on stderr
 850    */
 851   private final boolean debugRedraw = false;
 852
 853   /**
 854    * non-Thread safe repaint
 855    *
 856    * @param horizontal
 857    *          repaint with horizontal shift in alignment
 858    */
 859   public void fastPaint(int horizontal)
 860   {
 861     if ((horizontal == 0) || gg == null
 862             || av.getAlignment().getAlignmentAnnotation() == null
 863             || av.getAlignment().getAlignmentAnnotation().length < 1
 864             || av.isCalcInProgress())
 865     {
 866       repaint();
 867       return;
 868     }
 869     long stime = System.currentTimeMillis();
 870     gg.copyArea(0, 0, imgWidth, getHeight(), -horizontal * av.charWidth, 0);
 871     long mtime = System.currentTimeMillis();
 872     int sr = av.startRes;
 873     int er = av.endRes + 1;
 874     int transX = 0;
 875
 876     if (horizontal > 0) // scrollbar pulled right, image to the left
 877     {
 878       transX = (er - sr - horizontal) * av.charWidth;
 879       sr = er - horizontal;
 880     }
 881     else if (horizontal < 0)
 882     {
 883       er = sr - horizontal;
 884     }
 885
 886     gg.translate(transX, 0);
 887
 888     drawComponent(gg, sr, er);
 889
 890     gg.translate(-transX, 0);
 891     long dtime = System.currentTimeMillis();
 892     fastPaint = true;
 893     repaint();
 894     long rtime = System.currentTimeMillis();
 895     if (debugRedraw)
 896     {
 897       System.err.println("Scroll:\t" + horizontal + "\tCopyArea:\t"
 898               + (mtime - stime) + "\tDraw component:\t" + (dtime - mtime)
 899               + "\tRepaint call:\t" + (rtime - dtime));
 900     }
 901
 902   }
 903
 904   private volatile boolean lastImageGood = false;
 905
 906   /**
 907    * DOCUMENT ME!
 908    *
 909    * @param g
 910    *          DOCUMENT ME!
 911    * @param startRes
 912    *          DOCUMENT ME!
 913    * @param endRes
 914    *          DOCUMENT ME!
 915    */
 916   public void drawComponent(Graphics g, int startRes, int endRes)
 917   {
 918     BufferedImage oldFaded = fadedImage;
 919     if (av.isCalcInProgress())
 920     {
 921       if (image == null)
 922       {
 923         lastImageGood = false;
 924         return;
 925       }
 926       // We'll keep a record of the old image,
 927       // and draw a faded image until the calculation
 928       // has completed
 929       if (lastImageGood
 930               && (fadedImage == null || fadedImage.getWidth() != imgWidth || fadedImage
 931                       .getHeight() != image.getHeight()))
 932       {
 933         // System.err.println("redraw faded image ("+(fadedImage==null ?
 934         // "null image" : "") + " lastGood="+lastImageGood+")");
 935         fadedImage = new BufferedImage(imgWidth, image.getHeight(),
 936                 BufferedImage.TYPE_INT_RGB);
 937
 938         Graphics2D fadedG = (Graphics2D) fadedImage.getGraphics();
 939
 940         fadedG.setColor(Color.white);
 941         fadedG.fillRect(0, 0, imgWidth, image.getHeight());
 942
 943         fadedG.setComposite(AlphaComposite.getInstance(
 944                 AlphaComposite.SRC_OVER, .3f));
 945         fadedG.drawImage(image, 0, 0, this);
 946
 947       }
 948       // make sure we don't overwrite the last good faded image until all
 949       // calculations have finished
 950       lastImageGood = false;
 951
 952     }
 953     else
 954     {
 955       if (fadedImage != null)
 956       {
 957         oldFaded = fadedImage;
 958       }
 959       fadedImage = null;
 960     }
 961
 962     g.setColor(Color.white);
 963     g.fillRect(0, 0, (endRes - startRes) * av.charWidth, getHeight());
 964
 965     g.setFont(av.getFont());
 966     if (fm == null)
 967     {
 968       fm = g.getFontMetrics();
 969     }
 970
 971     if ((av.getAlignment().getAlignmentAnnotation() == null)
 972             || (av.getAlignment().getAlignmentAnnotation().length < 1))
 973     {
 974       g.setColor(Color.white);
 975       g.fillRect(0, 0, getWidth(), getHeight());
 976       g.setColor(Color.black);
 977       if (av.validCharWidth)
 978       {
 979         g.drawString(MessageManager
 980                 .getString("label.alignment_has_no_annotations"), 20, 15);
 981       }
 982
 983       return;
 984     }
 985     lastImageGood = renderer.drawComponent(this, av, g, activeRow,
 986             startRes, endRes);
 987     if (!lastImageGood && fadedImage == null)
 988     {
 989       fadedImage = oldFaded;
 990     }
 991   }
 992
 993   @Override
 994   public FontMetrics getFontMetrics()
 995   {
 996     return fm;
 997   }
 998
 999   @Override
1000   public Image getFadedImage()
1001   {
1002     return fadedImage;
1003   }
1004
1005   @Override
1006   public int getFadedImageWidth()
1007   {
1008     return imgWidth;
1009   }
1010
1011   private int[] bounds = new int[2];
1012
1013   @Override
1014   public int[] getVisibleVRange()
1015   {
1016     if (ap != null && ap.alabels != null)
1017     {
1018       int sOffset = -ap.alabels.scrollOffset;
1019       int visHeight = sOffset + ap.annotationSpaceFillerHolder.getHeight();
1020       bounds[0] = sOffset;
1021       bounds[1] = visHeight;
1022       return bounds;
1023     }
1024     else
1025     {
1026       return null;
1027     }
1028   }
1029 }