JAL-1759 corrected syntax for 'atom picked' callback (toggles label
[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 jalview.analysis.AlignmentUtils;
24 import jalview.datamodel.Alignment;
25 import jalview.datamodel.AlignmentAnnotation;
26 import jalview.datamodel.Annotation;
27 import jalview.datamodel.Sequence;
28 import jalview.datamodel.SequenceGroup;
29 import jalview.datamodel.SequenceI;
30 import jalview.io.FormatAdapter;
31 import jalview.util.MessageManager;
32
33 import java.awt.Color;
34 import java.awt.Dimension;
35 import java.awt.Font;
36 import java.awt.FontMetrics;
37 import java.awt.Graphics;
38 import java.awt.Graphics2D;
39 import java.awt.Image;
40 import java.awt.MediaTracker;
41 import java.awt.RenderingHints;
42 import java.awt.Toolkit;
43 import java.awt.datatransfer.StringSelection;
44 import java.awt.event.ActionEvent;
45 import java.awt.event.ActionListener;
46 import java.awt.event.MouseEvent;
47 import java.awt.event.MouseListener;
48 import java.awt.event.MouseMotionListener;
49 import java.awt.geom.AffineTransform;
50 import java.awt.image.BufferedImage;
51 import java.util.ArrayList;
52 import java.util.Arrays;
53 import java.util.Collections;
54 import java.util.List;
55 import java.util.regex.Pattern;
56
57 import javax.swing.JCheckBoxMenuItem;
58 import javax.swing.JMenuItem;
59 import javax.swing.JPanel;
60 import javax.swing.JPopupMenu;
61 import javax.swing.SwingUtilities;
62 import javax.swing.ToolTipManager;
63
64 /**
65  * DOCUMENT ME!
66  * 
67  * @author $author$
68  * @version $Revision$
69  */
70 public class AnnotationLabels extends JPanel implements MouseListener,
71         MouseMotionListener, ActionListener
72 {
73   private static final Pattern LEFT_ANGLE_BRACKET_PATTERN = Pattern.compile("<");
74
75   String TOGGLE_LABELSCALE = MessageManager.getString("label.scale_label_to_column");
76
77   String ADDNEW = MessageManager.getString("label.add_new_row");
78
79   String EDITNAME = MessageManager.getString("label.edit_label_description");
80
81   String HIDE = MessageManager.getString("label.hide_row");
82
83   String DELETE = MessageManager.getString("label.delete_row");
84
85   String SHOWALL = MessageManager.getString("label.show_all_hidden_rows");
86
87   String OUTPUT_TEXT = MessageManager.getString("label.export_annotation");
88
89   String COPYCONS_SEQ = MessageManager.getString("label.copy_consensus_sequence");
90
91   boolean resizePanel = false;
92
93   Image image;
94
95   AlignmentPanel ap;
96
97   AlignViewport av;
98
99   boolean resizing = false;
100
101   MouseEvent dragEvent;
102
103   int oldY;
104
105   int selectedRow;
106
107   private int scrollOffset = 0;
108
109   Font font = new Font("Arial", Font.PLAIN, 11);
110
111   private boolean hasHiddenRows;
112
113   /**
114    * Creates a new AnnotationLabels object.
115    * 
116    * @param ap
117    *          DOCUMENT ME!
118    */
119   public AnnotationLabels(AlignmentPanel ap)
120   {
121     this.ap = ap;
122     av = ap.av;
123     ToolTipManager.sharedInstance().registerComponent(this);
124
125     java.net.URL url = getClass().getResource("/images/idwidth.gif");
126     Image temp = null;
127
128     if (url != null)
129     {
130       temp = java.awt.Toolkit.getDefaultToolkit().createImage(url);
131     }
132
133     try
134     {
135       MediaTracker mt = new MediaTracker(this);
136       mt.addImage(temp, 0);
137       mt.waitForID(0);
138     } catch (Exception ex)
139     {
140     }
141
142     BufferedImage bi = new BufferedImage(temp.getHeight(this),
143             temp.getWidth(this), BufferedImage.TYPE_INT_RGB);
144     Graphics2D g = (Graphics2D) bi.getGraphics();
145     g.rotate(Math.toRadians(90));
146     g.drawImage(temp, 0, -bi.getWidth(this), this);
147     image = bi;
148
149     addMouseListener(this);
150     addMouseMotionListener(this);
151     addMouseWheelListener(ap.getAnnotationPanel());
152   }
153
154   public AnnotationLabels(AlignViewport av)
155   {
156     this.av = av;
157   }
158
159   /**
160    * DOCUMENT ME!
161    * 
162    * @param y
163    *          DOCUMENT ME!
164    */
165   public void setScrollOffset(int y)
166   {
167     scrollOffset = y;
168     repaint();
169   }
170
171   /**
172    * sets selectedRow to -2 if no annotation preset, -1 if no visible row is at
173    * y
174    * 
175    * @param y
176    *          coordinate position to search for a row
177    */
178   void getSelectedRow(int y)
179   {
180     int height = 0;
181     AlignmentAnnotation[] aa = ap.av.getAlignment()
182             .getAlignmentAnnotation();
183     selectedRow = -2;
184     if (aa != null)
185     {
186       for (int i = 0; i < aa.length; i++)
187       {
188         selectedRow = -1;
189         if (!aa[i].visible)
190         {
191           continue;
192         }
193
194         height += aa[i].height;
195
196         if (y < height)
197         {
198           selectedRow = i;
199
200           break;
201         }
202       }
203     }
204   }
205
206   /**
207    * DOCUMENT ME!
208    * 
209    * @param evt
210    *          DOCUMENT ME!
211    */
212   public void actionPerformed(ActionEvent evt)
213   {
214     AlignmentAnnotation[] aa = ap.av.getAlignment()
215             .getAlignmentAnnotation();
216
217     if (evt.getActionCommand().equals(ADDNEW))
218     {
219       AlignmentAnnotation newAnnotation = new AlignmentAnnotation(null,
220               null, new Annotation[ap.av.getAlignment().getWidth()]);
221
222       if (!editLabelDescription(newAnnotation))
223       {
224         return;
225       }
226
227       ap.av.getAlignment().addAnnotation(newAnnotation);
228       ap.av.getAlignment().setAnnotationIndex(newAnnotation, 0);
229     }
230     else if (evt.getActionCommand().equals(EDITNAME))
231     {
232       editLabelDescription(aa[selectedRow]);
233       repaint();
234     }
235     else if (evt.getActionCommand().equals(HIDE))
236     {
237       aa[selectedRow].visible = false;
238     }
239     else if (evt.getActionCommand().equals(DELETE))
240     {
241       ap.av.getAlignment().deleteAnnotation(aa[selectedRow]);
242     }
243     else if (evt.getActionCommand().equals(SHOWALL))
244     {
245       for (int i = 0; i < aa.length; i++)
246       {
247         if (!aa[i].visible && aa[i].annotations != null)
248         {
249           aa[i].visible = true;
250         }
251       }
252     }
253     else if (evt.getActionCommand().equals(OUTPUT_TEXT))
254     {
255       new AnnotationExporter().exportAnnotations(ap,
256               new AlignmentAnnotation[]
257       { aa[selectedRow] });
258     }
259     else if (evt.getActionCommand().equals(COPYCONS_SEQ))
260     {
261       SequenceI cons = null;
262       if (aa[selectedRow].groupRef != null)
263       {
264         cons = aa[selectedRow].groupRef.getConsensusSeq();
265       }
266       else
267       {
268         cons = av.getConsensusSeq();
269       }
270       if (cons != null)
271       {
272         copy_annotseqtoclipboard(cons);
273       }
274
275     }
276     else if (evt.getActionCommand().equals(TOGGLE_LABELSCALE))
277     {
278       aa[selectedRow].scaleColLabel = !aa[selectedRow].scaleColLabel;
279     }
280
281     refresh();
282
283   }
284
285   /**
286    * Redraw sensibly.
287    */
288   protected void refresh()
289   {
290     ap.validateAnnotationDimensions(false);
291     ap.addNotify();
292     ap.repaint();
293   }
294
295   /**
296    * DOCUMENT ME!
297    * 
298    * @param e
299    *          DOCUMENT ME!
300    */
301   boolean editLabelDescription(AlignmentAnnotation annotation)
302   {
303     EditNameDialog dialog = new EditNameDialog(annotation.label,
304             annotation.description, "       Annotation Name ",
305             "Annotation Description ", "Edit Annotation Name/Description",
306             ap.alignFrame);
307
308     if (!dialog.accept)
309     {
310       return false;
311     }
312
313     annotation.label = dialog.getName();
314
315     String text = dialog.getDescription();
316     if (text != null && text.length() == 0)
317     {
318       text = null;
319     }
320     annotation.description = text;
321
322     return true;
323   }
324
325   /**
326    * DOCUMENT ME!
327    * 
328    * @param evt
329    *          DOCUMENT ME!
330    */
331   public void mousePressed(MouseEvent evt)
332   {
333     getSelectedRow(evt.getY() - getScrollOffset());
334     oldY = evt.getY();
335   }
336
337   /**
338    * DOCUMENT ME!
339    * 
340    * @param evt
341    *          DOCUMENT ME!
342    */
343   public void mouseReleased(MouseEvent evt)
344   {
345     int start = selectedRow;
346     getSelectedRow(evt.getY() - getScrollOffset());
347     int end = selectedRow;
348
349     if (start != end)
350     {
351       // Swap these annotations
352       AlignmentAnnotation startAA = ap.av.getAlignment()
353               .getAlignmentAnnotation()[start];
354       if (end == -1)
355       {
356         end = ap.av.getAlignment().getAlignmentAnnotation().length - 1;
357       }
358       AlignmentAnnotation endAA = ap.av.getAlignment()
359               .getAlignmentAnnotation()[end];
360
361       ap.av.getAlignment().getAlignmentAnnotation()[end] = startAA;
362       ap.av.getAlignment().getAlignmentAnnotation()[start] = endAA;
363     }
364
365     resizePanel = false;
366     dragEvent = null;
367     repaint();
368     ap.getAnnotationPanel().repaint();
369   }
370
371   /**
372    * DOCUMENT ME!
373    * 
374    * @param evt
375    *          DOCUMENT ME!
376    */
377   public void mouseEntered(MouseEvent evt)
378   {
379     if (evt.getY() < 10)
380     {
381       resizePanel = true;
382       repaint();
383     }
384   }
385
386   /**
387    * DOCUMENT ME!
388    * 
389    * @param evt
390    *          DOCUMENT ME!
391    */
392   public void mouseExited(MouseEvent evt)
393   {
394     if (dragEvent == null)
395     {
396       resizePanel = false;
397       repaint();
398     }
399   }
400
401   /**
402    * DOCUMENT ME!
403    * 
404    * @param evt
405    *          DOCUMENT ME!
406    */
407   public void mouseDragged(MouseEvent evt)
408   {
409     dragEvent = evt;
410
411     if (resizePanel)
412     {
413       Dimension d = ap.annotationScroller.getPreferredSize();
414       int dif = evt.getY() - oldY;
415
416       dif /= ap.av.getCharHeight();
417       dif *= ap.av.getCharHeight();
418
419       if ((d.height - dif) > 20)
420       {
421         ap.annotationScroller.setPreferredSize(new Dimension(d.width,
422                 d.height - dif));
423         d = ap.annotationSpaceFillerHolder.getPreferredSize();
424         ap.annotationSpaceFillerHolder.setPreferredSize(new Dimension(
425                 d.width, d.height - dif));
426         ap.paintAlignment(true);
427       }
428
429       ap.addNotify();
430     }
431     else
432     {
433       repaint();
434     }
435   }
436
437   /**
438    * DOCUMENT ME!
439    * 
440    * @param evt
441    *          DOCUMENT ME!
442    */
443   public void mouseMoved(MouseEvent evt)
444   {
445     resizePanel = evt.getY() < 10;
446
447     getSelectedRow(evt.getY() - getScrollOffset());
448
449     if (selectedRow > -1
450             && ap.av.getAlignment().getAlignmentAnnotation().length > selectedRow)
451     {
452       AlignmentAnnotation aa = ap.av.getAlignment()
453               .getAlignmentAnnotation()[selectedRow];
454
455       StringBuffer desc = new StringBuffer();
456       if (aa.description != null
457               && !aa.description.equals("New description"))
458       {
459         // TODO: we could refactor and merge this code with the code in
460         // jalview.gui.SeqPanel.mouseMoved(..) that formats sequence feature
461         // tooltips
462         desc.append(aa.getDescription(true).trim());
463         // check to see if the description is an html fragment.
464         if (desc.length() < 6
465                 || (desc.substring(0, 6).toLowerCase().indexOf("<html>") < 0))
466         {
467           // clean the description ready for embedding in html
468           desc = new StringBuffer(LEFT_ANGLE_BRACKET_PATTERN.matcher(desc)
469                   .replaceAll("&lt;"));
470           desc.insert(0, "<html>");
471         }
472         else
473         {
474           // remove terminating html if any
475           int i = desc.substring(desc.length() - 7).toLowerCase()
476                   .lastIndexOf("</html>");
477           if (i > -1)
478           {
479             desc.setLength(desc.length() - 7 + i);
480           }
481         }
482         if (aa.hasScore())
483         {
484           desc.append("<br/>");
485         }
486         // if (aa.hasProperties())
487         // {
488         // desc.append("<table>");
489         // for (String prop : aa.getProperties())
490         // {
491         // desc.append("<tr><td>" + prop + "</td><td>"
492         // + aa.getProperty(prop) + "</td><tr>");
493         // }
494         // desc.append("</table>");
495         // }
496       }
497       else
498       {
499         // begin the tooltip's html fragment
500         desc.append("<html>");
501         if (aa.hasScore())
502         {
503           // TODO: limit precision of score to avoid noise from imprecise
504           // doubles
505           // (64.7 becomes 64.7+/some tiny value).
506           desc.append(" Score: " + aa.score);
507         }
508       }
509       if (desc.length() > 6)
510       {
511         desc.append("</html>");
512         this.setToolTipText(desc.toString());
513       }
514       else
515       {
516         this.setToolTipText(null);
517       }
518     }
519   }
520
521   /**
522    * DOCUMENT ME!
523    * 
524    * @param evt
525    *          DOCUMENT ME!
526    */
527   public void mouseClicked(MouseEvent evt)
528   {
529     final AlignmentAnnotation[] aa = ap.av.getAlignment()
530             .getAlignmentAnnotation();
531     if (SwingUtilities.isLeftMouseButton(evt))
532     {
533       if (selectedRow > -1 && selectedRow < aa.length)
534       {
535         if (aa[selectedRow].groupRef != null)
536         {
537           if (evt.getClickCount() >= 2)
538           {
539             // todo: make the ap scroll to the selection - not necessary, first
540             // click highlights/scrolls, second selects
541             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(null);
542             ap.av.setSelectionGroup(// new SequenceGroup(
543             aa[selectedRow].groupRef); // );
544             ap.paintAlignment(false);
545             PaintRefresher.Refresh(ap, ap.av.getSequenceSetId());
546             ap.av.sendSelection();
547           }
548           else
549           {
550             ap.getSeqPanel().ap.getIdPanel()
551                     .highlightSearchResults(aa[selectedRow].groupRef
552                             .getSequences(null));
553           }
554           return;
555         }
556         else if (aa[selectedRow].sequenceRef != null)
557         {
558           if (evt.getClickCount() == 1)
559           {
560             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(Arrays
561                     .asList(new SequenceI[]
562                     { aa[selectedRow].sequenceRef }));
563           }
564           else if (evt.getClickCount() >= 2)
565           {
566             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(null);
567             SequenceGroup sg = ap.av.getSelectionGroup();
568             if (sg!=null)
569             {
570               // we make a copy rather than edit the current selection if no modifiers pressed
571               // see Enhancement JAL-1557
572               if (!(evt.isControlDown() || evt.isShiftDown()))
573               {
574                 sg = new SequenceGroup(sg);
575                 sg.clear();
576                 sg.addSequence(aa[selectedRow].sequenceRef, false);
577               } else {
578                 if (evt.isControlDown())
579                 {
580                   sg.addOrRemove(aa[selectedRow].sequenceRef, true);
581                 } else {
582                   // notionally, we should also add intermediate sequences from last added sequence ?
583                   sg.addSequence(aa[selectedRow].sequenceRef, true);
584                 }
585               }
586             } else {
587               sg = new SequenceGroup();
588               sg.setStartRes(0);
589               sg.setEndRes(ap.av.getAlignment().getWidth()-1);
590               sg.addSequence(aa[selectedRow].sequenceRef, false);
591             }
592             ap.av.setSelectionGroup(sg);
593             ap.av.sendSelection();
594             ap.paintAlignment(false);
595             PaintRefresher.Refresh(ap, ap.av.getSequenceSetId());
596           }
597
598         }
599       }
600     }
601     if (!SwingUtilities.isRightMouseButton(evt))
602     {
603       return;
604     }
605
606     JPopupMenu pop = new JPopupMenu(
607             MessageManager.getString("label.annotations"));
608     JMenuItem item = new JMenuItem(ADDNEW);
609     item.addActionListener(this);
610     pop.add(item);
611     if (selectedRow < 0)
612     {
613       if (hasHiddenRows)
614       { // let the user make everything visible again
615         item = new JMenuItem(SHOWALL);
616         item.addActionListener(this);
617         pop.add(item);
618       }
619       pop.show(this, evt.getX(), evt.getY());
620       return;
621     }
622     item = new JMenuItem(EDITNAME);
623     item.addActionListener(this);
624     pop.add(item);
625     item = new JMenuItem(HIDE);
626     item.addActionListener(this);
627     pop.add(item);
628     // JAL-1264 hide all sequence-specific annotations of this type
629     if (selectedRow < aa.length)
630     {
631       if (aa[selectedRow].sequenceRef != null)
632       {
633         final String label = aa[selectedRow].label;
634         JMenuItem hideType = new JMenuItem();
635         String text = MessageManager.getString("label.hide_all") + " " + label;
636         hideType.setText(text);
637         hideType.addActionListener(new ActionListener()
638         {
639           @Override
640           public void actionPerformed(ActionEvent e)
641           {
642             AlignmentUtils.showOrHideSequenceAnnotations(
643                     ap.av.getAlignment(), Collections.singleton(label),
644                     null, false, false);
645             // for (AlignmentAnnotation ann : ap.av.getAlignment()
646             // .getAlignmentAnnotation())
647             // {
648             // if (ann.sequenceRef != null && ann.label != null
649             // && ann.label.equals(label))
650             // {
651             // ann.visible = false;
652             // }
653             // }
654             refresh();
655           }
656         });
657         pop.add(hideType);
658       }
659     }
660     item = new JMenuItem(DELETE);
661     item.addActionListener(this);
662     pop.add(item);
663     if (hasHiddenRows)
664     {
665       item = new JMenuItem(SHOWALL);
666       item.addActionListener(this);
667       pop.add(item);
668     }
669     item = new JMenuItem(OUTPUT_TEXT);
670     item.addActionListener(this);
671     pop.add(item);
672     // TODO: annotation object should be typed for autocalculated/derived
673     // property methods
674     if (selectedRow < aa.length)
675     {
676       final String label = aa[selectedRow].label;
677       if (!aa[selectedRow].autoCalculated)
678       {
679         if (aa[selectedRow].graph == AlignmentAnnotation.NO_GRAPH)
680         {
681           // display formatting settings for this row.
682           pop.addSeparator();
683           // av and sequencegroup need to implement same interface for
684           item = new JCheckBoxMenuItem(TOGGLE_LABELSCALE,
685                   aa[selectedRow].scaleColLabel);
686           item.addActionListener(this);
687           pop.add(item);
688         }
689       }
690       else if (label.indexOf("Consensus") > -1)
691       {
692         pop.addSeparator();
693         // av and sequencegroup need to implement same interface for
694         final JCheckBoxMenuItem cbmi = new JCheckBoxMenuItem(
695                         MessageManager.getString("label.ignore_gaps_consensus"),
696                 (aa[selectedRow].groupRef != null) ? aa[selectedRow].groupRef
697                         .getIgnoreGapsConsensus() : ap.av
698                         .isIgnoreGapsConsensus());
699         final AlignmentAnnotation aaa = aa[selectedRow];
700         cbmi.addActionListener(new ActionListener()
701         {
702           public void actionPerformed(ActionEvent e)
703           {
704             if (aaa.groupRef != null)
705             {
706               // TODO: pass on reference to ap so the view can be updated.
707               aaa.groupRef.setIgnoreGapsConsensus(cbmi.getState());
708               ap.getAnnotationPanel().paint(ap.getAnnotationPanel().getGraphics());
709             }
710             else
711             {
712               ap.av.setIgnoreGapsConsensus(cbmi.getState(), ap);
713             }
714           }
715         });
716         pop.add(cbmi);
717         // av and sequencegroup need to implement same interface for
718         if (aaa.groupRef != null)
719         {
720           final JCheckBoxMenuItem chist = new JCheckBoxMenuItem(
721                           MessageManager.getString("label.show_group_histogram"),
722                   aa[selectedRow].groupRef.isShowConsensusHistogram());
723           chist.addActionListener(new ActionListener()
724           {
725             public void actionPerformed(ActionEvent e)
726             {
727               // TODO: pass on reference
728               // to ap
729               // so the
730               // view
731               // can be
732               // updated.
733               aaa.groupRef.setShowConsensusHistogram(chist.getState());
734               ap.repaint();
735               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
736             }
737           });
738           pop.add(chist);
739           final JCheckBoxMenuItem cprofl = new JCheckBoxMenuItem(
740                           MessageManager.getString("label.show_group_logo"),
741                   aa[selectedRow].groupRef.isShowSequenceLogo());
742           cprofl.addActionListener(new ActionListener()
743           {
744             public void actionPerformed(ActionEvent e)
745             {
746               // TODO: pass on reference
747               // to ap
748               // so the
749               // view
750               // can be
751               // updated.
752               aaa.groupRef.setshowSequenceLogo(cprofl.getState());
753               ap.repaint();
754               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
755             }
756           });
757           pop.add(cprofl);
758           final JCheckBoxMenuItem cproflnorm = new JCheckBoxMenuItem(
759                           MessageManager.getString("label.normalise_group_logo"),
760                   aa[selectedRow].groupRef.isNormaliseSequenceLogo());
761           cproflnorm.addActionListener(new ActionListener()
762           {
763             public void actionPerformed(ActionEvent e)
764             {
765
766               // TODO: pass on reference
767               // to ap
768               // so the
769               // view
770               // can be
771               // updated.
772               aaa.groupRef.setNormaliseSequenceLogo(cproflnorm.getState());
773               // automatically enable logo display if we're clicked
774               aaa.groupRef.setshowSequenceLogo(true);
775               ap.repaint();
776               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
777             }
778           });
779           pop.add(cproflnorm);
780         }
781         else
782         {
783           final JCheckBoxMenuItem chist = new JCheckBoxMenuItem(
784                           MessageManager.getString("label.show_histogram"), av.isShowConsensusHistogram());
785           chist.addActionListener(new ActionListener()
786           {
787             public void actionPerformed(ActionEvent e)
788             {
789               // TODO: pass on reference
790               // to ap
791               // so the
792               // view
793               // can be
794               // updated.
795               av.setShowConsensusHistogram(chist.getState());
796               ap.alignFrame.setMenusForViewport();
797               ap.repaint();
798               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
799             }
800           });
801           pop.add(chist);
802           final JCheckBoxMenuItem cprof = new JCheckBoxMenuItem(
803                           MessageManager.getString("label.show_logo"), av.isShowSequenceLogo());
804           cprof.addActionListener(new ActionListener()
805           {
806             public void actionPerformed(ActionEvent e)
807             {
808               // TODO: pass on reference
809               // to ap
810               // so the
811               // view
812               // can be
813               // updated.
814               av.setShowSequenceLogo(cprof.getState());
815               ap.alignFrame.setMenusForViewport();
816               ap.repaint();
817               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
818             }
819           });
820           pop.add(cprof);
821           final JCheckBoxMenuItem cprofnorm = new JCheckBoxMenuItem(
822                           MessageManager.getString("label.normalise_logo"), av.isNormaliseSequenceLogo());
823           cprofnorm.addActionListener(new ActionListener()
824           {
825             public void actionPerformed(ActionEvent e)
826             {
827               // TODO: pass on reference
828               // to ap
829               // so the
830               // view
831               // can be
832               // updated.
833               av.setShowSequenceLogo(true);
834               av.setNormaliseSequenceLogo(cprofnorm.getState());
835               ap.alignFrame.setMenusForViewport();
836               ap.repaint();
837               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
838             }
839           });
840           pop.add(cprofnorm);
841         }
842         final JMenuItem consclipbrd = new JMenuItem(COPYCONS_SEQ);
843         consclipbrd.addActionListener(this);
844         pop.add(consclipbrd);
845       }
846     }
847     pop.show(this, evt.getX(), evt.getY());
848   }
849
850   /**
851    * do a single sequence copy to jalview and the system clipboard
852    * 
853    * @param sq
854    *          sequence to be copied to clipboard
855    */
856   protected void copy_annotseqtoclipboard(SequenceI sq)
857   {
858     SequenceI[] seqs = new SequenceI[]
859     { sq };
860     String[] omitHidden = null;
861     SequenceI[] dseqs = new SequenceI[]
862     { sq.getDatasetSequence() };
863     if (dseqs[0] == null)
864     {
865       dseqs[0] = new Sequence(sq);
866       dseqs[0].setSequence(jalview.analysis.AlignSeq.extractGaps(
867               jalview.util.Comparison.GapChars, sq.getSequenceAsString()));
868
869       sq.setDatasetSequence(dseqs[0]);
870     }
871     Alignment ds = new Alignment(dseqs);
872     if (av.hasHiddenColumns())
873     {
874       omitHidden = av.getColumnSelection().getVisibleSequenceStrings(0,
875               sq.getLength(), seqs);
876     }
877
878     int[] alignmentStartEnd = new int[]
879     { 0, ds.getWidth() - 1 };
880     List<int[]> hiddenCols = av.getColumnSelection().getHiddenColumns();
881     if (hiddenCols != null)
882     {
883       alignmentStartEnd = AlignFrame.getStartEnd(alignmentStartEnd,
884               hiddenCols);
885     }
886     String output = new FormatAdapter().formatSequences("Fasta", seqs,
887             omitHidden, alignmentStartEnd);
888
889     Toolkit.getDefaultToolkit().getSystemClipboard()
890             .setContents(new StringSelection(output), Desktop.instance);
891
892     ArrayList<int[]> hiddenColumns = null;
893     if (av.hasHiddenColumns())
894     {
895       hiddenColumns = new ArrayList<int[]>();
896       for (int[] region : av.getColumnSelection().getHiddenColumns())
897       {
898         hiddenColumns.add(new int[]
899         { region[0], region[1] });
900       }
901     }
902
903     Desktop.jalviewClipboard = new Object[]
904     { seqs, ds, // what is the dataset of a consensus sequence ? need to flag
905         // sequence as special.
906         hiddenColumns };
907   }
908
909   /**
910    * DOCUMENT ME!
911    * 
912    * @param g1
913    *          DOCUMENT ME!
914    */
915   public void paintComponent(Graphics g)
916   {
917
918     int width = getWidth();
919     if (width == 0)
920     {
921       width = ap.calculateIdWidth().width + 4;
922     }
923
924     Graphics2D g2 = (Graphics2D) g;
925     if (av.antiAlias)
926     {
927       g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
928               RenderingHints.VALUE_ANTIALIAS_ON);
929     }
930
931     drawComponent(g2, true, width);
932
933   }
934
935   /**
936    * Draw the full set of annotation Labels for the alignment at the given
937    * cursor
938    * 
939    * @param g
940    *          Graphics2D instance (needed for font scaling)
941    * @param width
942    *          Width for scaling labels
943    * 
944    */
945   public void drawComponent(Graphics g, int width)
946   {
947     drawComponent(g, false, width);
948   }
949
950   private final boolean debugRedraw = false;
951
952   /**
953    * Draw the full set of annotation Labels for the alignment at the given
954    * cursor
955    * 
956    * @param g
957    *          Graphics2D instance (needed for font scaling)
958    * @param clip
959    *          - true indicates that only current visible area needs to be
960    *          rendered
961    * @param width
962    *          Width for scaling labels
963    */
964   public void drawComponent(Graphics g, boolean clip, int width)
965   {
966     if (av.getFont().getSize() < 10)
967     {
968       g.setFont(font);
969     }
970     else
971     {
972       g.setFont(av.getFont());
973     }
974
975     FontMetrics fm = g.getFontMetrics(g.getFont());
976     g.setColor(Color.white);
977     g.fillRect(0, 0, getWidth(), getHeight());
978
979     g.translate(0, getScrollOffset());
980     g.setColor(Color.black);
981
982     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
983     int fontHeight = g.getFont().getSize();
984     int y = 0;
985     int x = 0;
986     int graphExtras = 0;
987     int offset = 0;
988     Font baseFont = g.getFont();
989     FontMetrics baseMetrics = fm;
990     int ofontH = fontHeight;
991     int sOffset = 0;
992     int visHeight = 0;
993     int[] visr = (ap != null && ap.getAnnotationPanel() != null) ? ap.getAnnotationPanel()
994             .getVisibleVRange() : null;
995     if (clip && visr != null)
996     {
997       sOffset = visr[0];
998       visHeight = visr[1];
999     }
1000     boolean visible = true, before = false, after = false;
1001     if (aa != null)
1002     {
1003       hasHiddenRows = false;
1004       int olY = 0;
1005       for (int i = 0; i < aa.length; i++)
1006       {
1007         visible = true;
1008         if (!aa[i].visible)
1009         {
1010           hasHiddenRows = true;
1011           continue;
1012         }
1013         olY = y;
1014         y += aa[i].height;
1015         if (clip)
1016         {
1017           if (y < sOffset)
1018           {
1019             if (!before)
1020             {
1021               if (debugRedraw)
1022               {
1023                 System.out.println("before vis: " + i);
1024               }
1025               before = true;
1026             }
1027             // don't draw what isn't visible
1028             continue;
1029           }
1030           if (olY > visHeight)
1031           {
1032
1033             if (!after)
1034             {
1035               if (debugRedraw)
1036               {
1037                 System.out.println("Scroll offset: " + sOffset
1038                         + " after vis: " + i);
1039               }
1040               after = true;
1041             }
1042             // don't draw what isn't visible
1043             continue;
1044           }
1045         }
1046         g.setColor(Color.black);
1047
1048         offset = -aa[i].height / 2;
1049
1050         if (aa[i].hasText)
1051         {
1052           offset += fm.getHeight() / 2;
1053           offset -= fm.getDescent();
1054         }
1055         else
1056         {
1057           offset += fm.getDescent();
1058         }
1059
1060         x = width - fm.stringWidth(aa[i].label) - 3;
1061
1062         if (aa[i].graphGroup > -1)
1063         {
1064           int groupSize = 0;
1065           // TODO: JAL-1291 revise rendering model so the graphGroup map is
1066           // computed efficiently for all visible labels
1067           for (int gg = 0; gg < aa.length; gg++)
1068           {
1069             if (aa[gg].graphGroup == aa[i].graphGroup)
1070             {
1071               groupSize++;
1072             }
1073           }
1074           if (groupSize * (fontHeight + 8) < aa[i].height)
1075           {
1076             graphExtras = (aa[i].height - (groupSize * (fontHeight + 8))) / 2;
1077           }
1078           else
1079           {
1080             // scale font to fit
1081             float h = aa[i].height / (float) groupSize, s;
1082             if (h < 9)
1083             {
1084               visible = false;
1085             }
1086             else
1087             {
1088               fontHeight = -8 + (int) h;
1089               s = ((float) fontHeight) / (float) ofontH;
1090               Font f = baseFont.deriveFont(AffineTransform
1091                       .getScaleInstance(s, s));
1092               g.setFont(f);
1093               fm = g.getFontMetrics();
1094               graphExtras = (aa[i].height - (groupSize * (fontHeight + 8))) / 2;
1095             }
1096           }
1097           if (visible)
1098           {
1099             for (int gg = 0; gg < aa.length; gg++)
1100             {
1101               if (aa[gg].graphGroup == aa[i].graphGroup)
1102               {
1103                 x = width - fm.stringWidth(aa[gg].label) - 3;
1104                 g.drawString(aa[gg].label, x, y - graphExtras);
1105
1106                 if (aa[gg]._linecolour != null)
1107                 {
1108
1109                   g.setColor(aa[gg]._linecolour);
1110                   g.drawLine(x, y - graphExtras + 3,
1111                           x + fm.stringWidth(aa[gg].label), y - graphExtras
1112                                   + 3);
1113                 }
1114
1115                 g.setColor(Color.black);
1116                 graphExtras += fontHeight + 8;
1117               }
1118             }
1119           }
1120           g.setFont(baseFont);
1121           fm = baseMetrics;
1122           fontHeight = ofontH;
1123         }
1124         else
1125         {
1126           g.drawString(aa[i].label, x, y + offset);
1127         }
1128       }
1129     }
1130
1131     if (resizePanel)
1132     {
1133       g.drawImage(image, 2, 0 - getScrollOffset(), this);
1134     }
1135     else if (dragEvent != null && aa != null)
1136     {
1137       g.setColor(Color.lightGray);
1138       g.drawString(aa[selectedRow].label, dragEvent.getX(),
1139               dragEvent.getY() - getScrollOffset());
1140     }
1141
1142     if (!av.getWrapAlignment() && ((aa == null) || (aa.length < 1)))
1143     {
1144       g.drawString(MessageManager.getString("label.right_click"), 2, 8);
1145       g.drawString(MessageManager.getString("label.to_add_annotation"), 2,
1146               18);
1147     }
1148   }
1149
1150   public int getScrollOffset()
1151   {
1152     return scrollOffset;
1153   }
1154 }