Merge branch 'patch/JAL-4345_pae_epas1_doubleclick' into develop
[jalview.git] / src / jalview / gui / AnnotationLabels.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.Canvas;
24 import java.awt.Color;
25 import java.awt.Cursor;
26 import java.awt.Dimension;
27 import java.awt.Font;
28 import java.awt.FontMetrics;
29 import java.awt.Graphics;
30 import java.awt.Graphics2D;
31 import java.awt.RenderingHints;
32 import java.awt.Toolkit;
33 import java.awt.datatransfer.StringSelection;
34 import java.awt.event.ActionEvent;
35 import java.awt.event.ActionListener;
36 import java.awt.event.MouseEvent;
37 import java.awt.event.MouseListener;
38 import java.awt.event.MouseMotionListener;
39 import java.awt.geom.AffineTransform;
40 import java.util.Arrays;
41 import java.util.Collections;
42 import java.util.Iterator;
43 import java.util.Locale;
44
45 import javax.swing.JCheckBoxMenuItem;
46 import javax.swing.JMenuItem;
47 import javax.swing.JPanel;
48 import javax.swing.JPopupMenu;
49 import javax.swing.SwingUtilities;
50 import javax.swing.ToolTipManager;
51
52 import jalview.analysis.AlignSeq;
53 import jalview.analysis.AlignmentUtils;
54 import jalview.bin.Cache;
55 import jalview.bin.Jalview;
56 import jalview.datamodel.Alignment;
57 import jalview.datamodel.AlignmentAnnotation;
58 import jalview.datamodel.Annotation;
59 import jalview.datamodel.ContactMatrixI;
60 import jalview.datamodel.GroupSet;
61 import jalview.datamodel.HiddenColumns;
62 import jalview.datamodel.Sequence;
63 import jalview.datamodel.SequenceGroup;
64 import jalview.datamodel.SequenceI;
65 import jalview.io.FileFormat;
66 import jalview.io.FormatAdapter;
67 import jalview.util.Comparison;
68 import jalview.util.MessageManager;
69 import jalview.util.Platform;
70
71 /**
72  * The panel that holds the labels for alignment annotations, providing
73  * tooltips, context menus, drag to reorder rows, and drag to adjust panel
74  * height
75  */
76 public class AnnotationLabels extends JPanel
77         implements MouseListener, MouseMotionListener, ActionListener
78 {
79   private static final String HTML_END_TAG = "</html>";
80
81   private static final String HTML_START_TAG = "<html>";
82
83   /**
84    * width in pixels within which height adjuster arrows are shown and active
85    */
86   private static final int HEIGHT_ADJUSTER_WIDTH = 50;
87
88   /**
89    * height in pixels for allowing height adjuster to be active
90    */
91   public static int HEIGHT_ADJUSTER_HEIGHT = 10;
92
93   private static final Font font = new Font("Arial", Font.PLAIN, 11);
94
95   private static final String TOGGLE_LABELSCALE = MessageManager
96           .getString("label.scale_label_to_column");
97
98   private static final String ADDNEW = MessageManager
99           .getString("label.add_new_row");
100
101   private static final String EDITNAME = MessageManager
102           .getString("label.edit_label_description");
103
104   private static final String HIDE = MessageManager
105           .getString("label.hide_row");
106
107   private static final String DELETE = MessageManager
108           .getString("label.delete_row");
109
110   private static final String SHOWALL = MessageManager
111           .getString("label.show_all_hidden_rows");
112
113   private static final String OUTPUT_TEXT = MessageManager
114           .getString("label.export_annotation");
115
116   private static final String COPYCONS_SEQ = MessageManager
117           .getString("label.copy_consensus_sequence");
118
119   private static final String ADJUST_ANNOTATION_LABELS_WIDTH_PREF = "ADJUST_ANNOTATION_LABELS_WIDTH";
120
121   private final boolean debugRedraw = false;
122
123   private AlignmentPanel ap;
124
125   AlignViewport av;
126
127   private MouseEvent dragEvent;
128
129   private int oldY;
130
131   private int selectedRow;
132
133   private int scrollOffset = 0;
134
135   private boolean hasHiddenRows;
136
137   private boolean resizePanel = false;
138
139   private int annotationIdWidth = -1;
140
141   public static final String RESIZE_MARGINS_MARK_PREF = "RESIZE_MARGINS_MARK";
142
143   /**
144    * Creates a new AnnotationLabels object
145    * 
146    * @param ap
147    */
148   public AnnotationLabels(AlignmentPanel ap)
149   {
150     this.ap = ap;
151     av = ap.av;
152     ToolTipManager.sharedInstance().registerComponent(this);
153
154     addMouseListener(this);
155     addMouseMotionListener(this);
156     addMouseWheelListener(ap.getAnnotationPanel());
157   }
158
159   public AnnotationLabels(AlignViewport av)
160   {
161     this.av = av;
162   }
163
164   /**
165    * DOCUMENT ME!
166    * 
167    * @param y
168    *          DOCUMENT ME!
169    */
170   public void setScrollOffset(int y)
171   {
172     scrollOffset = y;
173     repaint();
174   }
175
176   /**
177    * sets selectedRow to -2 if no annotation preset, -1 if no visible row is at
178    * y
179    * 
180    * @param y
181    *          coordinate position to search for a row
182    */
183   void getSelectedRow(int y)
184   {
185     int height = 0;
186     AlignmentAnnotation[] aa = ap.av.getAlignment()
187             .getAlignmentAnnotation();
188     selectedRow = -2;
189     if (aa != null)
190     {
191       for (int i = 0; i < aa.length; i++)
192       {
193         selectedRow = -1;
194         if (!aa[i].visible)
195         {
196           continue;
197         }
198
199         height += aa[i].height;
200
201         if (y < height)
202         {
203           selectedRow = i;
204
205           break;
206         }
207       }
208     }
209   }
210
211   /**
212    * DOCUMENT ME!
213    * 
214    * @param evt
215    *          DOCUMENT ME!
216    */
217   @Override
218   public void actionPerformed(ActionEvent evt)
219   {
220     AlignmentAnnotation[] aa = ap.av.getAlignment()
221             .getAlignmentAnnotation();
222
223     String action = evt.getActionCommand();
224     if (ADDNEW.equals(action))
225     {
226       /*
227        * non-returning dialog
228        */
229       AlignmentAnnotation newAnnotation = new AlignmentAnnotation(null,
230               null, new Annotation[ap.av.getAlignment().getWidth()]);
231       editLabelDescription(newAnnotation, true);
232     }
233     else if (EDITNAME.equals(action))
234     {
235       /*
236        * non-returning dialog
237        */
238       editLabelDescription(aa[selectedRow], false);
239     }
240     else if (HIDE.equals(action))
241     {
242       aa[selectedRow].visible = false;
243     }
244     else if (DELETE.equals(action))
245     {
246       ap.av.getAlignment().deleteAnnotation(aa[selectedRow]);
247       ap.av.getCalcManager().removeWorkerForAnnotation(aa[selectedRow]);
248     }
249     else if (SHOWALL.equals(action))
250     {
251       for (int i = 0; i < aa.length; i++)
252       {
253         if (!aa[i].visible && aa[i].annotations != null)
254         {
255           aa[i].visible = true;
256         }
257       }
258     }
259     else if (OUTPUT_TEXT.equals(action))
260     {
261       new AnnotationExporter(ap).exportAnnotation(aa[selectedRow]);
262     }
263     else if (COPYCONS_SEQ.equals(action))
264     {
265       SequenceI cons = null;
266       if (aa[selectedRow].groupRef != null)
267       {
268         cons = aa[selectedRow].groupRef.getConsensusSeq();
269       }
270       else
271       {
272         cons = av.getConsensusSeq();
273       }
274       if (cons != null)
275       {
276         copy_annotseqtoclipboard(cons);
277       }
278     }
279     else if (TOGGLE_LABELSCALE.equals(action))
280     {
281       aa[selectedRow].scaleColLabel = !aa[selectedRow].scaleColLabel;
282     }
283
284     ap.refresh(true);
285   }
286
287   /**
288    * Shows a dialog where the annotation name and description may be edited. If
289    * parameter addNew is true, then on confirmation, a new AlignmentAnnotation
290    * is added, else an existing annotation is updated.
291    * 
292    * @param annotation
293    * @param addNew
294    */
295   void editLabelDescription(AlignmentAnnotation annotation, boolean addNew)
296   {
297     String name = MessageManager.getString("label.annotation_name");
298     String description = MessageManager
299             .getString("label.annotation_description");
300     String title = MessageManager
301             .getString("label.edit_annotation_name_description");
302     EditNameDialog dialog = new EditNameDialog(annotation.label,
303             annotation.description, name, description);
304
305     dialog.showDialog(ap.alignFrame, title, () -> {
306       annotation.label = dialog.getName();
307       String text = dialog.getDescription();
308       if (text != null && text.length() == 0)
309       {
310         text = null;
311       }
312       annotation.description = text;
313       if (addNew)
314       {
315         ap.av.getAlignment().addAnnotation(annotation);
316         ap.av.getAlignment().setAnnotationIndex(annotation, 0);
317       }
318       ap.refresh(true);
319     });
320   }
321
322   @Override
323   public void mousePressed(MouseEvent evt)
324   {
325     getSelectedRow(evt.getY() - getScrollOffset());
326     oldY = evt.getY();
327     if (evt.isPopupTrigger())
328     {
329       showPopupMenu(evt);
330     }
331   }
332
333   /**
334    * Build and show the Pop-up menu at the right-click mouse position
335    * 
336    * @param evt
337    */
338   void showPopupMenu(MouseEvent evt)
339   {
340     evt.consume();
341     final AlignmentAnnotation[] aa = ap.av.getAlignment()
342             .getAlignmentAnnotation();
343
344     JPopupMenu pop = new JPopupMenu(
345             MessageManager.getString("label.annotations"));
346     JMenuItem item = new JMenuItem(ADDNEW);
347     item.addActionListener(this);
348     pop.add(item);
349     if (selectedRow < 0)
350     {
351       if (hasHiddenRows)
352       { // let the user make everything visible again
353         item = new JMenuItem(SHOWALL);
354         item.addActionListener(this);
355         pop.add(item);
356       }
357       pop.show(this, evt.getX(), evt.getY());
358       return;
359     }
360     item = new JMenuItem(EDITNAME);
361     item.addActionListener(this);
362     pop.add(item);
363     item = new JMenuItem(HIDE);
364     item.addActionListener(this);
365     pop.add(item);
366     // JAL-1264 hide all sequence-specific annotations of this type
367     if (selectedRow < aa.length)
368     {
369       if (aa[selectedRow].sequenceRef != null)
370       {
371         final String label = aa[selectedRow].label;
372         JMenuItem hideType = new JMenuItem();
373         String text = MessageManager.getString("label.hide_all") + " "
374                 + label;
375         hideType.setText(text);
376         hideType.addActionListener(new ActionListener()
377         {
378           @Override
379           public void actionPerformed(ActionEvent e)
380           {
381             AlignmentUtils.showOrHideSequenceAnnotations(
382                     ap.av.getAlignment(), Collections.singleton(label),
383                     null, false, false);
384             ap.refresh(true);
385           }
386         });
387         pop.add(hideType);
388       }
389     }
390     item = new JMenuItem(DELETE);
391     item.addActionListener(this);
392     pop.add(item);
393     if (hasHiddenRows)
394     {
395       item = new JMenuItem(SHOWALL);
396       item.addActionListener(this);
397       pop.add(item);
398     }
399     item = new JMenuItem(OUTPUT_TEXT);
400     item.addActionListener(this);
401     pop.add(item);
402     // TODO: annotation object should be typed for autocalculated/derived
403     // property methods
404     if (selectedRow < aa.length)
405     {
406       final String label = aa[selectedRow].label;
407       if (!aa[selectedRow].autoCalculated)
408       {
409         if (aa[selectedRow].graph == AlignmentAnnotation.NO_GRAPH)
410         {
411           // display formatting settings for this row.
412           pop.addSeparator();
413           // av and sequencegroup need to implement same interface for
414           item = new JCheckBoxMenuItem(TOGGLE_LABELSCALE,
415                   aa[selectedRow].scaleColLabel);
416           item.addActionListener(this);
417           pop.add(item);
418         }
419       }
420       else if (label.indexOf("Consensus") > -1)
421       {
422         addConsensusMenuOptions(ap, aa[selectedRow], pop);
423
424         final JMenuItem consclipbrd = new JMenuItem(COPYCONS_SEQ);
425         consclipbrd.addActionListener(this);
426         pop.add(consclipbrd);
427       }
428
429       addColourOrFilterByOptions(ap, aa[selectedRow], pop);
430
431       if (aa[selectedRow].graph == AlignmentAnnotation.CONTACT_MAP)
432       {
433         addContactMatrixOptions(ap, aa[selectedRow], pop);
434         // Set/adjust threshold for grouping ?
435         // colour alignment by this [type]
436         // select/hide columns by this row
437
438       }
439     }
440
441     pop.show(this, evt.getX(), evt.getY());
442   }
443
444   static void addColourOrFilterByOptions(final AlignmentPanel ap,
445           final AlignmentAnnotation alignmentAnnotation,
446           final JPopupMenu pop)
447   {
448     JMenuItem item;
449     item = new JMenuItem(
450             MessageManager.getString("label.colour_by_annotation"));
451     item.addActionListener(new ActionListener()
452     {
453
454       @Override
455       public void actionPerformed(ActionEvent e)
456       {
457         AnnotationColourChooser.displayFor(ap.av, ap, alignmentAnnotation,
458                 false);
459       };
460     });
461     pop.add(item);
462     if (alignmentAnnotation.sequenceRef != null)
463     {
464       item = new JMenuItem(
465               MessageManager.getString("label.colour_by_annotation") + " ("
466                       + MessageManager.getString("label.per_seq") + ")");
467       item.addActionListener(new ActionListener()
468       {
469         @Override
470         public void actionPerformed(ActionEvent e)
471         {
472           AnnotationColourChooser.displayFor(ap.av, ap, alignmentAnnotation,
473                   true);
474         };
475       });
476       pop.add(item);
477     }
478     item = new JMenuItem(
479             MessageManager.getString("action.select_by_annotation"));
480     item.addActionListener(new ActionListener()
481     {
482
483       @Override
484       public void actionPerformed(ActionEvent e)
485       {
486         AnnotationColumnChooser.displayFor(ap.av, ap, alignmentAnnotation);
487       };
488     });
489     pop.add(item);
490   }
491
492   static void addContactMatrixOptions(final AlignmentPanel ap,
493           final AlignmentAnnotation alignmentAnnotation,
494           final JPopupMenu pop)
495   {
496
497     final ContactMatrixI cm = ap.av.getContactMatrix(alignmentAnnotation);
498     JMenuItem item;
499     if (cm != null)
500     {
501       pop.addSeparator();
502
503       if (cm.hasGroups())
504       {
505         JCheckBoxMenuItem chitem = new JCheckBoxMenuItem(
506                 MessageManager.getString("action.show_groups_on_matrix"));
507         chitem.setToolTipText(MessageManager
508                 .getString("action.show_groups_on_matrix_tooltip"));
509         boolean showGroups = alignmentAnnotation
510                 .isShowGroupsForContactMatrix();
511         final AlignmentAnnotation sel_row = alignmentAnnotation;
512         chitem.setState(showGroups);
513         chitem.addActionListener(new ActionListener()
514         {
515
516           @Override
517           public void actionPerformed(ActionEvent e)
518           {
519             sel_row.setShowGroupsForContactMatrix(chitem.getState());
520             // so any annotation colour changes are propagated - though they
521             // probably won't be unless the annotation row colours are removed
522             // too!
523             ap.alignmentChanged();
524           }
525         });
526         pop.add(chitem);
527       }
528       if (cm.hasTree())
529       {
530         item = new JMenuItem(
531                 MessageManager.getString("action.show_tree_for_matrix"));
532         item.setToolTipText(MessageManager
533                 .getString("action.show_tree_for_matrix_tooltip"));
534         item.addActionListener(new ActionListener()
535         {
536
537           @Override
538           public void actionPerformed(ActionEvent e)
539           {
540
541             ap.alignFrame.showContactMapTree(alignmentAnnotation, cm);
542
543           }
544         });
545         pop.add(item);
546       }
547       else
548       {
549         item = new JMenuItem(
550                 MessageManager.getString("action.cluster_matrix"));
551         item.setToolTipText(
552                 MessageManager.getString("action.cluster_matrix_tooltip"));
553         item.addActionListener(new ActionListener()
554         {
555           @Override
556           public void actionPerformed(ActionEvent e)
557           {
558             new Thread(new Runnable()
559             {
560               @Override
561               public void run()
562               {
563                 final long progBar;
564                 ap.alignFrame.setProgressBar(
565                         MessageManager.formatMessage(
566                                 "action.clustering_matrix_for",
567                                 cm.getAnnotDescr(), 5f),
568                         progBar = System.currentTimeMillis());
569                 cm.setGroupSet(GroupSet.makeGroups(cm, true));
570                 cm.randomlyReColourGroups();
571                 cm.transferGroupColorsTo(alignmentAnnotation);
572                 ap.alignmentChanged();
573                 ap.alignFrame.showContactMapTree(alignmentAnnotation, cm);
574                 ap.alignFrame.setProgressBar(null, progBar);
575               }
576             }).start();
577           }
578         });
579         pop.add(item);
580       }
581     }
582   }
583
584   /**
585    * A helper method that adds menu options for calculation and visualisation of
586    * group and/or alignment consensus annotation to a popup menu. This is
587    * designed to be reusable for either unwrapped mode (popup menu is shown on
588    * component AnnotationLabels), or wrapped mode (popup menu is shown on
589    * IdPanel when the mouse is over an annotation label).
590    * 
591    * @param ap
592    * @param ann
593    * @param pop
594    */
595   static void addConsensusMenuOptions(AlignmentPanel ap,
596           AlignmentAnnotation ann, JPopupMenu pop)
597   {
598     pop.addSeparator();
599
600     final JCheckBoxMenuItem cbmi = new JCheckBoxMenuItem(
601             MessageManager.getString("label.ignore_gaps_consensus"),
602             (ann.groupRef != null) ? ann.groupRef.getIgnoreGapsConsensus()
603                     : ap.av.isIgnoreGapsConsensus());
604     final AlignmentAnnotation aaa = ann;
605     cbmi.addActionListener(new ActionListener()
606     {
607       @Override
608       public void actionPerformed(ActionEvent e)
609       {
610         if (aaa.groupRef != null)
611         {
612           aaa.groupRef.setIgnoreGapsConsensus(cbmi.getState());
613           ap.getAnnotationPanel()
614                   .paint(ap.getAnnotationPanel().getGraphics());
615         }
616         else
617         {
618           ap.av.setIgnoreGapsConsensus(cbmi.getState(), ap);
619         }
620         ap.alignmentChanged();
621       }
622     });
623     pop.add(cbmi);
624
625     if (aaa.groupRef != null)
626     {
627       /*
628        * group consensus options
629        */
630       final JCheckBoxMenuItem chist = new JCheckBoxMenuItem(
631               MessageManager.getString("label.show_group_histogram"),
632               ann.groupRef.isShowConsensusHistogram());
633       chist.addActionListener(new ActionListener()
634       {
635         @Override
636         public void actionPerformed(ActionEvent e)
637         {
638           aaa.groupRef.setShowConsensusHistogram(chist.getState());
639           ap.repaint();
640         }
641       });
642       pop.add(chist);
643       final JCheckBoxMenuItem cprofl = new JCheckBoxMenuItem(
644               MessageManager.getString("label.show_group_logo"),
645               ann.groupRef.isShowSequenceLogo());
646       cprofl.addActionListener(new ActionListener()
647       {
648         @Override
649         public void actionPerformed(ActionEvent e)
650         {
651           aaa.groupRef.setshowSequenceLogo(cprofl.getState());
652           ap.repaint();
653         }
654       });
655       pop.add(cprofl);
656       final JCheckBoxMenuItem cproflnorm = new JCheckBoxMenuItem(
657               MessageManager.getString("label.normalise_group_logo"),
658               ann.groupRef.isNormaliseSequenceLogo());
659       cproflnorm.addActionListener(new ActionListener()
660       {
661         @Override
662         public void actionPerformed(ActionEvent e)
663         {
664           aaa.groupRef.setNormaliseSequenceLogo(cproflnorm.getState());
665           // automatically enable logo display if we're clicked
666           aaa.groupRef.setshowSequenceLogo(true);
667           ap.repaint();
668         }
669       });
670       pop.add(cproflnorm);
671     }
672     else
673     {
674       /*
675        * alignment consensus options
676        */
677       final JCheckBoxMenuItem chist = new JCheckBoxMenuItem(
678               MessageManager.getString("label.show_histogram"),
679               ap.av.isShowConsensusHistogram());
680       chist.addActionListener(new ActionListener()
681       {
682         @Override
683         public void actionPerformed(ActionEvent e)
684         {
685           ap.av.setShowConsensusHistogram(chist.getState());
686           ap.alignFrame.setMenusForViewport();
687           ap.repaint();
688         }
689       });
690       pop.add(chist);
691       final JCheckBoxMenuItem cprof = new JCheckBoxMenuItem(
692               MessageManager.getString("label.show_logo"),
693               ap.av.isShowSequenceLogo());
694       cprof.addActionListener(new ActionListener()
695       {
696         @Override
697         public void actionPerformed(ActionEvent e)
698         {
699           ap.av.setShowSequenceLogo(cprof.getState());
700           ap.alignFrame.setMenusForViewport();
701           ap.repaint();
702         }
703       });
704       pop.add(cprof);
705       final JCheckBoxMenuItem cprofnorm = new JCheckBoxMenuItem(
706               MessageManager.getString("label.normalise_logo"),
707               ap.av.isNormaliseSequenceLogo());
708       cprofnorm.addActionListener(new ActionListener()
709       {
710         @Override
711         public void actionPerformed(ActionEvent e)
712         {
713           ap.av.setShowSequenceLogo(true);
714           ap.av.setNormaliseSequenceLogo(cprofnorm.getState());
715           ap.alignFrame.setMenusForViewport();
716           ap.repaint();
717         }
718       });
719       pop.add(cprofnorm);
720     }
721   }
722
723   /**
724    * Reorders annotation rows after a drag of a label
725    * 
726    * @param evt
727    */
728   @Override
729   public void mouseReleased(MouseEvent evt)
730   {
731     if (evt.isPopupTrigger())
732     {
733       showPopupMenu(evt);
734       return;
735     }
736
737     int start = selectedRow;
738     getSelectedRow(evt.getY() - getScrollOffset());
739     int end = selectedRow;
740
741     /*
742      * if dragging to resize instead, start == end
743      */
744     if (start != end)
745     {
746       // Swap these annotations
747       AlignmentAnnotation startAA = ap.av.getAlignment()
748               .getAlignmentAnnotation()[start];
749       if (end == -1)
750       {
751         end = ap.av.getAlignment().getAlignmentAnnotation().length - 1;
752       }
753       AlignmentAnnotation endAA = ap.av.getAlignment()
754               .getAlignmentAnnotation()[end];
755
756       ap.av.getAlignment().getAlignmentAnnotation()[end] = startAA;
757       ap.av.getAlignment().getAlignmentAnnotation()[start] = endAA;
758     }
759
760     resizePanel = false;
761     dragEvent = null;
762     repaint();
763     ap.getAnnotationPanel().repaint();
764   }
765
766   /**
767    * Removes the height adjuster image on leaving the panel, unless currently
768    * dragging it
769    */
770   @Override
771   public void mouseExited(MouseEvent evt)
772   {
773     if (resizePanel && dragEvent == null)
774     {
775       resizePanel = false;
776       repaint();
777     }
778   }
779
780   /**
781    * A mouse drag may be either an adjustment of the panel height (if flag
782    * resizePanel is set on), or a reordering of the annotation rows. The former
783    * is dealt with by this method, the latter in mouseReleased.
784    * 
785    * @param evt
786    */
787   @Override
788   public void mouseDragged(MouseEvent evt)
789   {
790     dragEvent = evt;
791
792     if (resizePanel)
793     {
794       Dimension d = ap.annotationScroller.getPreferredSize();
795       int dif = evt.getY() - oldY;
796
797       dif /= ap.av.getCharHeight();
798       dif *= ap.av.getCharHeight();
799
800       if ((d.height - dif) > 20)
801       {
802         ap.annotationScroller
803                 .setPreferredSize(new Dimension(d.width, d.height - dif));
804         d = ap.annotationSpaceFillerHolder.getPreferredSize();
805         ap.annotationSpaceFillerHolder
806                 .setPreferredSize(new Dimension(d.width, d.height - dif));
807         ap.paintAlignment(true, false);
808       }
809
810       ap.addNotify();
811     }
812     else
813     {
814       repaint();
815     }
816   }
817
818   /**
819    * Updates the tooltip as the mouse moves over the labels
820    * 
821    * @param evt
822    */
823   @Override
824   public void mouseMoved(MouseEvent evt)
825   {
826     showOrHideAdjuster(evt);
827
828     getSelectedRow(evt.getY() - getScrollOffset());
829
830     if (selectedRow > -1 && ap.av.getAlignment()
831             .getAlignmentAnnotation().length > selectedRow)
832     {
833       AlignmentAnnotation[] anns = ap.av.getAlignment()
834               .getAlignmentAnnotation();
835       AlignmentAnnotation aa = anns[selectedRow];
836
837       String desc = getTooltip(aa);
838       this.setToolTipText(desc);
839       String msg = getStatusMessage(aa, anns);
840       ap.alignFrame.setStatus(msg);
841     }
842   }
843
844   /**
845    * Constructs suitable text to show in the status bar when over an annotation
846    * label, containing the associated sequence name (if any), and the annotation
847    * labels (or all labels for a graph group annotation)
848    * 
849    * @param aa
850    * @param anns
851    * @return
852    */
853   static String getStatusMessage(AlignmentAnnotation aa,
854           AlignmentAnnotation[] anns)
855   {
856     if (aa == null)
857     {
858       return null;
859     }
860
861     StringBuilder msg = new StringBuilder(32);
862     if (aa.sequenceRef != null)
863     {
864       msg.append(aa.sequenceRef.getName()).append(" : ");
865     }
866
867     if (aa.graphGroup == -1)
868     {
869       msg.append(aa.label);
870     }
871     else if (anns != null)
872     {
873       boolean first = true;
874       for (int i = anns.length - 1; i >= 0; i--)
875       {
876         if (anns[i].graphGroup == aa.graphGroup)
877         {
878           if (!first)
879           {
880             msg.append(", ");
881           }
882           msg.append(anns[i].label);
883           first = false;
884         }
885       }
886     }
887
888     return msg.toString();
889   }
890
891   /**
892    * Answers a tooltip, formatted as html, containing the annotation description
893    * (prefixed by associated sequence id if applicable), and the annotation
894    * (non-positional) score if it has one. Answers null if neither description
895    * nor score is found.
896    * 
897    * @param aa
898    * @return
899    */
900   static String getTooltip(AlignmentAnnotation aa)
901   {
902     if (aa == null)
903     {
904       return null;
905     }
906     StringBuilder tooltip = new StringBuilder();
907     if (aa.description != null && !aa.description.equals("New description"))
908     {
909       // TODO: we could refactor and merge this code with the code in
910       // jalview.gui.SeqPanel.mouseMoved(..) that formats sequence feature
911       // tooltips
912       String desc = aa.getDescription(true).trim();
913       if (!desc.toLowerCase(Locale.ROOT).startsWith(HTML_START_TAG))
914       {
915         tooltip.append(HTML_START_TAG);
916         desc = desc.replace("<", "&lt;");
917       }
918       else if (desc.toLowerCase(Locale.ROOT).endsWith(HTML_END_TAG))
919       {
920         desc = desc.substring(0, desc.length() - HTML_END_TAG.length());
921       }
922       tooltip.append(desc);
923     }
924     else
925     {
926       // begin the tooltip's html fragment
927       tooltip.append(HTML_START_TAG);
928     }
929     if (aa.hasScore())
930     {
931       if (tooltip.length() > HTML_START_TAG.length())
932       {
933         tooltip.append("<br/>");
934       }
935       // TODO: limit precision of score to avoid noise from imprecise
936       // doubles
937       // (64.7 becomes 64.7+/some tiny value).
938       tooltip.append(" Score: ").append(String.valueOf(aa.score));
939     }
940
941     if (tooltip.length() > HTML_START_TAG.length())
942     {
943       return tooltip.append(HTML_END_TAG).toString();
944     }
945
946     /*
947      * nothing in the tooltip (except "<html>")
948      */
949     return null;
950   }
951
952   /**
953    * Shows the height adjuster image if the mouse moves into the top left
954    * region, or hides it if the mouse leaves the regio
955    * 
956    * @param evt
957    */
958   protected void showOrHideAdjuster(MouseEvent evt)
959   {
960     boolean was = resizePanel;
961     resizePanel = evt.getY() < HEIGHT_ADJUSTER_HEIGHT
962             && evt.getX() < HEIGHT_ADJUSTER_WIDTH;
963
964     if (resizePanel != was)
965     {
966       setCursor(Cursor
967               .getPredefinedCursor(resizePanel ? Cursor.S_RESIZE_CURSOR
968                       : Cursor.DEFAULT_CURSOR));
969       repaint();
970     }
971   }
972
973   @Override
974   public void mouseClicked(MouseEvent evt)
975   {
976     final AlignmentAnnotation[] aa = ap.av.getAlignment()
977             .getAlignmentAnnotation();
978     if (!evt.isPopupTrigger() && SwingUtilities.isLeftMouseButton(evt))
979     {
980       if (selectedRow > -1 && selectedRow < aa.length)
981       {
982         if (aa[selectedRow].groupRef != null)
983         {
984           if (evt.getClickCount() >= 2)
985           {
986             // todo: make the ap scroll to the selection - not necessary, first
987             // click highlights/scrolls, second selects
988             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(null);
989             // process modifiers
990             SequenceGroup sg = ap.av.getSelectionGroup();
991             if (sg == null || sg == aa[selectedRow].groupRef
992                     || !(Platform.isControlDown(evt) || evt.isShiftDown()))
993             {
994               if (Platform.isControlDown(evt) || evt.isShiftDown())
995               {
996                 // clone a new selection group from the associated group
997                 ap.av.setSelectionGroup(
998                         new SequenceGroup(aa[selectedRow].groupRef));
999               }
1000               else
1001               {
1002                 // set selection to the associated group so it can be edited
1003                 ap.av.setSelectionGroup(aa[selectedRow].groupRef);
1004               }
1005             }
1006             else
1007             {
1008               // modify current selection with associated group
1009               int remainToAdd = aa[selectedRow].groupRef.getSize();
1010               for (SequenceI sgs : aa[selectedRow].groupRef.getSequences())
1011               {
1012                 if (jalview.util.Platform.isControlDown(evt))
1013                 {
1014                   sg.addOrRemove(sgs, --remainToAdd == 0);
1015                 }
1016                 else
1017                 {
1018                   // notionally, we should also add intermediate sequences from
1019                   // last added sequence ?
1020                   sg.addSequence(sgs, --remainToAdd == 0);
1021                 }
1022               }
1023             }
1024
1025             ap.paintAlignment(false, false);
1026             PaintRefresher.Refresh(ap, ap.av.getSequenceSetId());
1027             ap.av.sendSelection();
1028           }
1029           else
1030           {
1031             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(
1032                     aa[selectedRow].groupRef.getSequences(null));
1033           }
1034           return;
1035         }
1036         else if (aa[selectedRow].sequenceRef != null)
1037         {
1038           if (evt.getClickCount() == 1)
1039           {
1040             ap.getSeqPanel().ap.getIdPanel()
1041                     .highlightSearchResults(Arrays.asList(new SequenceI[]
1042                     { aa[selectedRow].sequenceRef }));
1043           }
1044           else if (evt.getClickCount() >= 2)
1045           {
1046             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(null);
1047             SequenceGroup sg = ap.av.getSelectionGroup();
1048             if (sg != null)
1049             {
1050               // we make a copy rather than edit the current selection if no
1051               // modifiers pressed
1052               // see Enhancement JAL-1557
1053               if (!(Platform.isControlDown(evt) || evt.isShiftDown()))
1054               {
1055                 sg = new SequenceGroup(sg);
1056                 sg.clear();
1057                 sg.addSequence(aa[selectedRow].sequenceRef, false);
1058               }
1059               else
1060               {
1061                 if (Platform.isControlDown(evt))
1062                 {
1063                   sg.addOrRemove(aa[selectedRow].sequenceRef, true);
1064                 }
1065                 else
1066                 {
1067                   // notionally, we should also add intermediate sequences from
1068                   // last added sequence ?
1069                   sg.addSequence(aa[selectedRow].sequenceRef, true);
1070                 }
1071               }
1072             }
1073             else
1074             {
1075               sg = new SequenceGroup();
1076               sg.setStartRes(0);
1077               sg.setEndRes(ap.av.getAlignment().getWidth() - 1);
1078               sg.addSequence(aa[selectedRow].sequenceRef, false);
1079             }
1080             ap.av.setSelectionGroup(sg);
1081             ap.paintAlignment(false, false);
1082             PaintRefresher.Refresh(ap, ap.av.getSequenceSetId());
1083             ap.av.sendSelection();
1084           }
1085
1086         }
1087       }
1088       return;
1089     }
1090   }
1091
1092   /**
1093    * do a single sequence copy to jalview and the system clipboard
1094    * 
1095    * @param sq
1096    *          sequence to be copied to clipboard
1097    */
1098   protected void copy_annotseqtoclipboard(SequenceI sq)
1099   {
1100     SequenceI[] seqs = new SequenceI[] { sq };
1101     String[] omitHidden = null;
1102     SequenceI[] dseqs = new SequenceI[] { sq.getDatasetSequence() };
1103     if (dseqs[0] == null)
1104     {
1105       dseqs[0] = new Sequence(sq);
1106       dseqs[0].setSequence(AlignSeq.extractGaps(Comparison.GapChars,
1107               sq.getSequenceAsString()));
1108
1109       sq.setDatasetSequence(dseqs[0]);
1110     }
1111     Alignment ds = new Alignment(dseqs);
1112     if (av.hasHiddenColumns())
1113     {
1114       Iterator<int[]> it = av.getAlignment().getHiddenColumns()
1115               .getVisContigsIterator(0, sq.getLength(), false);
1116       omitHidden = new String[] { sq.getSequenceStringFromIterator(it) };
1117     }
1118
1119     int[] alignmentStartEnd = new int[] { 0, ds.getWidth() - 1 };
1120     if (av.hasHiddenColumns())
1121     {
1122       alignmentStartEnd = av.getAlignment().getHiddenColumns()
1123               .getVisibleStartAndEndIndex(av.getAlignment().getWidth());
1124     }
1125
1126     String output = new FormatAdapter().formatSequences(FileFormat.Fasta,
1127             seqs, omitHidden, alignmentStartEnd);
1128
1129     Toolkit.getDefaultToolkit().getSystemClipboard()
1130             .setContents(new StringSelection(output), Desktop.instance);
1131
1132     HiddenColumns hiddenColumns = null;
1133
1134     if (av.hasHiddenColumns())
1135     {
1136       hiddenColumns = new HiddenColumns(
1137               av.getAlignment().getHiddenColumns());
1138     }
1139
1140     Desktop.jalviewClipboard = new Object[] { seqs, ds, // what is the dataset
1141                                                         // of a consensus
1142                                                         // sequence ? need to
1143                                                         // flag
1144         // sequence as special.
1145         hiddenColumns };
1146   }
1147
1148   /**
1149    * DOCUMENT ME!
1150    * 
1151    * @param g1
1152    *          DOCUMENT ME!
1153    */
1154   @Override
1155   public void paintComponent(Graphics g)
1156   {
1157
1158     int width = getWidth();
1159     if (width == 0)
1160     {
1161       width = ap.calculateIdWidth().width;
1162     }
1163
1164     Graphics2D g2 = (Graphics2D) g;
1165     if (av.antiAlias)
1166     {
1167       g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
1168               RenderingHints.VALUE_ANTIALIAS_ON);
1169     }
1170
1171     drawComponent(g2, true, width, true);
1172   }
1173
1174   /**
1175    * Draw the full set of annotation Labels for the alignment at the given
1176    * cursor
1177    * 
1178    * @param g
1179    *          Graphics2D instance (needed for font scaling)
1180    * @param width
1181    *          Width for scaling labels
1182    * 
1183    */
1184   public void drawComponent(Graphics g, int width)
1185   {
1186     drawComponent(g, false, width, true);
1187   }
1188
1189   /**
1190    * Draw the full set of annotation Labels for the alignment at the given
1191    * cursor
1192    * 
1193    * @param g
1194    *          Graphics2D instance (needed for font scaling)
1195    * @param clip
1196    *          - true indicates that only current visible area needs to be
1197    *          rendered
1198    * @param width
1199    *          Width for scaling labels
1200    */
1201   public void drawComponent(Graphics g, boolean clip, int givenWidth,
1202           boolean forGUI)
1203   {
1204     int width = givenWidth;
1205     IdwidthAdjuster iwa = null;
1206     if (ap != null)
1207     {
1208       iwa = ap.idwidthAdjuster;
1209       if ((Cache.getDefault(ADJUST_ANNOTATION_LABELS_WIDTH_PREF, true)
1210               || Jalview.isHeadlessMode()))
1211       {
1212         Graphics2D g2d = (Graphics2D) g;
1213         Graphics dummy = g2d.create();
1214         int newAnnotationIdWidth = drawLabels(dummy, clip, width, false,
1215                 forGUI, null, false);
1216         dummy.dispose();
1217         Dimension d = ap.calculateDefaultAlignmentIdWidth();
1218         int alignmentIdWidth = d.width;
1219         if (iwa != null && !iwa.manuallyAdjusted())
1220         {
1221           // If no manual adjustment to ID column with has been made then adjust
1222           // width match widest of alignment or annotation id widths
1223           boolean allowShrink = Cache.getDefault("ALLOW_SHRINK_ID_WIDTH",
1224                   false);
1225           width = Math.max(alignmentIdWidth, newAnnotationIdWidth);
1226           if (clip && width < givenWidth && !allowShrink)
1227           {
1228             width = givenWidth;
1229           }
1230         }
1231         else if (newAnnotationIdWidth != annotationIdWidth
1232                 && newAnnotationIdWidth > givenWidth
1233                 && newAnnotationIdWidth > alignmentIdWidth)
1234         {
1235           // otherwise if the annotation id width has become larger than the
1236           // current id width, increase
1237           width = newAnnotationIdWidth;
1238           annotationIdWidth = newAnnotationIdWidth;
1239         }
1240         // set the width if it's changed
1241         if (width != ap.av.getIdWidth())
1242         {
1243           iwa.setWidth(width);
1244         }
1245       }
1246     }
1247     else
1248     {
1249       int newAnnotationIdWidth = drawLabels(g, clip, width, false, forGUI,
1250               null, false);
1251       width = newAnnotationIdWidth < givenWidth ? givenWidth
1252               : Math.min(newAnnotationIdWidth, givenWidth);
1253     }
1254     drawLabels(g, clip, width, true, forGUI, null, false);
1255   }
1256
1257   /**
1258    * Render the full set of annotation Labels for the alignment at the given
1259    * cursor. If actuallyDraw is false or g is null then no actual drawing will
1260    * occur, but the widest label width will be returned. If g is null then
1261    * fmetrics must be supplied.
1262    * 
1263    * @param g
1264    *          Graphics2D instance (used for rendering and font scaling if no
1265    *          fmetrics supplied)
1266    * @param clip
1267    *          - true indicates that only current visible area needs to be
1268    *          rendered
1269    * @param width
1270    *          Width for scaling labels
1271    * @param actuallyDraw
1272    *          - when false, no graphics are rendered to g0
1273    * @param forGUI
1274    *          - when false, GUI relevant marks like indicators for dragging
1275    *          annotation panel height are not rendered
1276    * @param fmetrics
1277    *          FontMetrics if Graphics object g is null
1278    * @param includeHidden
1279    *          - when true returned width includes labels in hidden row width
1280    *          calculation
1281    * @return the width of the annotation labels.
1282    */
1283   public int drawLabels(Graphics g0, boolean clip, int width,
1284           boolean actuallyDraw, boolean forGUI, FontMetrics fmetrics,
1285           boolean includeHidden)
1286   {
1287     if (clip)
1288     {
1289       clip = Cache.getDefault("MOVE_SEQUENCE_ID_WITH_VISIBLE_ANNOTATIONS",
1290               true);
1291     }
1292     Graphics g = null;
1293     // create a dummy Graphics object if not drawing and one is supplied
1294     if (g0 != null)
1295     {
1296       if (!actuallyDraw)
1297       {
1298         Graphics2D g2d = (Graphics2D) g0;
1299         g = g2d.create();
1300       }
1301       else
1302       {
1303         g = g0;
1304       }
1305     }
1306     int actualWidth = 0;
1307     if (g != null)
1308     {
1309       if (av.getFont().getSize() < 10)
1310       {
1311         g.setFont(font);
1312       }
1313       else
1314       {
1315         g.setFont(av.getFont());
1316       }
1317     }
1318
1319     FontMetrics fm = fmetrics == null ? g.getFontMetrics(g.getFont())
1320             : fmetrics;
1321     if (actuallyDraw)
1322     {
1323       g.setColor(Color.white);
1324       g.fillRect(0, 0, getWidth(), getHeight());
1325
1326       if (!Cache.getDefault(RESIZE_MARGINS_MARK_PREF, false)
1327               && !av.getWrapAlignment() && forGUI)
1328       {
1329         g.setColor(Color.LIGHT_GRAY);
1330         g.drawLine(0, HEIGHT_ADJUSTER_HEIGHT / 4, HEIGHT_ADJUSTER_WIDTH / 4,
1331                 HEIGHT_ADJUSTER_HEIGHT / 4);
1332         g.drawLine(0, 3 * HEIGHT_ADJUSTER_HEIGHT / 4,
1333                 HEIGHT_ADJUSTER_WIDTH / 4, 3 * HEIGHT_ADJUSTER_HEIGHT / 4);
1334
1335       }
1336     }
1337
1338     if (actuallyDraw)
1339     {
1340       g.translate(0, getScrollOffset());
1341       g.setColor(Color.black);
1342     }
1343     SequenceI lastSeqRef = null;
1344     String lastLabel = null;
1345     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
1346     int fontHeight = g != null ? g.getFont().getSize()
1347             : fm.getFont().getSize();
1348     int y = 0;
1349     int x = 0;
1350     int graphExtras = 0;
1351     int offset = 0;
1352     Font baseFont = g != null ? g.getFont() : fm.getFont();
1353     FontMetrics baseMetrics = fm;
1354     int ofontH = fontHeight;
1355     int sOffset = 0;
1356     int visHeight = 0;
1357     int[] visr = (ap != null && ap.getAnnotationPanel() != null)
1358             ? ap.getAnnotationPanel().getVisibleVRange()
1359             : null;
1360     if (clip && visr != null)
1361     {
1362       sOffset = visr[0];
1363       visHeight = visr[1];
1364     }
1365     boolean visible = true, before = false, after = false;
1366     if (aa != null)
1367     {
1368       hasHiddenRows = false;
1369       int olY = 0;
1370       int nexAA = 0;
1371       for (int i = 0; i < aa.length; i++)
1372       {
1373         visible = true;
1374         if (!aa[i].visible && !includeHidden)
1375         {
1376           hasHiddenRows = true;
1377           continue;
1378         }
1379         olY = y;
1380         // look ahead to next annotation
1381         for (nexAA = i + 1; nexAA < aa.length
1382                 && (!aa[nexAA].visible && includeHidden); nexAA++)
1383           ;
1384         y += aa[i].height;
1385         if (clip)
1386         {
1387           if (y < sOffset)
1388           {
1389             if (!before)
1390             {
1391               if (debugRedraw)
1392               {
1393                 jalview.bin.Console.outPrintln("before vis: " + i);
1394               }
1395               before = true;
1396             }
1397             // don't draw what isn't visible
1398             continue;
1399           }
1400           if (olY > visHeight)
1401           {
1402
1403             if (!after)
1404             {
1405               if (debugRedraw)
1406               {
1407                 jalview.bin.Console.outPrintln(
1408                         "Scroll offset: " + sOffset + " after vis: " + i);
1409               }
1410               after = true;
1411             }
1412             // don't draw what isn't visible
1413             continue;
1414           }
1415         }
1416         if (actuallyDraw && g != null)
1417         {
1418           g.setColor(Color.black);
1419         }
1420         offset = -aa[i].height / 2;
1421
1422         if (aa[i].hasText)
1423         {
1424           offset += fm.getHeight() / 2;
1425           offset -= fm.getDescent();
1426         }
1427         else
1428         {
1429           offset += fm.getDescent();
1430         }
1431         String label = aa[i].label;
1432         boolean vertBar = false;
1433         if ((lastLabel != null && lastLabel.equals(label)))
1434         {
1435           label = aa[i].description;
1436         }
1437         else
1438         {
1439           if (nexAA < aa.length && label.equals(aa[nexAA].label)) // &&
1440                                                                   // aa[nexY].sequenceRef==aa[i].sequenceRef)
1441           {
1442             lastLabel = label;
1443             // next label is the same as this label
1444             label = aa[i].description;
1445           }
1446           else
1447           {
1448             lastLabel = label;
1449           }
1450         }
1451         if (aa[i].sequenceRef != null)
1452         {
1453           if (aa[i].sequenceRef != lastSeqRef)
1454           {
1455             label = aa[i].sequenceRef.getName() + " " + label;
1456             // TODO record relationship between sequence and this annotation and
1457             // display it here
1458           }
1459           else
1460           {
1461             vertBar = true;
1462           }
1463         }
1464
1465         int labelWidth = fm.stringWidth(label) + 3;
1466         x = width - labelWidth;
1467
1468         if (aa[i].graphGroup > -1)
1469         {
1470           int groupSize = 0;
1471           // TODO: JAL-1291 revise rendering model so the graphGroup map is
1472           // computed efficiently for all visible labels
1473           for (int gg = 0; gg < aa.length; gg++)
1474           {
1475             if (aa[gg].graphGroup == aa[i].graphGroup)
1476             {
1477               groupSize++;
1478             }
1479           }
1480           if (groupSize * (fontHeight + 8) < aa[i].height)
1481           {
1482             graphExtras = (aa[i].height - (groupSize * (fontHeight + 8)))
1483                     / 2;
1484           }
1485           else
1486           {
1487             // scale font to fit
1488             float h = aa[i].height / (float) groupSize, s;
1489             if (h < 9)
1490             {
1491               visible = false;
1492             }
1493             else
1494             {
1495               fontHeight = -8 + (int) h;
1496               s = ((float) fontHeight) / (float) ofontH;
1497               Font f = baseFont
1498                       .deriveFont(AffineTransform.getScaleInstance(s, s));
1499               Canvas c = new Canvas();
1500               fm = c.getFontMetrics(f);
1501               if (actuallyDraw && g != null)
1502               {
1503                 g.setFont(f);
1504                 // fm = g.getFontMetrics();
1505                 graphExtras = (aa[i].height
1506                         - (groupSize * (fontHeight + 8))) / 2;
1507               }
1508             }
1509           }
1510           if (visible)
1511           {
1512             for (int gg = 0; gg < aa.length; gg++)
1513             {
1514               if (aa[gg].graphGroup == aa[i].graphGroup)
1515               {
1516                 labelWidth = fm.stringWidth(aa[gg].label) + 3;
1517                 x = width - labelWidth;
1518                 if (actuallyDraw && g != null)
1519                 {
1520                   g.drawString(aa[gg].label, x, y - graphExtras);
1521
1522                   if (aa[gg]._linecolour != null)
1523                   {
1524
1525                     g.setColor(aa[gg]._linecolour);
1526                     g.drawLine(x, y - graphExtras + 3,
1527                             x + fm.stringWidth(aa[gg].label),
1528                             y - graphExtras + 3);
1529                   }
1530
1531                   g.setColor(Color.black);
1532                 }
1533                 graphExtras += fontHeight + 8;
1534               }
1535             }
1536           }
1537           if (actuallyDraw && g != null)
1538           {
1539             g.setFont(baseFont);
1540           }
1541           fm = baseMetrics;
1542           fontHeight = ofontH;
1543         }
1544         else
1545         {
1546           if (actuallyDraw && g != null)
1547           {
1548             if (vertBar)
1549             {
1550               g.drawLine(width - 3, y + offset - fontHeight, width - 3,
1551                       (int) (y - 1.5 * aa[i].height - offset - fontHeight));
1552               // g.drawLine(20, y + offset, x - 20, y + offset);
1553
1554             }
1555             g.drawString(label, x, y + offset);
1556           }
1557         }
1558         lastSeqRef = aa[i].sequenceRef;
1559
1560         if (labelWidth > actualWidth)
1561         {
1562           actualWidth = labelWidth;
1563         }
1564       }
1565     }
1566
1567     if (!resizePanel && dragEvent != null && aa != null && selectedRow > -1
1568             && selectedRow < aa.length)
1569     {
1570       if (actuallyDraw && g != null)
1571       {
1572         g.setColor(Color.lightGray);
1573         g.drawString(
1574                 (aa[selectedRow].sequenceRef == null ? ""
1575                         : aa[selectedRow].sequenceRef.getName())
1576                         + aa[selectedRow].label,
1577                 dragEvent.getX(), dragEvent.getY() - getScrollOffset());
1578       }
1579     }
1580
1581     if (!av.getWrapAlignment() && ((aa == null) || (aa.length < 1)))
1582     {
1583       if (actuallyDraw && g != null)
1584       {
1585         g.drawString(MessageManager.getString("label.right_click"), 2, 8);
1586         g.drawString(MessageManager.getString("label.to_add_annotation"), 2,
1587                 18);
1588       }
1589     }
1590
1591     return actualWidth;
1592   }
1593
1594   public int getScrollOffset()
1595   {
1596     return scrollOffset;
1597   }
1598
1599   @Override
1600   public void mouseEntered(MouseEvent e)
1601   {
1602   }
1603
1604   public void drawComponentNotGUI(Graphics idGraphics, int idWidth)
1605   {
1606     drawComponent(idGraphics, false, idWidth, false);
1607   }
1608 }