JAL-3851 remove old interface
[jalview.git] / 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 java.awt.AlphaComposite;
24 import java.awt.Color;
25 import java.awt.Dimension;
26 import java.awt.FontMetrics;
27 import java.awt.Graphics;
28 import java.awt.Graphics2D;
29 import java.awt.Image;
30 import java.awt.Rectangle;
31 import java.awt.RenderingHints;
32 import java.awt.event.ActionEvent;
33 import java.awt.event.ActionListener;
34 import java.awt.event.AdjustmentEvent;
35 import java.awt.event.AdjustmentListener;
36 import java.awt.event.MouseEvent;
37 import java.awt.event.MouseListener;
38 import java.awt.event.MouseMotionListener;
39 import java.awt.event.MouseWheelEvent;
40 import java.awt.event.MouseWheelListener;
41 import java.awt.image.BufferedImage;
42 import java.beans.PropertyChangeEvent;
43 import java.util.ArrayList;
44 import java.util.Collections;
45 import java.util.List;
46
47 import javax.swing.JMenuItem;
48 import javax.swing.JPanel;
49 import javax.swing.JPopupMenu;
50 import javax.swing.Scrollable;
51 import javax.swing.ToolTipManager;
52
53 import jalview.datamodel.AlignmentAnnotation;
54 import jalview.datamodel.AlignmentI;
55 import jalview.datamodel.Annotation;
56 import jalview.datamodel.ColumnSelection;
57 import jalview.datamodel.HiddenColumns;
58 import jalview.datamodel.SequenceI;
59 import jalview.gui.JalviewColourChooser.ColourChooserListener;
60 import jalview.renderer.AnnotationRenderer;
61 import jalview.renderer.AwtRenderPanelI;
62 import jalview.schemes.ResidueProperties;
63 import jalview.util.Comparison;
64 import jalview.util.MessageManager;
65 import jalview.util.Platform;
66 import jalview.viewmodel.ViewportListenerI;
67 import jalview.viewmodel.ViewportRanges;
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     if (dragMode == DragMode.Resize)
638     {
639       ap.adjustAnnotationHeight();
640     }
641     dragMode = DragMode.Undefined;
642     ap.getScalePanel().mouseReleased(evt);
643
644     /*
645      * isPopupTrigger is set in mouseReleased on Windows
646      * (in mousePressed on Mac)
647      */
648     if (evt.isPopupTrigger() && activeRow != -1)
649     {
650       showPopupMenu(evt.getY(), evt.getX());
651     }
652
653   }
654
655   /**
656    * DOCUMENT ME!
657    * 
658    * @param evt
659    *          DOCUMENT ME!
660    */
661   @Override
662   public void mouseEntered(MouseEvent evt)
663   {
664     this.mouseDragging = false;
665     ap.getScalePanel().mouseEntered(evt);
666   }
667
668   /**
669    * On leaving the panel, calls ScalePanel.mouseExited to deal with scrolling
670    * with column selection on a mouse drag
671    * 
672    * @param evt
673    */
674   @Override
675   public void mouseExited(MouseEvent evt)
676   {
677     ap.getScalePanel().mouseExited(evt);
678   }
679
680   /**
681    * Action on starting or continuing a mouse drag. There are two possible
682    * actions:
683    * <ul>
684    * <li>drag up or down on a graphed annotation increases or decreases the
685    * height of the graph</li>
686    * <li>dragging left or right selects the columns dragged across</li>
687    * </ul>
688    * A drag on a graph annotation is treated as column selection if it starts
689    * with more horizontal than vertical movement, and as resize if it starts
690    * with more vertical than horizontal movement. Once started, the drag does
691    * not change mode.
692    * 
693    * @param evt
694    */
695   @Override
696   public void mouseDragged(MouseEvent evt)
697   {
698     /*
699      * if dragMode is Undefined:
700      * - set to Select if dx > dy
701      * - set to Resize if dy > dx
702      * - do nothing if dx == dy
703      */
704     final int x = evt.getX();
705     final int y = evt.getY();
706     if (dragMode == DragMode.Undefined)
707     {
708       int dx = Math.abs(x - mouseDragLastX);
709       int dy = Math.abs(y - mouseDragLastY);
710       if (graphStretch == -1 || dx > dy)
711       {
712         /*
713          * mostly horizontal drag, or not a graph annotation
714          */
715         dragMode = DragMode.Select;
716       }
717       else if (dy > dx)
718       {
719         /*
720          * mostly vertical drag
721          */
722         dragMode = DragMode.Resize;
723       }
724     }
725
726     if (dragMode == DragMode.Undefined)
727     {
728       /*
729        * drag is diagonal - defer deciding whether to
730        * treat as up/down or left/right
731        */
732       return;
733     }
734
735     try
736     {
737       if (dragMode == DragMode.Resize)
738       {
739         /*
740          * resize graph annotation if mouse was dragged up or down
741          */
742         int deltaY = mouseDragLastY - evt.getY();
743         if (deltaY != 0)
744         {
745           AlignmentAnnotation graphAnnotation = av.getAlignment()
746                   .getAlignmentAnnotation()[graphStretch];
747           int newHeight = Math.max(0, graphAnnotation.graphHeight + deltaY);
748           graphAnnotation.graphHeight = newHeight;
749           adjustPanelHeight();
750           ap.paintAlignment(false, false);
751         }
752       }
753       else
754       {
755         /*
756          * for mouse drag left or right, delegate to 
757          * ScalePanel to adjust the column selection
758          */
759         ap.getScalePanel().mouseDragged(evt);
760       }
761     } finally
762     {
763       mouseDragLastX = x;
764       mouseDragLastY = y;
765     }
766   }
767
768   /**
769    * Constructs the tooltip, and constructs and displays a status message, for
770    * the current mouse position
771    * 
772    * @param evt
773    */
774   @Override
775   public void mouseMoved(MouseEvent evt)
776   {
777     int yPos = evt.getY();
778     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
779
780     int row = getRowIndex(yPos, aa);
781
782     if (row == -1)
783     {
784       this.setToolTipText(null);
785       return;
786     }
787
788     int column = (evt.getX() / av.getCharWidth())
789             + av.getRanges().getStartRes();
790     column = Math.min(column, av.getRanges().getEndRes());
791
792     if (av.hasHiddenColumns())
793     {
794       column = av.getAlignment().getHiddenColumns()
795               .visibleToAbsoluteColumn(column);
796     }
797
798     AlignmentAnnotation ann = aa[row];
799     if (row > -1 && ann.annotations != null
800             && column < ann.annotations.length)
801     {
802       String toolTip = buildToolTip(ann, column, aa);
803       setToolTipText(toolTip == null ? null
804               : JvSwingUtils.wrapTooltip(true, toolTip));
805       String msg = getStatusMessage(av.getAlignment(), column, ann);
806       ap.alignFrame.setStatus(msg);
807     }
808     else
809     {
810       this.setToolTipText(null);
811       ap.alignFrame.setStatus(" ");
812     }
813   }
814
815   /**
816    * Answers the index in the annotations array of the visible annotation at the
817    * given y position. This is done by adding the heights of visible annotations
818    * until the y position has been exceeded. Answers -1 if no annotations are
819    * visible, or the y position is below all annotations.
820    * 
821    * @param yPos
822    * @param aa
823    * @return
824    */
825   static int getRowIndex(int yPos, AlignmentAnnotation[] aa)
826   {
827     if (aa == null)
828     {
829       return -1;
830     }
831     int row = -1;
832     int height = 0;
833
834     for (int i = 0; i < aa.length; i++)
835     {
836       if (aa[i].visible)
837       {
838         height += aa[i].height;
839       }
840
841       if (height > yPos)
842       {
843         row = i;
844         break;
845       }
846     }
847     return row;
848   }
849
850   /**
851    * Answers a tooltip for the annotation at the current mouse position, not
852    * wrapped in &lt;html&gt; tags (apply if wanted). Answers null if there is no
853    * tooltip to show.
854    * 
855    * @param ann
856    * @param column
857    * @param anns
858    */
859   static String buildToolTip(AlignmentAnnotation ann, int column,
860           AlignmentAnnotation[] anns)
861   {
862     String tooltip = null;
863     if (ann.graphGroup > -1)
864     {
865       StringBuilder tip = new StringBuilder(32);
866       boolean first = true;
867       for (int i = 0; i < anns.length; i++)
868       {
869         if (anns[i].graphGroup == ann.graphGroup
870                 && anns[i].annotations[column] != null)
871         {
872           if (!first)
873           {
874             tip.append("<br>");
875           }
876           first = false;
877           tip.append(anns[i].label);
878           String description = anns[i].annotations[column].description;
879           if (description != null && description.length() > 0)
880           {
881             tip.append(" ").append(description);
882           }
883         }
884       }
885       tooltip = first ? null : tip.toString();
886     }
887     else if (column < ann.annotations.length
888             && ann.annotations[column] != null)
889     {
890       tooltip = ann.annotations[column].description;
891     }
892
893     return tooltip;
894   }
895
896   /**
897    * Constructs and returns the status bar message
898    * 
899    * @param al
900    * @param column
901    * @param ann
902    */
903   static String getStatusMessage(AlignmentI al, int column,
904           AlignmentAnnotation ann)
905   {
906     /*
907      * show alignment column and annotation description if any
908      */
909     StringBuilder text = new StringBuilder(32);
910     text.append(MessageManager.getString("label.column")).append(" ")
911             .append(column + 1);
912
913     if (column < ann.annotations.length && ann.annotations[column] != null)
914     {
915       String description = ann.annotations[column].description;
916       if (description != null && description.trim().length() > 0)
917       {
918         text.append("  ").append(description);
919       }
920     }
921
922     /*
923      * if the annotation is sequence-specific, show the sequence number
924      * in the alignment, and (if not a gap) the residue and position
925      */
926     SequenceI seqref = ann.sequenceRef;
927     if (seqref != null)
928     {
929       int seqIndex = al.findIndex(seqref);
930       if (seqIndex != -1)
931       {
932         text.append(", ").append(MessageManager.getString("label.sequence"))
933                 .append(" ").append(seqIndex + 1);
934         char residue = seqref.getCharAt(column);
935         if (!Comparison.isGap(residue))
936         {
937           text.append(" ");
938           String name;
939           if (al.isNucleotide())
940           {
941             name = ResidueProperties.nucleotideName
942                     .get(String.valueOf(residue));
943             text.append(" Nucleotide: ")
944                     .append(name != null ? name : residue);
945           }
946           else
947           {
948             name = 'X' == residue ? "X"
949                     : ('*' == residue ? "STOP"
950                             : ResidueProperties.aa2Triplet
951                                     .get(String.valueOf(residue)));
952             text.append(" Residue: ").append(name != null ? name : residue);
953           }
954           int residuePos = seqref.findPosition(column);
955           text.append(" (").append(residuePos).append(")");
956         }
957       }
958     }
959
960     return text.toString();
961   }
962
963   /**
964    * DOCUMENT ME!
965    * 
966    * @param evt
967    *          DOCUMENT ME!
968    */
969   @Override
970   public void mouseClicked(MouseEvent evt)
971   {
972     // if (activeRow != -1)
973     // {
974     // AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
975     // AlignmentAnnotation anot = aa[activeRow];
976     // }
977   }
978
979   // TODO mouseClicked-content and drawCursor are quite experimental!
980   public void drawCursor(Graphics graphics, SequenceI seq, int res, int x1,
981           int y1)
982   {
983     int pady = av.getCharHeight() / 5;
984     int charOffset = 0;
985     graphics.setColor(Color.black);
986     graphics.fillRect(x1, y1, av.getCharWidth(), av.getCharHeight());
987
988     if (av.validCharWidth)
989     {
990       graphics.setColor(Color.white);
991
992       char s = seq.getCharAt(res);
993
994       charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
995       graphics.drawString(String.valueOf(s), charOffset + x1,
996               (y1 + av.getCharHeight()) - pady);
997     }
998
999   }
1000
1001   private volatile boolean imageFresh = false;
1002   private Rectangle visibleRect = new Rectangle(), clipBounds = new Rectangle();
1003
1004   /**
1005    * DOCUMENT ME!
1006    * 
1007    * @param g
1008    *          DOCUMENT ME!
1009    */
1010   @Override
1011   public void paintComponent(Graphics g)
1012   {
1013           
1014           // BH: note that this method is generally recommended to 
1015           // call super.paintComponent(g). Otherwise, the children of this
1016           // component will not be rendered. That is not needed here 
1017           // because AnnotationPanel does not have any children. It is
1018           // just a JPanel contained in a JViewPort. 
1019
1020     computeVisibleRect(visibleRect);
1021     
1022     g.setColor(Color.white);
1023     g.fillRect(0, 0, visibleRect.width, visibleRect.height);
1024
1025     if (image != null)
1026     {
1027         // BH 2018 optimizing generation of new Rectangle().
1028       if (fastPaint || (visibleRect.width != (clipBounds = g.getClipBounds(clipBounds)).width)
1029             || (visibleRect.height != clipBounds.height))
1030       {
1031
1032           
1033           g.drawImage(image, 0, 0, this);
1034         fastPaint = false;
1035         return;
1036       }
1037     }
1038     imgWidth = (av.getRanges().getEndRes() - av.getRanges().getStartRes()
1039             + 1) * av.getCharWidth();
1040     if (imgWidth < 1)
1041     {
1042       return;
1043     }
1044     Graphics2D gg;
1045     if (image == null || imgWidth != image.getWidth(this)
1046             || image.getHeight(this) != getHeight())
1047     {
1048       try
1049       {
1050         image = new BufferedImage(imgWidth,
1051                 ap.getAnnotationPanel().getHeight(),
1052                 BufferedImage.TYPE_INT_RGB);
1053       } catch (OutOfMemoryError oom)
1054       {
1055         try
1056         {
1057           System.gc();
1058         } catch (Exception x)
1059         {
1060         }
1061         ;
1062         new OOMWarning(
1063                 "Couldn't allocate memory to redraw screen. Please restart Jalview",
1064                 oom);
1065         return;
1066       }
1067       gg = (Graphics2D) image.getGraphics();
1068
1069       if (av.antiAlias)
1070       {
1071         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
1072                 RenderingHints.VALUE_ANTIALIAS_ON);
1073       }
1074
1075       gg.setFont(av.getFont());
1076       fm = gg.getFontMetrics();
1077       gg.setColor(Color.white);
1078       gg.fillRect(0, 0, imgWidth, image.getHeight());
1079       imageFresh = true;
1080     } else {
1081         gg = (Graphics2D) image.getGraphics();
1082
1083     }
1084     
1085     drawComponent(gg, av.getRanges().getStartRes(),
1086             av.getRanges().getEndRes() + 1);
1087     gg.dispose();
1088     imageFresh = false;
1089     g.drawImage(image, 0, 0, this);
1090   }
1091
1092   /**
1093    * set true to enable redraw timing debug output on stderr
1094    */
1095   private final boolean debugRedraw = false;
1096
1097   /**
1098    * non-Thread safe repaint
1099    * 
1100    * @param horizontal
1101    *          repaint with horizontal shift in alignment
1102    */
1103   public void fastPaint(int horizontal)
1104   {
1105     if ((horizontal == 0) || image == null
1106             || av.getAlignment().getAlignmentAnnotation() == null
1107             || av.getAlignment().getAlignmentAnnotation().length < 1
1108             || av.isCalcInProgress())
1109     {
1110       repaint();
1111       return;
1112     }
1113
1114     int sr = av.getRanges().getStartRes();
1115     int er = av.getRanges().getEndRes() + 1;
1116     int transX = 0;
1117
1118     Graphics2D gg = (Graphics2D) image.getGraphics();
1119
1120     gg.copyArea(0, 0, imgWidth, getHeight(),
1121             -horizontal * av.getCharWidth(), 0);
1122
1123     if (horizontal > 0) // scrollbar pulled right, image to the left
1124     {
1125       transX = (er - sr - horizontal) * av.getCharWidth();
1126       sr = er - horizontal;
1127     }
1128     else if (horizontal < 0)
1129     {
1130       er = sr - horizontal;
1131     }
1132
1133     gg.translate(transX, 0);
1134
1135     drawComponent(gg, sr, er);
1136
1137     gg.translate(-transX, 0);
1138
1139     gg.dispose();
1140     
1141     fastPaint = true;
1142
1143     // Call repaint on alignment panel so that repaints from other alignment
1144     // panel components can be aggregated. Otherwise performance of the overview
1145     // window and others may be adversely affected.
1146     av.getAlignPanel().repaint();
1147   }
1148
1149   private volatile boolean lastImageGood = false;
1150
1151   /**
1152    * DOCUMENT ME!
1153    * 
1154    * @param g
1155    *          DOCUMENT ME!
1156    * @param startRes
1157    *          DOCUMENT ME!
1158    * @param endRes
1159    *          DOCUMENT ME!
1160    */
1161   public void drawComponent(Graphics g, int startRes, int endRes)
1162   {
1163     BufferedImage oldFaded = fadedImage;
1164     if (av.isCalcInProgress())
1165     {
1166       if (image == null)
1167       {
1168         lastImageGood = false;
1169         return;
1170       }
1171       // We'll keep a record of the old image,
1172       // and draw a faded image until the calculation
1173       // has completed
1174       if (lastImageGood
1175               && (fadedImage == null || fadedImage.getWidth() != imgWidth
1176                       || fadedImage.getHeight() != image.getHeight()))
1177       {
1178         // System.err.println("redraw faded image ("+(fadedImage==null ?
1179         // "null image" : "") + " lastGood="+lastImageGood+")");
1180         fadedImage = new BufferedImage(imgWidth, image.getHeight(),
1181                 BufferedImage.TYPE_INT_RGB);
1182
1183         Graphics2D fadedG = (Graphics2D) fadedImage.getGraphics();
1184
1185         fadedG.setColor(Color.white);
1186         fadedG.fillRect(0, 0, imgWidth, image.getHeight());
1187
1188         fadedG.setComposite(
1189                 AlphaComposite.getInstance(AlphaComposite.SRC_OVER, .3f));
1190         fadedG.drawImage(image, 0, 0, this);
1191
1192       }
1193       // make sure we don't overwrite the last good faded image until all
1194       // calculations have finished
1195       lastImageGood = false;
1196
1197     }
1198     else
1199     {
1200       if (fadedImage != null)
1201       {
1202         oldFaded = fadedImage;
1203       }
1204       fadedImage = null;
1205     }
1206
1207     g.setColor(Color.white);
1208     g.fillRect(0, 0, (endRes - startRes) * av.getCharWidth(), getHeight());
1209
1210     g.setFont(av.getFont());
1211     if (fm == null)
1212     {
1213       fm = g.getFontMetrics();
1214     }
1215
1216     if ((av.getAlignment().getAlignmentAnnotation() == null)
1217             || (av.getAlignment().getAlignmentAnnotation().length < 1))
1218     {
1219       g.setColor(Color.white);
1220       g.fillRect(0, 0, getWidth(), getHeight());
1221       g.setColor(Color.black);
1222       if (av.validCharWidth)
1223       {
1224         g.drawString(MessageManager
1225                 .getString("label.alignment_has_no_annotations"), 20, 15);
1226       }
1227
1228       return;
1229     }
1230     lastImageGood = renderer.drawComponent(this, av, g, activeRow, startRes,
1231             endRes);
1232     if (!lastImageGood && fadedImage == null)
1233     {
1234       fadedImage = oldFaded;
1235     }
1236   }
1237
1238   @Override
1239   public FontMetrics getFontMetrics()
1240   {
1241     return fm;
1242   }
1243
1244   @Override
1245   public Image getFadedImage()
1246   {
1247     return fadedImage;
1248   }
1249
1250   @Override
1251   public int getFadedImageWidth()
1252   {
1253     return imgWidth;
1254   }
1255
1256   private int[] bounds = new int[2];
1257
1258   @Override
1259   public int[] getVisibleVRange()
1260   {
1261     if (ap != null && ap.getAlabels() != null)
1262     {
1263       int sOffset = -ap.getAlabels().getScrollOffset();
1264       int visHeight = sOffset + ap.annotationSpaceFillerHolder.getHeight();
1265       bounds[0] = sOffset;
1266       bounds[1] = visHeight;
1267       return bounds;
1268     }
1269     else
1270     {
1271       return null;
1272     }
1273   }
1274
1275   /**
1276    * Try to ensure any references held are nulled
1277    */
1278   public void dispose()
1279   {
1280     av = null;
1281     ap = null;
1282     image = null;
1283     fadedImage = null;
1284 //    gg = null;
1285     _mwl = null;
1286
1287     /*
1288      * I created the renderer so I will dispose of it
1289      */
1290     if (renderer != null)
1291     {
1292       renderer.dispose();
1293     }
1294   }
1295
1296   @Override
1297   public void propertyChange(PropertyChangeEvent evt)
1298   {
1299     // Respond to viewport range changes (e.g. alignment panel was scrolled)
1300     // Both scrolling and resizing change viewport ranges: scrolling changes
1301     // both start and end points, but resize only changes end values.
1302     // Here we only want to fastpaint on a scroll, with resize using a normal
1303     // paint, so scroll events are identified as changes to the horizontal or
1304     // vertical start value.
1305     if (evt.getPropertyName().equals(ViewportRanges.STARTRES))
1306     {
1307       fastPaint((int) evt.getNewValue() - (int) evt.getOldValue());
1308     }
1309     else if (evt.getPropertyName().equals(ViewportRanges.STARTRESANDSEQ))
1310     {
1311       fastPaint(((int[]) evt.getNewValue())[0]
1312               - ((int[]) evt.getOldValue())[0]);
1313     }
1314     else if (evt.getPropertyName().equals(ViewportRanges.MOVE_VIEWPORT))
1315     {
1316       repaint();
1317     }
1318   }
1319
1320   /**
1321    * computes the visible height of the annotation panel
1322    * 
1323    * @param adjustPanelHeight
1324    *          - when false, just adjust existing height according to other
1325    *          windows
1326    * @param annotationHeight
1327    * @return height to use for the ScrollerPreferredVisibleSize
1328    */
1329   public int adjustForAlignFrame(boolean adjustPanelHeight,
1330           int annotationHeight)
1331   {
1332     /*
1333      * Estimate available height in the AlignFrame for alignment +
1334      * annotations. Deduct an estimate for title bar, menu bar, scale panel,
1335      * hscroll, status bar, insets. 
1336      */
1337     int stuff = (ap.getViewName() != null ? 30 : 0)
1338             + (Platform.isAMacAndNotJS() ? 120 : 140);
1339     int availableHeight = ap.alignFrame.getHeight() - stuff;
1340     int rowHeight = av.getCharHeight();
1341
1342     if (adjustPanelHeight)
1343     {
1344       int alignmentHeight = rowHeight * av.getAlignment().getHeight();
1345
1346       /*
1347        * If not enough vertical space, maximize annotation height while keeping
1348        * at least two rows of alignment visible
1349        */
1350       if (annotationHeight + alignmentHeight > availableHeight)
1351       {
1352         annotationHeight = Math.min(annotationHeight,
1353                 availableHeight - 2 * rowHeight);
1354       }
1355     }
1356     else
1357     {
1358       // maintain same window layout whilst updating sliders
1359       annotationHeight = Math.min(ap.annotationScroller.getSize().height,
1360               availableHeight - 2 * rowHeight);
1361     }
1362     return annotationHeight;
1363   }
1364 }