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