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.renderer.AnnotationRenderer;
  30 import jalview.renderer.AwtRenderPanelI;
  31 import jalview.schemes.ResidueProperties;
  32 import jalview.util.Comparison;
  33 import jalview.util.MessageManager;
  34 import jalview.util.Platform;
  35 import jalview.viewmodel.ViewportListenerI;
  36 import jalview.viewmodel.ViewportRanges;
  37
  38 import java.awt.AlphaComposite;
  39 import java.awt.Color;
  40 import java.awt.Dimension;
  41 import java.awt.FontMetrics;
  42 import java.awt.Graphics;
  43 import java.awt.Graphics2D;
  44 import java.awt.Image;
  45 import java.awt.Rectangle;
  46 import java.awt.RenderingHints;
  47 import java.awt.event.ActionEvent;
  48 import java.awt.event.ActionListener;
  49 import java.awt.event.AdjustmentEvent;
  50 import java.awt.event.AdjustmentListener;
  51 import java.awt.event.MouseEvent;
  52 import java.awt.event.MouseListener;
  53 import java.awt.event.MouseMotionListener;
  54 import java.awt.event.MouseWheelEvent;
  55 import java.awt.event.MouseWheelListener;
  56 import java.awt.image.BufferedImage;
  57 import java.beans.PropertyChangeEvent;
  58 import java.util.ArrayList;
  59 import java.util.Collections;
  60 import java.util.List;
  61
  62 import javax.swing.JColorChooser;
  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   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(this,
 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       Color col = JColorChooser.showDialog(this,
 351               MessageManager.getString("label.select_foreground_colour"),
 352               Color.black);
 353
 354       for (int index : av.getColumnSelection().getSelected())
 355       {
 356         if (!av.getAlignment().getHiddenColumns().isVisible(index))
 357         {
 358           continue;
 359         }
 360
 361         if (anot[index] == null)
 362         {
 363           anot[index] = new Annotation("", "", ' ', 0);
 364         }
 365
 366         anot[index].colour = col;
 367       }
 368     }
 369     else
 370     // HELIX, SHEET or STEM
 371     {
 372       char type = 0;
 373       String symbol = "\u03B1"; // alpha
 374
 375       if (action.equals(HELIX))
 376       {
 377         type = 'H';
 378       }
 379       else if (action.equals(SHEET))
 380       {
 381         type = 'E';
 382         symbol = "\u03B2"; // beta
 383       }
 384
 385       // Added by LML to color stems
 386       else if (action.equals(STEM))
 387       {
 388         type = 'S';
 389         int column = av.getColumnSelection().getSelectedRanges().get(0)[0];
 390         symbol = aa[activeRow].getDefaultRnaHelixSymbol(column);
 391       }
 392
 393       if (!aa[activeRow].hasIcons)
 394       {
 395         aa[activeRow].hasIcons = true;
 396       }
 397
 398       String label = JvOptionPane.showInputDialog(MessageManager
 399               .getString("label.enter_label_for_the_structure"), symbol);
 400
 401       if (label == null)
 402       {
 403         return;
 404       }
 405
 406       if ((label.length() > 0) && !aa[activeRow].hasText)
 407       {
 408         aa[activeRow].hasText = true;
 409         if (action.equals(STEM))
 410         {
 411           aa[activeRow].showAllColLabels = true;
 412         }
 413       }
 414       for (int index : av.getColumnSelection().getSelected())
 415       {
 416         if (!av.getAlignment().getHiddenColumns().isVisible(index))
 417         {
 418           continue;
 419         }
 420
 421         if (anot[index] == null)
 422         {
 423           anot[index] = new Annotation(label, "", type, 0);
 424         }
 425
 426         anot[index].secondaryStructure = type != 'S' ? type
 427                 : label.length() == 0 ? ' ' : label.charAt(0);
 428         anot[index].displayCharacter = label;
 429
 430       }
 431     }
 432
 433     av.getAlignment().validateAnnotation(aa[activeRow]);
 434     ap.alignmentChanged();
 435     ap.alignFrame.setMenusForViewport();
 436     adjustPanelHeight();
 437     repaint();
 438
 439     return;
 440   }
 441
 442   /**
 443    * Returns any existing annotation concatenated as a string. For each
 444    * annotation, takes the description, if any, else the secondary structure
 445    * character (if type is HELIX, SHEET or STEM), else the display character (if
 446    * type is LABEL).
 447    *
 448    * @param anots
 449    * @param type
 450    * @return
 451    */
 452   private String collectAnnotVals(Annotation[] anots, String type)
 453   {
 454     // TODO is this method wanted? why? 'last' is not used
 455
 456     StringBuilder collatedInput = new StringBuilder(64);
 457     String last = "";
 458     ColumnSelection viscols = av.getColumnSelection();
 459     HiddenColumns hidden = av.getAlignment().getHiddenColumns();
 460
 461     /*
 462      * the selection list (read-only view) is in selection order, not
 463      * column order; make a copy so we can sort it
 464      */
 465     List<Integer> selected = new ArrayList<>(viscols.getSelected());
 466     Collections.sort(selected);
 467     for (int index : selected)
 468     {
 469       // always check for current display state - just in case
 470       if (!hidden.isVisible(index))
 471       {
 472         continue;
 473       }
 474       String tlabel = null;
 475       if (anots[index] != null)
 476       { // LML added stem code
 477         if (type.equals(HELIX) || type.equals(SHEET) || type.equals(STEM)
 478                 || type.equals(LABEL))
 479         {
 480           tlabel = anots[index].description;
 481           if (tlabel == null || tlabel.length() < 1)
 482           {
 483             if (type.equals(HELIX) || type.equals(SHEET)
 484                     || type.equals(STEM))
 485             {
 486               tlabel = "" + anots[index].secondaryStructure;
 487             }
 488             else
 489             {
 490               tlabel = "" + anots[index].displayCharacter;
 491             }
 492           }
 493         }
 494         if (tlabel != null && !tlabel.equals(last))
 495         {
 496           if (last.length() > 0)
 497           {
 498             collatedInput.append(" ");
 499           }
 500           collatedInput.append(tlabel);
 501         }
 502       }
 503     }
 504     return collatedInput.toString();
 505   }
 506
 507   /**
 508    * Action on right mouse pressed on Mac is to show a pop-up menu for the
 509    * annotation. Action on left mouse pressed is to find which annotation is
 510    * pressed and mark the start of a column selection or graph resize operation.
 511    *
 512    * @param evt
 513    */
 514   @Override
 515   public void mousePressed(MouseEvent evt)
 516   {
 517
 518     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 519     if (aa == null)
 520     {
 521       return;
 522     }
 523     mouseDragLastX = evt.getX();
 524     mouseDragLastY = evt.getY();
 525
 526     /*
 527      * add visible annotation heights until we reach the y
 528      * position, to find which annotation it is in
 529      */
 530     int height = 0;
 531     activeRow = -1;
 532
 533     final int y = evt.getY();
 534     for (int i = 0; i < aa.length; i++)
 535     {
 536       if (aa[i].visible)
 537       {
 538         height += aa[i].height;
 539       }
 540
 541       if (y < height)
 542       {
 543         if (aa[i].editable)
 544         {
 545           activeRow = i;
 546         }
 547         else if (aa[i].graph > 0)
 548         {
 549           /*
 550            * we have clicked on a resizable graph annotation
 551            */
 552           graphStretch = i;
 553         }
 554         break;
 555       }
 556     }
 557
 558     /*
 559      * isPopupTrigger fires in mousePressed on Mac,
 560      * not until mouseRelease on Windows
 561      */
 562     if (evt.isPopupTrigger() && activeRow != -1)
 563     {
 564       showPopupMenu(y, evt.getX());
 565       return;
 566     }
 567
 568     ap.getScalePanel().mousePressed(evt);
 569   }
 570
 571   /**
 572    * Construct and display a context menu at the right-click position
 573    *
 574    * @param y
 575    * @param x
 576    */
 577   void showPopupMenu(final int y, int x)
 578   {
 579     if (av.getColumnSelection() == null
 580             || av.getColumnSelection().isEmpty())
 581     {
 582       return;
 583     }
 584
 585     JPopupMenu pop = new JPopupMenu(
 586             MessageManager.getString("label.structure_type"));
 587     JMenuItem item;
 588     /*
 589      * Just display the needed structure options
 590      */
 591     if (av.getAlignment().isNucleotide())
 592     {
 593       item = new JMenuItem(STEM);
 594       item.addActionListener(this);
 595       pop.add(item);
 596     }
 597     else
 598     {
 599       item = new JMenuItem(HELIX);
 600       item.addActionListener(this);
 601       pop.add(item);
 602       item = new JMenuItem(SHEET);
 603       item.addActionListener(this);
 604       pop.add(item);
 605     }
 606     item = new JMenuItem(LABEL);
 607     item.addActionListener(this);
 608     pop.add(item);
 609     item = new JMenuItem(COLOUR);
 610     item.addActionListener(this);
 611     pop.add(item);
 612     item = new JMenuItem(REMOVE);
 613     item.addActionListener(this);
 614     pop.add(item);
 615     pop.show(this, x, y);
 616   }
 617
 618   /**
 619    * Action on mouse up is to clear mouse drag data and call mouseReleased on
 620    * ScalePanel, to deal with defining the selection group (if any) defined by
 621    * the mouse drag
 622    *
 623    * @param evt
 624    */
 625   @Override
 626   public void mouseReleased(MouseEvent evt)
 627   {
 628     graphStretch = -1;
 629     mouseDragLastX = -1;
 630     mouseDragLastY = -1;
 631     mouseDragging = false;
 632     dragMode = DragMode.Undefined;
 633     ap.getScalePanel().mouseReleased(evt);
 634
 635     /*
 636      * isPopupTrigger is set in mouseReleased on Windows
 637      * (in mousePressed on Mac)
 638      */
 639     if (evt.isPopupTrigger() && activeRow != -1)
 640     {
 641       showPopupMenu(evt.getY(), evt.getX());
 642     }
 643
 644   }
 645
 646   /**
 647    * DOCUMENT ME!
 648    *
 649    * @param evt
 650    *          DOCUMENT ME!
 651    */
 652   @Override
 653   public void mouseEntered(MouseEvent evt)
 654   {
 655     ap.getScalePanel().mouseEntered(evt);
 656   }
 657
 658   /**
 659    * DOCUMENT ME!
 660    *
 661    * @param evt
 662    *          DOCUMENT ME!
 663    */
 664   @Override
 665   public void mouseExited(MouseEvent evt)
 666   {
 667     ap.getScalePanel().mouseExited(evt);
 668   }
 669
 670   /**
 671    * DOCUMENT ME!
 672    *
 673    * @param evt
 674    *          DOCUMENT ME!
 675    */
 676   @Override
 677   public void mouseDragged(MouseEvent evt)
 678   {
 679     /*
 680      * todo: if dragMode is Undefined:
 681      * - set to Select if dx > dy
 682      * - set to Resize if dy > dx
 683      * - do nothing if dx == dy
 684      */
 685     final int x = evt.getX();
 686     final int y = evt.getY();
 687     if (dragMode == DragMode.Undefined)
 688     {
 689       int dx = Math.abs(x - mouseDragLastX);
 690       int dy = Math.abs(y - mouseDragLastY);
 691       if (graphStretch == -1 || dx > dy)
 692       {
 693         /*
 694          * mostly horizontal drag, or not a graph annotation
 695          */
 696         dragMode = DragMode.Select;
 697       }
 698       else if (dy > dx)
 699       {
 700         /*
 701          * mostly vertical drag
 702          */
 703         dragMode = DragMode.Resize;
 704       }
 705     }
 706
 707     if (dragMode == DragMode.Undefined)
 708     {
 709       /*
 710        * drag is diagonal - defer deciding whether to
 711        * treat as up/down or left/right
 712        */
 713       return;
 714     }
 715
 716     try
 717     {
 718       if (dragMode == DragMode.Resize)
 719       {
 720         /*
 721          * resize graph annotation if mouse was dragged up or down
 722          */
 723         int deltaY = mouseDragLastY - evt.getY();
 724         if (deltaY != 0)
 725         {
 726           AlignmentAnnotation graphAnnotation = av.getAlignment()
 727                   .getAlignmentAnnotation()[graphStretch];
 728           int newHeight = Math.max(0, graphAnnotation.graphHeight + deltaY);
 729           graphAnnotation.graphHeight = newHeight;
 730           adjustPanelHeight();
 731           ap.paintAlignment(false, false);
 732         }
 733       }
 734       else
 735       {
 736         /*
 737          * for mouse drag left or right, delegate to
 738          * ScalePanel to adjust the column selection
 739          */
 740         ap.getScalePanel().mouseDragged(evt);
 741       }
 742     } finally
 743     {
 744       mouseDragLastX = x;
 745       mouseDragLastY = y;
 746     }
 747   }
 748
 749   /**
 750    * Constructs the tooltip, and constructs and displays a status message, for
 751    * the current mouse position
 752    *
 753    * @param evt
 754    */
 755   @Override
 756   public void mouseMoved(MouseEvent evt)
 757   {
 758     int yPos = evt.getY();
 759     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 760
 761     int row = getRowIndex(yPos, aa);
 762
 763     if (row == -1)
 764     {
 765       this.setToolTipText(null);
 766       return;
 767     }
 768
 769     int column = (evt.getX() / av.getCharWidth())
 770             + av.getRanges().getStartRes();
 771     column = Math.min(column, av.getRanges().getEndRes());
 772
 773     if (av.hasHiddenColumns())
 774     {
 775       column = av.getAlignment().getHiddenColumns()
 776               .visibleToAbsoluteColumn(column);
 777     }
 778
 779     AlignmentAnnotation ann = aa[row];
 780     if (row > -1 && ann.annotations != null
 781             && column < ann.annotations.length)
 782     {
 783       setToolTipText(buildToolTip(ann, column, aa));
 784       String msg = getStatusMessage(av.getAlignment(), column, ann);
 785       ap.alignFrame.setStatus(msg);
 786     }
 787     else
 788     {
 789       this.setToolTipText(null);
 790       ap.alignFrame.setStatus(" ");
 791     }
 792   }
 793
 794   /**
 795    * Answers the index in the annotations array of the visible annotation at the
 796    * given y position. This is done by adding the heights of visible annotations
 797    * until the y position has been exceeded. Answers -1 if no annotations are
 798    * visible, or the y position is below all annotations.
 799    *
 800    * @param yPos
 801    * @param aa
 802    * @return
 803    */
 804   static int getRowIndex(int yPos, AlignmentAnnotation[] aa)
 805   {
 806     if (aa == null)
 807     {
 808       return -1;
 809     }
 810     int row = -1;
 811     int height = 0;
 812
 813     for (int i = 0; i < aa.length; i++)
 814     {
 815       if (aa[i].visible)
 816       {
 817         height += aa[i].height;
 818       }
 819
 820       if (height > yPos)
 821       {
 822         row = i;
 823         break;
 824       }
 825     }
 826     return row;
 827   }
 828
 829   /**
 830    * Answers a tooltip for the annotation at the current mouse position
 831    *
 832    * @param ann
 833    * @param column
 834    * @param anns
 835    */
 836   static String buildToolTip(AlignmentAnnotation ann, int column,
 837           AlignmentAnnotation[] anns)
 838   {
 839     String tooltip = null;
 840     if (ann.graphGroup > -1)
 841     {
 842       StringBuilder tip = new StringBuilder(32);
 843       tip.append("<html>");
 844       for (int i = 0; i < anns.length; i++)
 845       {
 846         if (anns[i].graphGroup == ann.graphGroup
 847                 && anns[i].annotations[column] != null)
 848         {
 849           tip.append(anns[i].label);
 850           String description = anns[i].annotations[column].description;
 851           if (description != null && description.length() > 0)
 852           {
 853             tip.append(" ").append(description);
 854           }
 855           tip.append("<br>");
 856         }
 857       }
 858       if (tip.length() != 6)
 859       {
 860         tip.setLength(tip.length() - 4);
 861         tooltip = tip.toString() + "</html>";
 862       }
 863     }
 864     else if (column < ann.annotations.length
 865             && ann.annotations[column] != null)
 866     {
 867       String description = ann.annotations[column].description;
 868       if (description != null && description.length() > 0)
 869       {
 870         tooltip = JvSwingUtils.wrapTooltip(true, description);
 871       }
 872       else
 873       {
 874         tooltip = null; // no tooltip if null or empty description
 875       }
 876     }
 877     else
 878     {
 879       // clear the tooltip.
 880       tooltip = null;
 881     }
 882     return tooltip;
 883   }
 884
 885   /**
 886    * Constructs and returns the status bar message
 887    *
 888    * @param al
 889    * @param column
 890    * @param ann
 891    */
 892   static String getStatusMessage(AlignmentI al, int column,
 893           AlignmentAnnotation ann)
 894   {
 895     /*
 896      * show alignment column and annotation description if any
 897      */
 898     StringBuilder text = new StringBuilder(32);
 899     text.append(MessageManager.getString("label.column")).append(" ")
 900             .append(column + 1);
 901
 902     if (column < ann.annotations.length && ann.annotations[column] != null)
 903     {
 904       String description = ann.annotations[column].description;
 905       if (description != null && description.trim().length() > 0)
 906       {
 907         text.append("  ").append(description);
 908       }
 909     }
 910
 911     /*
 912      * if the annotation is sequence-specific, show the sequence number
 913      * in the alignment, and (if not a gap) the residue and position
 914      */
 915     SequenceI seqref = ann.sequenceRef;
 916     if (seqref != null)
 917     {
 918       int seqIndex = al.findIndex(seqref);
 919       if (seqIndex != -1)
 920       {
 921         text.append(", ").append(MessageManager.getString("label.sequence"))
 922                 .append(" ").append(seqIndex + 1);
 923         char residue = seqref.getCharAt(column);
 924         if (!Comparison.isGap(residue))
 925         {
 926           text.append(" ");
 927           String name;
 928           if (al.isNucleotide())
 929           {
 930             name = ResidueProperties.nucleotideName
 931                     .get(String.valueOf(residue));
 932             text.append(" Nucleotide: ")
 933                     .append(name != null ? name : residue);
 934           }
 935           else
 936           {
 937             name = 'X' == residue ? "X"
 938                     : ('*' == residue ? "STOP"
 939                             : ResidueProperties.aa2Triplet
 940                                     .get(String.valueOf(residue)));
 941             text.append(" Residue: ").append(name != null ? name : residue);
 942           }
 943           int residuePos = seqref.findPosition(column);
 944           text.append(" (").append(residuePos).append(")");
 945         }
 946       }
 947     }
 948
 949     return text.toString();
 950   }
 951
 952   /**
 953    * DOCUMENT ME!
 954    *
 955    * @param evt
 956    *          DOCUMENT ME!
 957    */
 958   @Override
 959   public void mouseClicked(MouseEvent evt)
 960   {
 961     // if (activeRow != -1)
 962     // {
 963     // AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 964     // AlignmentAnnotation anot = aa[activeRow];
 965     // }
 966   }
 967
 968   // TODO mouseClicked-content and drawCursor are quite experimental!
 969   public void drawCursor(Graphics graphics, SequenceI seq, int res, int x1,
 970           int y1)
 971   {
 972     int pady = av.getCharHeight() / 5;
 973     int charOffset = 0;
 974     graphics.setColor(Color.black);
 975     graphics.fillRect(x1, y1, av.getCharWidth(), av.getCharHeight());
 976
 977     if (av.validCharWidth)
 978     {
 979       graphics.setColor(Color.white);
 980
 981       char s = seq.getCharAt(res);
 982
 983       charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
 984       graphics.drawString(String.valueOf(s), charOffset + x1,
 985               (y1 + av.getCharHeight()) - pady);
 986     }
 987
 988   }
 989
 990   private volatile boolean imageFresh = false;
 991
 992   /**
 993    * DOCUMENT ME!
 994    *
 995    * @param g
 996    *          DOCUMENT ME!
 997    */
 998   @Override
 999   public void paintComponent(Graphics g)
