src/jalview/gui/AnnotationPanel.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.AlignmentAnnotation;
  24 import jalview.datamodel.AlignmentI;
  25 import jalview.datamodel.Annotation;
  26 import jalview.datamodel.ColumnSelection;
  27 import jalview.datamodel.HiddenColumns;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.gui.JalviewColourChooser.ColourChooserListener;
  30 import jalview.renderer.AnnotationRenderer;
  31 import jalview.renderer.AwtRenderPanelI;
  32 import jalview.schemes.ResidueProperties;
  33 import jalview.util.Comparison;
  34 import jalview.util.MessageManager;
  35 import jalview.util.Platform;
  36 import jalview.viewmodel.ViewportListenerI;
  37 import jalview.viewmodel.ViewportRanges;
  38
  39 import java.awt.AlphaComposite;
  40 import java.awt.Color;
  41 import java.awt.Dimension;
  42 import java.awt.FontMetrics;
  43 import java.awt.Graphics;
  44 import java.awt.Graphics2D;
  45 import java.awt.Image;
  46 import java.awt.Rectangle;
  47 import java.awt.RenderingHints;
  48 import java.awt.event.ActionEvent;
  49 import java.awt.event.ActionListener;
  50 import java.awt.event.AdjustmentEvent;
  51 import java.awt.event.AdjustmentListener;
  52 import java.awt.event.MouseEvent;
  53 import java.awt.event.MouseListener;
  54 import java.awt.event.MouseMotionListener;
  55 import java.awt.event.MouseWheelEvent;
  56 import java.awt.event.MouseWheelListener;
  57 import java.awt.image.BufferedImage;
  58 import java.beans.PropertyChangeEvent;
  59 import java.util.ArrayList;
  60 import java.util.Collections;
  61 import java.util.List;
  62
  63 import javax.swing.JMenuItem;
  64 import javax.swing.JPanel;
  65 import javax.swing.JPopupMenu;
  66 import javax.swing.Scrollable;
  67 import javax.swing.ToolTipManager;
  68
  69 /**
  70  * AnnotationPanel displays visible portion of annotation rows below unwrapped
  71  * alignment
  72  *
  73  * @author $author$
  74  * @version $Revision$
  75  */
  76 public class AnnotationPanel extends JPanel implements AwtRenderPanelI,
  77         MouseListener, MouseWheelListener, MouseMotionListener,
  78         ActionListener, AdjustmentListener, Scrollable, ViewportListenerI
  79 {
  80   enum DragMode
  81   {
  82     Select, Resize, Undefined
  83   };
  84
  85   String HELIX = MessageManager.getString("label.helix");
  86
  87   String SHEET = MessageManager.getString("label.sheet");
  88
  89   /**
  90    * For RNA secondary structure "stems" aka helices
  91    */
  92   String STEM = MessageManager.getString("label.rna_helix");
  93
  94   String LABEL = MessageManager.getString("label.label");
  95
  96   String REMOVE = MessageManager.getString("label.remove_annotation");
  97
  98   String COLOUR = MessageManager.getString("action.colour");
  99
 100   public final Color HELIX_COLOUR = Color.red.darker();
 101
 102   public final Color SHEET_COLOUR = Color.green.darker().darker();
 103
 104   public final Color STEM_COLOUR = Color.blue.darker();
 105
 106   /** DOCUMENT ME!! */
 107   public AlignViewport av;
 108
 109   AlignmentPanel ap;
 110
 111   public int activeRow = -1;
 112
 113   public BufferedImage image;
 114
 115   public volatile BufferedImage fadedImage;
 116
 117   // private Graphics2D gg;
 118
 119   public FontMetrics fm;
 120
 121   public int imgWidth = 0;
 122
 123   boolean fastPaint = false;
 124
 125   // Used For mouse Dragging and resizing graphs
 126   int graphStretch = -1;
 127
 128   int mouseDragLastX = -1;
 129
 130   int mouseDragLastY = -1;
 131
 132   DragMode dragMode = DragMode.Undefined;
 133
 134   boolean mouseDragging = false;
 135
 136   // for editing cursor
 137   int cursorX = 0;
 138
 139   int cursorY = 0;
 140
 141   public final AnnotationRenderer renderer;
 142
 143   private MouseWheelListener[] _mwl;
 144
 145   /**
 146    * Creates a new AnnotationPanel object.
 147    *
 148    * @param ap
 149    *          DOCUMENT ME!
 150    */
 151   public AnnotationPanel(AlignmentPanel ap)
 152   {
 153     ToolTipManager.sharedInstance().registerComponent(this);
 154     ToolTipManager.sharedInstance().setInitialDelay(0);
 155     ToolTipManager.sharedInstance().setDismissDelay(10000);
 156     this.ap = ap;
 157     av = ap.av;
 158     this.setLayout(null);
 159     addMouseListener(this);
 160     addMouseMotionListener(this);
 161     ap.annotationScroller.getVerticalScrollBar()
 162             .addAdjustmentListener(this);
 163     // save any wheel listeners on the scroller, so we can propagate scroll
 164     // events to them.
 165     _mwl = ap.annotationScroller.getMouseWheelListeners();
 166     // and then set our own listener to consume all mousewheel events
 167     ap.annotationScroller.addMouseWheelListener(this);
 168     renderer = new AnnotationRenderer();
 169
 170     av.getRanges().addPropertyChangeListener(this);
 171   }
 172
 173   public AnnotationPanel(AlignViewport av)
 174   {
 175     this.av = av;
 176     renderer = new AnnotationRenderer();
 177   }
 178
 179   @Override
 180   public void mouseWheelMoved(MouseWheelEvent e)
 181   {
 182     if (e.isShiftDown())
 183     {
 184       e.consume();
 185       double wheelRotation = e.getPreciseWheelRotation();
 186       if (wheelRotation > 0)
 187       {
 188         av.getRanges().scrollRight(true);
 189       }
 190       else if (wheelRotation < 0)
 191       {
 192         av.getRanges().scrollRight(false);
 193       }
 194     }
 195     else
 196     {
 197       // TODO: find the correct way to let the event bubble up to
 198       // ap.annotationScroller
 199       for (MouseWheelListener mwl : _mwl)
 200       {
 201         if (mwl != null)
 202         {
 203           mwl.mouseWheelMoved(e);
 204         }
 205         if (e.isConsumed())
 206         {
 207           break;
 208         }
 209       }
 210     }
 211   }
 212
 213   @Override
 214   public Dimension getPreferredScrollableViewportSize()
 215   {
 216     Dimension ps = getPreferredSize();
 217     return new Dimension(ps.width, adjustForAlignFrame(false, ps.height));
 218   }
 219
 220   @Override
 221   public int getScrollableBlockIncrement(Rectangle visibleRect,
 222           int orientation, int direction)
 223   {
 224     return 30;
 225   }
 226
 227   @Override
 228   public boolean getScrollableTracksViewportHeight()
 229   {
 230     return false;
 231   }
 232
 233   @Override
 234   public boolean getScrollableTracksViewportWidth()
 235   {
 236     return true;
 237   }
 238
 239   @Override
 240   public int getScrollableUnitIncrement(Rectangle visibleRect,
 241           int orientation, int direction)
 242   {
 243     return 30;
 244   }
 245
 246   /*
 247    * (non-Javadoc)
 248    *
 249    * @see
 250    * java.awt.event.AdjustmentListener#adjustmentValueChanged(java.awt.event
 251    * .AdjustmentEvent)
 252    */
 253   @Override
 254   public void adjustmentValueChanged(AdjustmentEvent evt)
 255   {
 256     // update annotation label display
 257     ap.getAlabels().setScrollOffset(-evt.getValue());
 258   }
 259
 260   /**
 261    * Calculates the height of the annotation displayed in the annotation panel.
 262    * Callers should normally call the ap.adjustAnnotationHeight method to ensure
 263    * all annotation associated components are updated correctly.
 264    *
 265    */
 266   public int adjustPanelHeight()
 267   {
 268     int height = av.calcPanelHeight();
 269     this.setPreferredSize(new Dimension(1, height));
 270     if (ap != null)
 271     {
 272       // revalidate only when the alignment panel is fully constructed
 273       ap.validate();
 274     }
 275
 276     return height;
 277   }
 278
 279   /**
 280    * DOCUMENT ME!
 281    *
 282    * @param evt
 283    *          DOCUMENT ME!
 284    */
 285   @Override
 286   public void actionPerformed(ActionEvent evt)
 287   {
 288     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 289     if (aa == null)
 290     {
 291       return;
 292     }
 293     Annotation[] anot = aa[activeRow].annotations;
 294
 295     if (anot.length < av.getColumnSelection().getMax())
 296     {
 297       Annotation[] temp = new Annotation[av.getColumnSelection().getMax()
 298               + 2];
 299       System.arraycopy(anot, 0, temp, 0, anot.length);
 300       anot = temp;
 301       aa[activeRow].annotations = anot;
 302     }
 303
 304     String action = evt.getActionCommand();
 305     if (action.equals(REMOVE))
 306     {
 307       for (int index : av.getColumnSelection().getSelected())
 308       {
 309         if (av.getAlignment().getHiddenColumns().isVisible(index))
 310         {
 311           anot[index] = null;
 312         }
 313       }
 314     }
 315     else if (action.equals(LABEL))
 316     {
 317       String exMesg = collectAnnotVals(anot, LABEL);
 318       String label = JvOptionPane.showInputDialog(
 319               MessageManager.getString("label.enter_label"), exMesg);
 320
 321       if (label == null)
 322       {
 323         return;
 324       }
 325
 326       if ((label.length() > 0) && !aa[activeRow].hasText)
 327       {
 328         aa[activeRow].hasText = true;
 329       }
 330
 331       for (int index : av.getColumnSelection().getSelected())
 332       {
 333         if (!av.getAlignment().getHiddenColumns().isVisible(index))
 334         {
 335           continue;
 336         }
 337
 338         if (anot[index] == null)
 339         {
 340           anot[index] = new Annotation(label, "", ' ', 0);
 341         }
 342         else
 343         {
 344           anot[index].displayCharacter = label;
 345         }
 346       }
 347     }
 348     else if (action.equals(COLOUR))
 349     {
 350       final Annotation[] fAnot = anot;
 351       String title = MessageManager
 352               .getString("label.select_foreground_colour");
 353       ColourChooserListener listener = new ColourChooserListener()
 354       {
 355         @Override
 356         public void colourSelected(Color c)
 357         {
 358           HiddenColumns hiddenColumns = av.getAlignment().getHiddenColumns();
 359           for (int index : av.getColumnSelection().getSelected())
 360           {
 361             if (hiddenColumns.isVisible(index))
 362             {
 363               if (fAnot[index] == null)
 364               {
 365                 fAnot[index] = new Annotation("", "", ' ', 0);
 366               }
 367               fAnot[index].colour = c;
 368             }
 369         }};
 370       };
 371       JalviewColourChooser.showColourChooser(this,
 372               title, Color.black, listener);
 373     }
 374     else
 375     // HELIX, SHEET or STEM
 376     {
 377       char type = 0;
 378       String symbol = "\u03B1"; // alpha
 379
 380       if (action.equals(HELIX))
 381       {
 382         type = 'H';
 383       }
 384       else if (action.equals(SHEET))
 385       {
 386         type = 'E';
 387         symbol = "\u03B2"; // beta
 388       }
 389
 390       // Added by LML to color stems
 391       else if (action.equals(STEM))
 392       {
 393         type = 'S';
 394         int column = av.getColumnSelection().getSelectedRanges().get(0)[0];
 395         symbol = aa[activeRow].getDefaultRnaHelixSymbol(column);
 396       }
 397
 398       if (!aa[activeRow].hasIcons)
 399       {
 400         aa[activeRow].hasIcons = true;
 401       }
 402
 403       String label = JvOptionPane.showInputDialog(MessageManager
 404               .getString("label.enter_label_for_the_structure"), symbol);
 405
 406       if (label == null)
 407       {
 408         return;
 409       }
 410
 411       if ((label.length() > 0) && !aa[activeRow].hasText)
 412       {
 413         aa[activeRow].hasText = true;
 414         if (action.equals(STEM))
 415         {
 416           aa[activeRow].showAllColLabels = true;
 417         }
 418       }
 419       for (int index : av.getColumnSelection().getSelected())
 420       {
 421         if (!av.getAlignment().getHiddenColumns().isVisible(index))
 422         {
 423           continue;
 424         }
 425
 426         if (anot[index] == null)
 427         {
 428           anot[index] = new Annotation(label, "", type, 0);
 429         }
 430
 431         anot[index].secondaryStructure = type != 'S' ? type
 432                 : label.length() == 0 ? ' ' : label.charAt(0);
 433         anot[index].displayCharacter = label;
 434
 435       }
 436     }
 437
 438     av.getAlignment().validateAnnotation(aa[activeRow]);
 439     ap.alignmentChanged();
 440     ap.alignFrame.setMenusForViewport();
 441     adjustPanelHeight();
 442     repaint();
 443
 444     return;
 445   }
 446
 447   /**
 448    * Returns any existing annotation concatenated as a string. For each
 449    * annotation, takes the description, if any, else the secondary structure
 450    * character (if type is HELIX, SHEET or STEM), else the display character (if
 451    * type is LABEL).
 452    *
 453    * @param anots
 454    * @param type
 455    * @return
 456    */
 457   private String collectAnnotVals(Annotation[] anots, String type)
 458   {
 459     // TODO is this method wanted? why? 'last' is not used
 460
 461     StringBuilder collatedInput = new StringBuilder(64);
 462     String last = "";
 463     ColumnSelection viscols = av.getColumnSelection();
 464     HiddenColumns hidden = av.getAlignment().getHiddenColumns();
 465
 466     /*
 467      * the selection list (read-only view) is in selection order, not
 468      * column order; make a copy so we can sort it
 469      */
 470     List<Integer> selected = new ArrayList<>(viscols.getSelected());
 471     Collections.sort(selected);
 472     for (int index : selected)
 473     {
 474       // always check for current display state - just in case
 475       if (!hidden.isVisible(index))
 476       {
 477         continue;
 478       }
 479       String tlabel = null;
 480       if (anots[index] != null)
 481       { // LML added stem code
 482         if (type.equals(HELIX) || type.equals(SHEET) || type.equals(STEM)
 483                 || type.equals(LABEL))
 484         {
 485           tlabel = anots[index].description;
 486           if (tlabel == null || tlabel.length() < 1)
 487           {
 488             if (type.equals(HELIX) || type.equals(SHEET)
 489                     || type.equals(STEM))
 490             {
 491               tlabel = "" + anots[index].secondaryStructure;
 492             }
 493             else
 494             {
 495               tlabel = "" + anots[index].displayCharacter;
 496             }
 497           }
 498         }
 499         if (tlabel != null && !tlabel.equals(last))
 500         {
 501           if (last.length() > 0)
 502           {
 503             collatedInput.append(" ");
 504           }
 505           collatedInput.append(tlabel);
 506         }
 507       }
 508     }
 509     return collatedInput.toString();
 510   }
 511
 512   /**
 513    * Action on right mouse pressed on Mac is to show a pop-up menu for the
 514    * annotation. Action on left mouse pressed is to find which annotation is
 515    * pressed and mark the start of a column selection or graph resize operation.
 516    *
 517    * @param evt
 518    */
 519   @Override
 520   public void mousePressed(MouseEvent evt)
 521   {
 522
 523     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 524     if (aa == null)
 525     {
 526       return;
 527     }
 528     mouseDragLastX = evt.getX();
 529     mouseDragLastY = evt.getY();
 530
 531     /*
 532      * add visible annotation heights until we reach the y
 533      * position, to find which annotation it is in
 534      */
 535     int height = 0;
 536     activeRow = -1;
 537
 538     final int y = evt.getY();
 539     for (int i = 0; i < aa.length; i++)
 540     {
 541       if (aa[i].visible)
 542       {
 543         height += aa[i].height;
 544       }
 545
 546       if (y < height)
 547       {
 548         if (aa[i].editable)
 549         {
 550           activeRow = i;
 551         }
 552         else if (aa[i].graph > 0)
 553         {
 554           /*
 555            * we have clicked on a resizable graph annotation
 556            */
 557           graphStretch = i;
 558         }
 559         break;
 560       }
 561     }
 562
 563     /*
 564      * isPopupTrigger fires in mousePressed on Mac,
 565      * not until mouseRelease on Windows
 566      */
 567     if (evt.isPopupTrigger() && activeRow != -1)
 568     {
 569       showPopupMenu(y, evt.getX());
 570       return;
 571     }
 572
 573     ap.getScalePanel().mousePressed(evt);
 574   }
 575
 576   /**
 577    * Construct and display a context menu at the right-click position
 578    *
 579    * @param y
 580    * @param x
 581    */
 582   void showPopupMenu(final int y, int x)
 583   {
 584     if (av.getColumnSelection() == null
 585             || av.getColumnSelection().isEmpty())
 586     {
 587       return;
 588     }
 589
 590     JPopupMenu pop = new JPopupMenu(
 591             MessageManager.getString("label.structure_type"));
 592     JMenuItem item;
 593     /*
 594      * Just display the needed structure options
 595      */
 596     if (av.getAlignment().isNucleotide())
 597     {
 598       item = new JMenuItem(STEM);
 599       item.addActionListener(this);
 600       pop.add(item);
 601     }
 602     else
 603     {
 604       item = new JMenuItem(HELIX);
 605       item.addActionListener(this);
 606       pop.add(item);
 607       item = new JMenuItem(SHEET);
 608       item.addActionListener(this);
 609       pop.add(item);
 610     }
 611     item = new JMenuItem(LABEL);
 612     item.addActionListener(this);
 613     pop.add(item);
 614     item = new JMenuItem(COLOUR);
 615     item.addActionListener(this);
 616     pop.add(item);
 617     item = new JMenuItem(REMOVE);
 618     item.addActionListener(this);
 619     pop.add(item);
 620     pop.show(this, x, y);
 621   }
 622
 623   /**
 624    * Action on mouse up is to clear mouse drag data and call mouseReleased on
 625    * ScalePanel, to deal with defining the selection group (if any) defined by
 626    * the mouse drag
 627    *
 628    * @param evt
 629    */
 630   @Override
 631   public void mouseReleased(MouseEvent evt)
 632   {
 633     graphStretch = -1;
 634     mouseDragLastX = -1;
 635     mouseDragLastY = -1;
 636     mouseDragging = false;
 637     dragMode = DragMode.Undefined;
 638     ap.getScalePanel().mouseReleased(evt);
 639
 640     /*
 641      * isPopupTrigger is set in mouseReleased on Windows
 642      * (in mousePressed on Mac)
 643      */
 644     if (evt.isPopupTrigger() && activeRow != -1)
 645     {
 646       showPopupMenu(evt.getY(), evt.getX());
 647     }
 648
 649   }
 650
 651   /**
 652    * DOCUMENT ME!
 653    *
 654    * @param evt
 655    *          DOCUMENT ME!
 656    */
 657   @Override
 658   public void mouseEntered(MouseEvent evt)
 659   {
 660     this.mouseDragging = false;
 661     ap.getScalePanel().mouseEntered(evt);
 662   }
 663
 664   /**
 665    * On leaving the panel, calls ScalePanel.mouseExited to deal with scrolling
 666    * with column selection on a mouse drag
 667    *
 668    * @param evt
 669    */
 670   @Override
 671   public void mouseExited(MouseEvent evt)
 672   {
 673     ap.getScalePanel().mouseExited(evt);
 674   }
 675
 676   /**
 677    * DOCUMENT ME!
 678    *
 679    * @param evt
 680    *          DOCUMENT ME!
 681    */
 682   @Override
 683   public void mouseDragged(MouseEvent evt)
 684   {
 685     /*
 686      * todo: if dragMode is Undefined:
 687      * - set to Select if dx > dy
 688      * - set to Resize if dy > dx
 689      * - do nothing if dx == dy
 690      */
 691     final int x = evt.getX();
 692     final int y = evt.getY();
 693     if (dragMode == DragMode.Undefined)
 694     {
 695       int dx = Math.abs(x - mouseDragLastX);
 696       int dy = Math.abs(y - mouseDragLastY);
 697       if (graphStretch == -1 || dx > dy)
 698       {
 699         /*
 700          * mostly horizontal drag, or not a graph annotation
 701          */
 702         dragMode = DragMode.Select;
 703       }
 704       else if (dy > dx)
 705       {
 706         /*
 707          * mostly vertical drag
 708          */
 709         dragMode = DragMode.Resize;
 710       }
 711     }
 712
 713     if (dragMode == DragMode.Undefined)
 714     {
 715       /*
 716        * drag is diagonal - defer deciding whether to
 717        * treat as up/down or left/right
 718        */
 719       return;
 720     }
 721
 722     try
 723     {
 724       if (dragMode == DragMode.Resize)
 725       {
 726         /*
 727          * resize graph annotation if mouse was dragged up or down
 728          */
 729         int deltaY = mouseDragLastY - evt.getY();
 730         if (deltaY != 0)
 731         {
 732           AlignmentAnnotation graphAnnotation = av.getAlignment()
 733                   .getAlignmentAnnotation()[graphStretch];
 734           int newHeight = Math.max(0, graphAnnotation.graphHeight + deltaY);
 735           graphAnnotation.graphHeight = newHeight;
 736           adjustPanelHeight();
 737           ap.paintAlignment(false, false);
 738         }
 739       }
 740       else
 741       {
 742         /*
 743          * for mouse drag left or right, delegate to
 744          * ScalePanel to adjust the column selection
 745          */
 746         ap.getScalePanel().mouseDragged(evt);
 747       }
 748     } finally
 749     {
 750       mouseDragLastX = x;
 751       mouseDragLastY = y;
 752     }
 753   }
 754
 755   /**
 756    * Constructs the tooltip, and constructs and displays a status message, for
 757    * the current mouse position
 758    *
 759    * @param evt
 760    */
 761   @Override
 762   public void mouseMoved(MouseEvent evt)
 763   {
 764     int yPos = evt.getY();
 765     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 766
 767     int row = getRowIndex(yPos, aa);
 768
 769     if (row == -1)
 770     {
 771       this.setToolTipText(null);
 772       return;
 773     }
 774
 775     int column = (evt.getX() / av.getCharWidth())
 776             + av.getRanges().getStartRes();
 777     column = Math.min(column, av.getRanges().getEndRes());
 778
 779     if (av.hasHiddenColumns())
 780     {
 781       column = av.getAlignment().getHiddenColumns()
 782               .visibleToAbsoluteColumn(column);
 783     }
 784
 785     AlignmentAnnotation ann = aa[row];
 786     if (row > -1 && ann.annotations != null
 787             && column < ann.annotations.length)
 788     {
 789       setToolTipText(buildToolTip(ann, column, aa));
 790       String msg = getStatusMessage(av.getAlignment(), column, ann);
 791       ap.alignFrame.setStatus(msg);
 792     }
 793     else
 794     {
 795       this.setToolTipText(null);
 796       ap.alignFrame.setStatus(" ");
 797     }
 798   }
 799
 800   /**
 801    * Answers the index in the annotations array of the visible annotation at the
 802    * given y position. This is done by adding the heights of visible annotations
 803    * until the y position has been exceeded. Answers -1 if no annotations are
 804    * visible, or the y position is below all annotations.
 805    *
 806    * @param yPos
 807    * @param aa
 808    * @return
 809    */
 810   static int getRowIndex(int yPos, AlignmentAnnotation[] aa)
 811   {
 812     if (aa == null)
 813     {
 814       return -1;
 815     }
 816     int row = -1;
 817     int height = 0;
 818
 819     for (int i = 0; i < aa.length; i++)
 820     {
 821       if (aa[i].visible)
 822       {
 823         height += aa[i].height;
 824       }
 825
 826       if (height > yPos)
 827       {
 828         row = i;
 829         break;
 830       }
 831     }
 832     return row;
 833   }
 834
 835   /**
 836    * Answers a tooltip for the annotation at the current mouse position
 837    *
 838    * @param ann
 839    * @param column
 840    * @param anns
 841    */
 842   static String buildToolTip(AlignmentAnnotation ann, int column,
 843           AlignmentAnnotation[] anns)
 844   {
 845     String tooltip = null;
 846     if (ann.graphGroup > -1)
 847     {
 848       StringBuilder tip = new StringBuilder(32);
 849       tip.append("<html>");
 850       for (int i = 0; i < anns.length; i++)
 851       {
 852         if (anns[i].graphGroup == ann.graphGroup
 853                 && anns[i].annotations[column] != null)
 854         {
 855           tip.append(anns[i].label);
 856           String description = anns[i].annotations[column].description;
 857           if (description != null && description.length() > 0)
 858           {
 859             tip.append(" ").append(description);
 860           }
 861           tip.append("<br>");
 862         }
 863       }
 864       if (tip.length() != 6)
 865       {
 866         tip.setLength(tip.length() - 4);
 867         tooltip = tip.toString() + "</html>";
 868       }
 869     }
 870     else if (column < ann.annotations.length
 871             && ann.annotations[column] != null)
 872     {
 873       String description = ann.annotations[column].description;
 874       if (description != null && description.length() > 0)
 875       {
 876         tooltip = JvSwingUtils.wrapTooltip(true, description);
 877       }
 878       else
 879       {
 880         tooltip = null; // no tooltip if null or empty description
 881       }
 882     }
 883     else
 884     {
 885       // clear the tooltip.
 886       tooltip = null;
 887     }
 888     return tooltip;
 889   }
 890
 891   /**
 892    * Constructs and returns the status bar message
 893    *
 894    * @param al
 895    * @param column
 896    * @param ann
 897    */
 898   static String getStatusMessage(AlignmentI al, int column,
 899           AlignmentAnnotation ann)
 900   {
 901     /*
 902      * show alignment column and annotation description if any
 903      */
 904     StringBuilder text = new StringBuilder(32);
 905     text.append(MessageManager.getString("label.column")).append(" ")
 906             .append(column + 1);
 907
 908     if (column < ann.annotations.length && ann.annotations[column] != null)
 909     {
 910       String description = ann.annotations[column].description;
 911       if (description != null && description.trim().length() > 0)
 912       {
 913         text.append("  ").append(description);
 914       }
 915     }
 916
 917     /*
 918      * if the annotation is sequence-specific, show the sequence number
 919      * in the alignment, and (if not a gap) the residue and position
 920      */
 921     SequenceI seqref = ann.sequenceRef;
 922     if (seqref != null)
 923     {
 924       int seqIndex = al.findIndex(seqref);
 925       if (seqIndex != -1)
 926       {
 927         text.append(", ").append(MessageManager.getString("label.sequence"))
 928                 .append(" ").append(seqIndex + 1);
 929         char residue = seqref.getCharAt(column);
 930         if (!Comparison.isGap(residue))
 931         {
 932           text.append(" ");
 933           String name;
 934           if (al.isNucleotide())
 935           {
 936             name = ResidueProperties.nucleotideName
 937                     .get(String.valueOf(residue));
 938             text.append(" Nucleotide: ")
 939                     .append(name != null ? name : residue);
 940           }
 941           else
 942           {
 943             name = 'X' == residue ? "X"
 944                     : ('*' == residue ? "STOP"
 945                             : ResidueProperties.aa2Triplet
 946                                     .get(String.valueOf(residue)));
 947             text.append(" Residue: ").append(name != null ? name : residue);
 948           }
 949           int residuePos = seqref.findPosition(column);
 950           text.append(" (").append(residuePos).append(")");
 951         }
 952       }
 953     }
 954
 955     return text.toString();
 956   }
 957
 958   /**
 959    * DOCUMENT ME!
 960    *
 961    * @param evt
 962    *          DOCUMENT ME!
 963    */
 964   @Override
 965   public void mouseClicked(MouseEvent evt)
 966   {
 967     // if (activeRow != -1)
 968     // {
 969     // AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 970     // AlignmentAnnotation anot = aa[activeRow];
 971     // }
 972   }
 973
 974   // TODO mouseClicked-content and drawCursor are quite experimental!
 975   public void drawCursor(Graphics graphics, SequenceI seq, int res, int x1,
 976           int y1)
 977   {
 978     int pady = av.getCharHeight() / 5;
 979     int charOffset = 0;
 980     graphics.setColor(Color.black);
 981     graphics.fillRect(x1, y1, av.getCharWidth(), av.getCharHeight());
 982
 983     if (av.validCharWidth)
 984     {
 985       graphics.setColor(Color.white);
 986
 987       char s = seq.getCharAt(res);
 988
 989       charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
 990       graphics.drawString(String.valueOf(s), charOffset + x1,
 991               (y1 + av.getCharHeight()) - pady);
 992     }
 993
 994   }
 995
 996   private volatile boolean imageFresh = false;
 997   private Rectangle visibleRect = new Rectangle(), clipBounds = new Rectangle();
 998
 999   /**
1000    * DOCUMENT ME!
1001    *
1002    * @param g
1003    *          DOCUMENT ME!
1004    */
1005   @Override
1006   public void paintComponent(Graphics g)
1007   {
1008
1009           // BH: note that this method is generally recommended to
1010           // call super.paintComponent(g). Otherwise, the children of this
1011           // component will not be rendered. That is not needed here
1012           // because AnnotationPanel does not have any children. It is
1013           // just a JPanel contained in a JViewPort.
1014
1015     computeVisibleRect(visibleRect);
1016
1017     g.setColor(Color.white);
1018     g.fillRect(0, 0, visibleRect.width, visibleRect.height);
1019
1020     if (image != null)
1021     {
1022         // BH 2018 optimizing generation of new Rectangle().
1023       if (fastPaint || (visibleRect.width != (clipBounds = g.getClipBounds(clipBounds)).width)
1024             || (visibleRect.height != clipBounds.height))
1025       {
1026
1027
1028           g.drawImage(image, 0, 0, this);
1029         fastPaint = false;
1030         return;
1031       }
1032     }
1033     imgWidth = (av.getRanges().getEndRes() - av.getRanges().getStartRes()
1034             + 1) * av.getCharWidth();
1035     if (imgWidth < 1)
1036     {
1037       return;
1038     }
1039     Graphics2D gg;
1040     if (image == null || imgWidth != image.getWidth(this)
1041             || image.getHeight(this) != getHeight())
1042     {
1043       try
1044       {
1045         image = new BufferedImage(imgWidth,
1046                 ap.getAnnotationPanel().getHeight(),
1047                 BufferedImage.TYPE_INT_RGB);
1048       } catch (OutOfMemoryError oom)
1049       {
1050         try
1051         {
1052           System.gc();
1053         } catch (Exception x)
1054         {
1055         }
1056         ;
1057         new OOMWarning(
1058                 "Couldn't allocate memory to redraw screen. Please restart Jalview",
1059                 oom);
1060         return;
1061       }
1062       gg = (Graphics2D) image.getGraphics();
1063
1064       if (av.antiAlias)
1065       {
1066         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
1067                 RenderingHints.VALUE_ANTIALIAS_ON);
1068       }
1069
1070       gg.setFont(av.getFont());
1071       fm = gg.getFontMetrics();
1072       gg.setColor(Color.white);
1073       gg.fillRect(0, 0, imgWidth, image.getHeight());
1074       imageFresh = true;
1075     } else {
1076         gg = (Graphics2D) image.getGraphics();
1077
1078     }
1079
1080     drawComponent(gg, av.getRanges().getStartRes(),
1081             av.getRanges().getEndRes() + 1);
1082     gg.dispose();
1083     imageFresh = false;
1084     g.drawImage(image, 0, 0, this);
1085   }
1086
1087   /**
1088    * set true to enable redraw timing debug output on stderr
1089    */
1090   private final boolean debugRedraw = false;
1091
1092   /**
1093    * non-Thread safe repaint
1094    *
1095    * @param horizontal
1096    *          repaint with horizontal shift in alignment
1097    */
1098   public void fastPaint(int horizontal)
1099   {
1100     if ((horizontal == 0) || image == null
1101             || av.getAlignment().getAlignmentAnnotation() == null
1102             || av.getAlignment().getAlignmentAnnotation().length < 1
1103             || av.isCalcInProgress())
1104     {
1105       repaint();
1106       return;
1107     }
1108
1109     int sr = av.getRanges().getStartRes();
1110     int er = av.getRanges().getEndRes() + 1;
1111     int transX = 0;
1112
1113     Graphics2D gg = (Graphics2D) image.getGraphics();
1114
1115     gg.copyArea(0, 0, imgWidth, getHeight(),
1116             -horizontal * av.getCharWidth(), 0);
1117
1118     if (horizontal > 0) // scrollbar pulled right, image to the left
1119     {
1120       transX = (er - sr - horizontal) * av.getCharWidth();
1121       sr = er - horizontal;
1122     }
1123     else if (horizontal < 0)
1124     {
1125       er = sr - horizontal;
1126     }
1127
1128     gg.translate(transX, 0);
1129
1130     drawComponent(gg, sr, er);
1131
1132     gg.translate(-transX, 0);
1133
1134     gg.dispose();
1135
1136     fastPaint = true;
1137
1138     // Call repaint on alignment panel so that repaints from other alignment
1139     // panel components can be aggregated. Otherwise performance of the overview
1140     // window and others may be adversely affected.
1141     av.getAlignPanel().repaint();
1142   }
1143
1144   private volatile boolean lastImageGood = false;
1145
1146   /**
1147    * DOCUMENT ME!
1148    *
1149    * @param g
1150    *          DOCUMENT ME!
1151    * @param startRes
1152    *          DOCUMENT ME!
1153    * @param endRes
1154    *          DOCUMENT ME!
1155    */
1156   public void drawComponent(Graphics g, int startRes, int endRes)
1157   {
1158     BufferedImage oldFaded = fadedImage;
1159     if (av.isCalcInProgress())
1160     {
1161       if (image == null)
1162       {
1163         lastImageGood = false;
1164         return;
1165       }
1166       // We'll keep a record of the old image,
1167       // and draw a faded image until the calculation
1168       // has completed
1169       if (lastImageGood
1170               && (fadedImage == null || fadedImage.getWidth() != imgWidth
1171                       || fadedImage.getHeight() != image.getHeight()))
1172       {
1173         // System.err.println("redraw faded image ("+(fadedImage==null ?
1174         // "null image" : "") + " lastGood="+lastImageGood+")");
1175         fadedImage = new BufferedImage(imgWidth, image.getHeight(),
1176                 BufferedImage.TYPE_INT_RGB);
1177
1178         Graphics2D fadedG = (Graphics2D) fadedImage.getGraphics();
1179
1180         fadedG.setColor(Color.white);
1181         fadedG.fillRect(0, 0, imgWidth, image.getHeight());
1182
1183         fadedG.setComposite(
1184                 AlphaComposite.getInstance(AlphaComposite.SRC_OVER, .3f));
1185         fadedG.drawImage(image, 0, 0, this);
1186
1187       }
1188       // make sure we don't overwrite the last good faded image until all
1189       // calculations have finished
1190       lastImageGood = false;
1191
1192     }
1193     else
1194     {
1195       if (fadedImage != null)
1196       {
1197         oldFaded = fadedImage;
1198       }
1199       fadedImage = null;
1200     }
1201
1202     g.setColor(Color.white);
1203     g.fillRect(0, 0, (endRes - startRes) * av.getCharWidth(), getHeight());
1204
1205     g.setFont(av.getFont());
1206     if (fm == null)
1207     {
1208       fm = g.getFontMetrics();
1209     }
1210
1211     if ((av.getAlignment().getAlignmentAnnotation() == null)
1212             || (av.getAlignment().getAlignmentAnnotation().length < 1))
1213     {
1214       g.setColor(Color.white);
1215       g.fillRect(0, 0, getWidth(), getHeight());
1216       g.setColor(Color.black);
1217       if (av.validCharWidth)
1218       {
1219         g.drawString(MessageManager
1220                 .getString("label.alignment_has_no_annotations"), 20, 15);
1221       }
1222
1223       return;
1224     }
1225     lastImageGood = renderer.drawComponent(this, av, g, activeRow, startRes,
1226             endRes);
1227     if (!lastImageGood && fadedImage == null)
1228     {
1229       fadedImage = oldFaded;
1230     }
1231   }
1232
1233   @Override
1234   public FontMetrics getFontMetrics()
1235   {
1236     return fm;
1237   }
1238
1239   @Override
1240   public Image getFadedImage()
1241   {
1242     return fadedImage;
1243   }
1244
1245   @Override
1246   public int getFadedImageWidth()
1247   {
1248     return imgWidth;
1249   }
1250
1251   private int[] bounds = new int[2];
1252
1253   @Override
1254   public int[] getVisibleVRange()
1255   {
1256     if (ap != null && ap.getAlabels() != null)
1257     {
1258       int sOffset = -ap.getAlabels().getScrollOffset();
1259       int visHeight = sOffset + ap.annotationSpaceFillerHolder.getHeight();
1260       bounds[0] = sOffset;
1261       bounds[1] = visHeight;
1262       return bounds;
1263     }
1264     else
1265     {
1266       return null;
1267     }
1268   }
1269
1270   /**
1271    * Try to ensure any references held are nulled
1272    */
1273   public void dispose()
1274   {
1275     av = null;
1276     ap = null;
1277     image = null;
1278     fadedImage = null;
1279 //    gg = null;
1280     _mwl = null;
1281
1282     /*
1283      * I created the renderer so I will dispose of it
1284      */
1285     if (renderer != null)
1286     {
1287       renderer.dispose();
1288     }
1289   }
1290
1291   @Override
1292   public void propertyChange(PropertyChangeEvent evt)
1293   {
1294     // Respond to viewport range changes (e.g. alignment panel was scrolled)
1295     // Both scrolling and resizing change viewport ranges: scrolling changes
1296     // both start and end points, but resize only changes end values.
1297     // Here we only want to fastpaint on a scroll, with resize using a normal
1298     // paint, so scroll events are identified as changes to the horizontal or
1299     // vertical start value.
1300     if (evt.getPropertyName().equals(ViewportRanges.STARTRES))
1301     {
1302       fastPaint((int) evt.getNewValue() - (int) evt.getOldValue());
1303     }
1304     else if (evt.getPropertyName().equals(ViewportRanges.STARTRESANDSEQ))
1305     {
1306       fastPaint(((int[]) evt.getNewValue())[0]
1307               - ((int[]) evt.getOldValue())[0]);
1308     }
1309     else if (evt.getPropertyName().equals(ViewportRanges.MOVE_VIEWPORT))
1310     {
1311       repaint();
1312     }
1313   }
1314
1315   /**
1316    * computes the visible height of the annotation panel
1317    *
1318    * @param adjustPanelHeight
1319    *          - when false, just adjust existing height according to other
1320    *          windows
1321    * @param annotationHeight
1322    * @return height to use for the ScrollerPreferredVisibleSize
1323    */
1324   public int adjustForAlignFrame(boolean adjustPanelHeight,
1325           int annotationHeight)
1326   {
1327     /*
1328      * Estimate available height in the AlignFrame for alignment +
1329      * annotations. Deduct an estimate for title bar, menu bar, scale panel,
1330      * hscroll, status bar, insets.
1331      */
1332     int stuff = (ap.getViewName() != null ? 30 : 0)
1333             + (Platform.isAMacAndNotJS() ? 120 : 140);
1334     int availableHeight = ap.alignFrame.getHeight() - stuff;
1335     int rowHeight = av.getCharHeight();
1336
1337     if (adjustPanelHeight)
1338     {
1339       int alignmentHeight = rowHeight * av.getAlignment().getHeight();
1340
1341       /*
1342        * If not enough vertical space, maximize annotation height while keeping
1343        * at least two rows of alignment visible
1344        */
1345       if (annotationHeight + alignmentHeight > availableHeight)
1346       {
1347         annotationHeight = Math.min(annotationHeight,
1348                 availableHeight - 2 * rowHeight);
1349       }
1350     }
1351     else
1352     {
1353       // maintain same window layout whilst updating sliders
1354       annotationHeight = Math.min(ap.annotationScroller.getSize().height,
1355               availableHeight - 2 * rowHeight);
1356     }
1357     return annotationHeight;
1358   }
1359 }