1000   {
1001     super.paintComponent(g);
1002
1003     g.setColor(Color.white);
1004     g.fillRect(0, 0, getWidth(), getHeight());
1005
1006     if (image != null)
1007     {
1008       if (fastPaint || (getVisibleRect().width != g.getClipBounds().width)
1009               || (getVisibleRect().height != g.getClipBounds().height))
1010       {
1011         g.drawImage(image, 0, 0, this);
1012         fastPaint = false;
1013         return;
1014       }
1015     }
1016     imgWidth = (av.getRanges().getEndRes() - av.getRanges().getStartRes()
1017             + 1) * av.getCharWidth();
1018     if (imgWidth < 1)
1019     {
1020       return;
1021     }
1022     if (image == null || imgWidth != image.getWidth(this)
1023             || image.getHeight(this) != getHeight())
1024     {
1025       try
1026       {
1027         image = new BufferedImage(imgWidth,
1028                 ap.getAnnotationPanel().getHeight(),
1029                 BufferedImage.TYPE_INT_RGB);
1030       } catch (OutOfMemoryError oom)
1031       {
1032         try
1033         {
1034           System.gc();
1035         } catch (Exception x)
1036         {
1037         }
1038         ;
1039         new OOMWarning(
1040                 "Couldn't allocate memory to redraw screen. Please restart Jalview",
1041                 oom);
1042         return;
1043       }
1044       gg = (Graphics2D) image.getGraphics();
1045
1046       if (av.antiAlias)
1047       {
1048         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
1049                 RenderingHints.VALUE_ANTIALIAS_ON);
1050       }
1051
1052       gg.setFont(av.getFont());
1053       fm = gg.getFontMetrics();
1054       gg.setColor(Color.white);
1055       gg.fillRect(0, 0, imgWidth, image.getHeight());
1056       imageFresh = true;
1057     }
1058
1059     drawComponent(gg, av.getRanges().getStartRes(),
1060             av.getRanges().getEndRes() + 1);
1061     imageFresh = false;
1062     g.drawImage(image, 0, 0, this);
1063   }
1064
1065   /**
1066    * set true to enable redraw timing debug output on stderr
1067    */
1068   private final boolean debugRedraw = false;
1069
1070   /**
1071    * non-Thread safe repaint
1072    *
1073    * @param horizontal
1074    *          repaint with horizontal shift in alignment
1075    */
1076   public void fastPaint(int horizontal)
1077   {
1078     if ((horizontal == 0) || gg == null
1079             || av.getAlignment().getAlignmentAnnotation() == null
1080             || av.getAlignment().getAlignmentAnnotation().length < 1
1081             || av.isCalcInProgress())
1082     {
1083       repaint();
1084       return;
1085     }
1086
1087     int sr = av.getRanges().getStartRes();
1088     int er = av.getRanges().getEndRes() + 1;
1089     int transX = 0;
1090
1091     gg.copyArea(0, 0, imgWidth, getHeight(),
1092             -horizontal * av.getCharWidth(), 0);
1093
1094     if (horizontal > 0) // scrollbar pulled right, image to the left
1095     {
1096       transX = (er - sr - horizontal) * av.getCharWidth();
1097       sr = er - horizontal;
1098     }
1099     else if (horizontal < 0)
1100     {
1101       er = sr - horizontal;
1102     }
1103
1104     gg.translate(transX, 0);
1105
1106     drawComponent(gg, sr, er);
1107
1108     gg.translate(-transX, 0);
1109
1110     fastPaint = true;
1111
1112     // Call repaint on alignment panel so that repaints from other alignment
1113     // panel components can be aggregated. Otherwise performance of the overview
1114     // window and others may be adversely affected.
1115     av.getAlignPanel().repaint();
1116   }
1117
1118   private volatile boolean lastImageGood = false;
1119
1120   /**
1121    * DOCUMENT ME!
1122    *
1123    * @param g
1124    *          DOCUMENT ME!
1125    * @param startRes
1126    *          DOCUMENT ME!
1127    * @param endRes
1128    *          DOCUMENT ME!
1129    */
1130   public void drawComponent(Graphics g, int startRes, int endRes)
1131   {
1132     BufferedImage oldFaded = fadedImage;
1133     if (av.isCalcInProgress())
1134     {
1135       if (image == null)
1136       {
1137         lastImageGood = false;
1138         return;
1139       }
1140       // We'll keep a record of the old image,
1141       // and draw a faded image until the calculation
1142       // has completed
1143       if (lastImageGood
1144               && (fadedImage == null || fadedImage.getWidth() != imgWidth
1145                       || fadedImage.getHeight() != image.getHeight()))
1146       {
1147         // System.err.println("redraw faded image ("+(fadedImage==null ?
1148         // "null image" : "") + " lastGood="+lastImageGood+")");
1149         fadedImage = new BufferedImage(imgWidth, image.getHeight(),
1150                 BufferedImage.TYPE_INT_RGB);
1151
1152         Graphics2D fadedG = (Graphics2D) fadedImage.getGraphics();
1153
1154         fadedG.setColor(Color.white);
1155         fadedG.fillRect(0, 0, imgWidth, image.getHeight());
1156
1157         fadedG.setComposite(
1158                 AlphaComposite.getInstance(AlphaComposite.SRC_OVER, .3f));
1159         fadedG.drawImage(image, 0, 0, this);
1160
1161       }
1162       // make sure we don't overwrite the last good faded image until all
1163       // calculations have finished
1164       lastImageGood = false;
1165
1166     }
1167     else
1168     {
1169       if (fadedImage != null)
1170       {
1171         oldFaded = fadedImage;
1172       }
1173       fadedImage = null;
1174     }
1175
1176     g.setColor(Color.white);
1177     g.fillRect(0, 0, (endRes - startRes) * av.getCharWidth(), getHeight());
1178
1179     g.setFont(av.getFont());
1180     if (fm == null)
1181     {
1182       fm = g.getFontMetrics();
1183     }
1184
1185     if ((av.getAlignment().getAlignmentAnnotation() == null)
1186             || (av.getAlignment().getAlignmentAnnotation().length < 1))
1187     {
1188       g.setColor(Color.white);
1189       g.fillRect(0, 0, getWidth(), getHeight());
1190       g.setColor(Color.black);
1191       if (av.validCharWidth)
1192       {
1193         g.drawString(MessageManager
1194                 .getString("label.alignment_has_no_annotations"), 20, 15);
1195       }
1196
1197       return;
1198     }
1199     lastImageGood = renderer.drawComponent(this, av, g, activeRow, startRes,
1200             endRes);
1201     if (!lastImageGood && fadedImage == null)
1202     {
1203       fadedImage = oldFaded;
1204     }
1205   }
1206
1207   @Override
1208   public FontMetrics getFontMetrics()
1209   {
1210     return fm;
1211   }
1212
1213   @Override
1214   public Image getFadedImage()
1215   {
1216     return fadedImage;
1217   }
1218
1219   @Override
1220   public int getFadedImageWidth()
1221   {
1222     return imgWidth;
1223   }
1224
1225   private int[] bounds = new int[2];
1226
1227   @Override
1228   public int[] getVisibleVRange()
1229   {
1230     if (ap != null && ap.getAlabels() != null)
1231     {
1232       int sOffset = -ap.getAlabels().getScrollOffset();
1233       int visHeight = sOffset + ap.annotationSpaceFillerHolder.getHeight();
1234       bounds[0] = sOffset;
1235       bounds[1] = visHeight;
1236       return bounds;
1237     }
1238     else
1239     {
1240       return null;
1241     }
1242   }
1243
1244   /**
1245    * Try to ensure any references held are nulled
1246    */
1247   public void dispose()
1248   {
1249     av = null;
1250     ap = null;
1251     image = null;
1252     fadedImage = null;
1253     gg = null;
1254     _mwl = null;
1255
1256     /*
1257      * I created the renderer so I will dispose of it
1258      */
1259     if (renderer != null)
1260     {
1261       renderer.dispose();
1262     }
1263   }
1264
1265   @Override
1266   public void propertyChange(PropertyChangeEvent evt)
1267   {
1268     // Respond to viewport range changes (e.g. alignment panel was scrolled)
1269     // Both scrolling and resizing change viewport ranges: scrolling changes
1270     // both start and end points, but resize only changes end values.
1271     // Here we only want to fastpaint on a scroll, with resize using a normal
1272     // paint, so scroll events are identified as changes to the horizontal or
1273     // vertical start value.
1274     if (evt.getPropertyName().equals(ViewportRanges.STARTRES))
1275     {
1276       fastPaint((int) evt.getNewValue() - (int) evt.getOldValue());
1277     }
1278     else if (evt.getPropertyName().equals(ViewportRanges.STARTRESANDSEQ))
1279     {
1280       fastPaint(((int[]) evt.getNewValue())[0]
1281               - ((int[]) evt.getOldValue())[0]);
1282     }
1283     else if (evt.getPropertyName().equals(ViewportRanges.MOVE_VIEWPORT))
1284     {
1285       repaint();
1286     }
1287   }
1288
1289   /**
1290    * computes the visible height of the annotation panel
1291    *
1292    * @param adjustPanelHeight
1293    *          - when false, just adjust existing height according to other
1294    *          windows
1295    * @param annotationHeight
1296    * @return height to use for the ScrollerPreferredVisibleSize
1297    */
1298   public int adjustForAlignFrame(boolean adjustPanelHeight,
1299           int annotationHeight)
1300   {
1301     /*
1302      * Estimate available height in the AlignFrame for alignment +
1303      * annotations. Deduct an estimate for title bar, menu bar, scale panel,
1304      * hscroll, status bar, insets.
1305      */
1306     int stuff = (ap.getViewName() != null ? 30 : 0)
1307             + (Platform.isAMac() ? 120 : 140);
1308     int availableHeight = ap.alignFrame.getHeight() - stuff;
1309     int rowHeight = av.getCharHeight();
1310
1311     if (adjustPanelHeight)
1312     {
1313       int alignmentHeight = rowHeight * av.getAlignment().getHeight();
1314
1315       /*
1316        * If not enough vertical space, maximize annotation height while keeping
1317        * at least two rows of alignment visible
1318        */
1319       if (annotationHeight + alignmentHeight > availableHeight)
1320       {
1321         annotationHeight = Math.min(annotationHeight,
1322                 availableHeight - 2 * rowHeight);
1323       }
1324     }
1325     else
1326     {
1327       // maintain same window layout whilst updating sliders
1328       annotationHeight = Math.min(ap.annotationScroller.getSize().height,
1329               availableHeight - 2 * rowHeight);
1330     }
1331     return annotationHeight;
1332   }
1333 }