JAL-2403 redundant 'implements' removed
[jalview.git] / src / jalview / appletgui / APopupMenu.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.appletgui;
22
23 import jalview.analysis.AAFrequency;
24 import jalview.analysis.AlignmentAnnotationUtils;
25 import jalview.analysis.AlignmentUtils;
26 import jalview.analysis.Conservation;
27 import jalview.bin.JalviewLite;
28 import jalview.commands.ChangeCaseCommand;
29 import jalview.commands.EditCommand;
30 import jalview.commands.EditCommand.Action;
31 import jalview.datamodel.AlignmentAnnotation;
32 import jalview.datamodel.AlignmentI;
33 import jalview.datamodel.PDBEntry;
34 import jalview.datamodel.SequenceFeature;
35 import jalview.datamodel.SequenceGroup;
36 import jalview.datamodel.SequenceI;
37 import jalview.io.AppletFormatAdapter;
38 import jalview.io.DataSourceType;
39 import jalview.io.FileFormatI;
40 import jalview.io.FileFormats;
41 import jalview.io.SequenceAnnotationReport;
42 import jalview.renderer.ResidueShader;
43 import jalview.renderer.ResidueShaderI;
44 import jalview.schemes.Blosum62ColourScheme;
45 import jalview.schemes.BuriedColourScheme;
46 import jalview.schemes.ClustalxColourScheme;
47 import jalview.schemes.HelixColourScheme;
48 import jalview.schemes.HydrophobicColourScheme;
49 import jalview.schemes.JalviewColourScheme;
50 import jalview.schemes.NucleotideColourScheme;
51 import jalview.schemes.PIDColourScheme;
52 import jalview.schemes.PurinePyrimidineColourScheme;
53 import jalview.schemes.StrandColourScheme;
54 import jalview.schemes.TaylorColourScheme;
55 import jalview.schemes.TurnColourScheme;
56 import jalview.schemes.ZappoColourScheme;
57 import jalview.util.MessageManager;
58 import jalview.util.UrlLink;
59
60 import java.awt.CheckboxMenuItem;
61 import java.awt.Frame;
62 import java.awt.Menu;
63 import java.awt.MenuItem;
64 import java.awt.event.ActionEvent;
65 import java.awt.event.ActionListener;
66 import java.awt.event.ItemEvent;
67 import java.awt.event.ItemListener;
68 import java.util.Arrays;
69 import java.util.Collection;
70 import java.util.Collections;
71 import java.util.LinkedHashMap;
72 import java.util.List;
73 import java.util.Map;
74 import java.util.SortedMap;
75 import java.util.TreeMap;
76 import java.util.Vector;
77
78 public class APopupMenu extends java.awt.PopupMenu implements
79         ActionListener, ItemListener
80 {
81   Menu groupMenu = new Menu();
82
83   MenuItem editGroupName = new MenuItem();
84
85   CheckboxMenuItem noColour = new CheckboxMenuItem();
86
87   protected CheckboxMenuItem clustalColour = new CheckboxMenuItem();
88
89   protected CheckboxMenuItem zappoColour = new CheckboxMenuItem();
90
91   protected CheckboxMenuItem taylorColour = new CheckboxMenuItem();
92
93   protected CheckboxMenuItem hydrophobicityColour = new CheckboxMenuItem();
94
95   protected CheckboxMenuItem helixColour = new CheckboxMenuItem();
96
97   protected CheckboxMenuItem strandColour = new CheckboxMenuItem();
98
99   protected CheckboxMenuItem turnColour = new CheckboxMenuItem();
100
101   protected CheckboxMenuItem buriedColour = new CheckboxMenuItem();
102
103   protected CheckboxMenuItem PIDColour = new CheckboxMenuItem();
104
105   protected CheckboxMenuItem BLOSUM62Colour = new CheckboxMenuItem();
106
107   CheckboxMenuItem nucleotideColour = new CheckboxMenuItem();
108
109   CheckboxMenuItem purinePyrimidineColour = new CheckboxMenuItem();
110
111   protected MenuItem userDefinedColour = new MenuItem();
112
113   protected CheckboxMenuItem abovePIDColour = new CheckboxMenuItem();
114
115   MenuItem modifyPID = new MenuItem();
116
117   protected CheckboxMenuItem conservationColour = new CheckboxMenuItem();
118
119   MenuItem modifyConservation = new MenuItem();
120
121   MenuItem noColourmenuItem = new MenuItem();
122
123   final AlignmentPanel ap;
124
125   MenuItem unGroupMenuItem = new MenuItem();
126
127   MenuItem createGroupMenuItem = new MenuItem();
128
129   Menu colourMenu = new Menu();
130
131   CheckboxMenuItem showBoxes = new CheckboxMenuItem();
132
133   CheckboxMenuItem showText = new CheckboxMenuItem();
134
135   CheckboxMenuItem showColourText = new CheckboxMenuItem();
136
137   CheckboxMenuItem displayNonconserved = new CheckboxMenuItem();
138
139   Menu seqShowAnnotationsMenu = new Menu(
140           MessageManager.getString("label.show_annotations"));
141
142   Menu seqHideAnnotationsMenu = new Menu(
143           MessageManager.getString("label.hide_annotations"));
144
145   MenuItem seqAddReferenceAnnotations = new MenuItem(
146           MessageManager.getString("label.add_reference_annotations"));
147
148   Menu groupShowAnnotationsMenu = new Menu(
149           MessageManager.getString("label.show_annotations"));
150
151   Menu groupHideAnnotationsMenu = new Menu(
152           MessageManager.getString("label.hide_annotations"));
153
154   MenuItem groupAddReferenceAnnotations = new MenuItem(
155           MessageManager.getString("label.add_reference_annotations"));
156
157   Menu editMenu = new Menu(MessageManager.getString("action.edit"));
158
159   MenuItem copy = new MenuItem(MessageManager.getString("action.copy"));
160
161   MenuItem cut = new MenuItem(MessageManager.getString("action.cut"));
162
163   MenuItem toUpper = new MenuItem(
164           MessageManager.getString("label.to_upper_case"));
165
166   MenuItem toLower = new MenuItem(
167           MessageManager.getString("label.to_lower_case"));
168
169   MenuItem toggleCase = new MenuItem(
170           MessageManager.getString("label.toggle_case"));
171
172   Menu outputmenu = new Menu();
173
174   Menu seqMenu = new Menu();
175
176   MenuItem pdb = new MenuItem();
177
178   MenuItem hideSeqs = new MenuItem();
179
180   MenuItem repGroup = new MenuItem();
181
182   MenuItem sequenceName = new MenuItem(
183           MessageManager.getString("label.edit_name_description"));
184
185   MenuItem sequenceFeature = new MenuItem(
186           MessageManager.getString("label.create_sequence_feature"));
187
188   MenuItem editSequence = new MenuItem(
189           MessageManager.getString("label.edit_sequence"));
190
191   MenuItem sequenceDetails = new MenuItem(
192           MessageManager.getString("label.sequence_details"));
193
194   MenuItem selSeqDetails = new MenuItem(
195           MessageManager.getString("label.sequence_details"));
196
197   MenuItem makeReferenceSeq = new MenuItem();
198
199   SequenceI seq;
200
201   MenuItem revealAll = new MenuItem();
202
203   MenuItem revealSeq = new MenuItem();
204
205   /**
206    * index of sequence to be revealed
207    */
208   int revealSeq_index = -1;
209
210   Menu menu1 = new Menu();
211
212   public APopupMenu(AlignmentPanel apanel, final SequenceI seq,
213           List<String> links)
214   {
215     // /////////////////////////////////////////////////////////
216     // If this is activated from the sequence panel, the user may want to
217     // edit or annotate a particular residue. Therefore display the residue menu
218     //
219     // If from the IDPanel, we must display the sequence menu
220     // ////////////////////////////////////////////////////////
221
222     this.ap = apanel;
223     this.seq = seq;
224
225     try
226     {
227       jbInit();
228     } catch (Exception e)
229     {
230       e.printStackTrace();
231     }
232
233     for (String ff : FileFormats.getInstance().getWritableFormats(true))
234     {
235       MenuItem item = new MenuItem(ff);
236
237       item.addActionListener(this);
238       outputmenu.add(item);
239     }
240
241     buildAnnotationSubmenus();
242
243     SequenceGroup sg = ap.av.getSelectionGroup();
244     if (sg != null && sg.getSize() > 0)
245     {
246       if (sg.isNucleotide())
247       {
248         conservationColour.setEnabled(false);
249         clustalColour.setEnabled(false);
250         BLOSUM62Colour.setEnabled(false);
251         zappoColour.setEnabled(false);
252         taylorColour.setEnabled(false);
253         hydrophobicityColour.setEnabled(false);
254         helixColour.setEnabled(false);
255         strandColour.setEnabled(false);
256         turnColour.setEnabled(false);
257         buriedColour.setEnabled(false);
258       }
259       else
260       {
261         purinePyrimidineColour.setEnabled(false);
262         nucleotideColour.setEnabled(false);
263       }
264       editGroupName.setLabel(MessageManager.formatMessage(
265               "label.name_param", new Object[] { sg.getName() }));
266       showText.setState(sg.getDisplayText());
267       showColourText.setState(sg.getColourText());
268       showBoxes.setState(sg.getDisplayBoxes());
269       displayNonconserved.setState(sg.getShowNonconserved());
270       if (!ap.av.getAlignment().getGroups().contains(sg))
271       {
272         menu1.setLabel(MessageManager.getString("action.edit_new_group"));
273         groupMenu.remove(unGroupMenuItem);
274       }
275       else
276       {
277         menu1.setLabel(MessageManager.getString("action.edit_group"));
278         groupMenu.remove(createGroupMenuItem);
279         if (sg.cs != null)
280         {
281           abovePIDColour.setState(sg.cs.getThreshold() > 0);
282           conservationColour.setState(sg.cs.conservationApplied());
283           modifyPID.setEnabled(abovePIDColour.getState());
284           modifyConservation.setEnabled(conservationColour.getState());
285         }
286       }
287       setSelectedColour(sg.cs);
288     }
289     else
290     {
291       remove(hideSeqs);
292       remove(groupMenu);
293     }
294
295     if (links != null && links.size() > 0)
296     {
297       addFeatureLinks(seq, links);
298     }
299
300     // TODO: add group link menu entry here
301     if (seq != null)
302     {
303       seqMenu.setLabel(seq.getName());
304       if (seq == ap.av.getAlignment().getSeqrep())
305       {
306         makeReferenceSeq.setLabel(MessageManager
307                 .getString("action.unmark_as_reference"));// Unmark
308                                                           // representative");
309       }
310       else
311       {
312         makeReferenceSeq.setLabel(MessageManager
313                 .getString("action.set_as_reference")); // );
314       }
315       repGroup.setLabel(MessageManager.formatMessage(
316               "label.represent_group_with", new Object[] { seq.getName() }));
317     }
318     else
319     {
320       remove(seqMenu);
321     }
322
323     if (!ap.av.hasHiddenRows())
324     {
325       remove(revealAll);
326       remove(revealSeq);
327     }
328     else
329     {
330       final int index = ap.av.getAlignment().findIndex(seq);
331
332       if (ap.av.adjustForHiddenSeqs(index)
333               - ap.av.adjustForHiddenSeqs(index - 1) > 1)
334       {
335         revealSeq_index = index;
336       }
337       else
338       {
339         remove(revealSeq);
340       }
341     }
342   }
343
344   /**
345    * Select the menu item (if any) matching the current colour scheme. This
346    * works by matching the menu item name (not display text) to the canonical
347    * name of the colour scheme.
348    * 
349    * @param cs
350    */
351   protected void setSelectedColour(ResidueShaderI cs)
352   {
353     if (cs == null || cs.getColourScheme() == null)
354     {
355       noColour.setState(true);
356     }
357     else
358     {
359       String name = cs.getColourScheme().getSchemeName();
360       for (int i = 0; i < colourMenu.getItemCount(); i++)
361       {
362         MenuItem item = colourMenu.getItem(i);
363         if (item instanceof CheckboxMenuItem)
364         {
365           if (name.equals(item.getName()))
366           {
367             ((CheckboxMenuItem) item).setState(true);
368           }
369         }
370       }
371     }
372   }
373
374   /**
375    * Adds a 'Link' menu item with a sub-menu item for each hyperlink provided.
376    * 
377    * @param seq
378    * @param links
379    */
380   void addFeatureLinks(final SequenceI seq, List<String> links)
381   {
382     Menu linkMenu = new Menu(MessageManager.getString("action.link"));
383     Map<String, List<String>> linkset = new LinkedHashMap<String, List<String>>();
384
385     for (String link : links)
386     {
387       UrlLink urlLink = null;
388       try
389       {
390         urlLink = new UrlLink(link);
391       } catch (Exception foo)
392       {
393         System.err.println("Exception for URLLink '" + link + "': "
394                 + foo.getMessage());
395         continue;
396       }
397
398       if (!urlLink.isValid())
399       {
400         System.err.println(urlLink.getInvalidMessage());
401         continue;
402       }
403
404       urlLink.createLinksFromSeq(seq, linkset);
405     }
406
407     addshowLinks(linkMenu, linkset.values());
408
409     // disable link menu if there are no valid entries
410     if (linkMenu.getItemCount() > 0)
411     {
412       linkMenu.setEnabled(true);
413     }
414     else
415     {
416       linkMenu.setEnabled(false);
417     }
418
419     if (seq != null)
420     {
421       seqMenu.add(linkMenu);
422     }
423     else
424     {
425       add(linkMenu);
426     }
427
428   }
429
430   private void addshowLinks(Menu linkMenu, Collection<List<String>> linkset)
431   {
432     for (List<String> linkstrset : linkset)
433     {
434       // split linkstr into label and url
435       addshowLink(linkMenu, linkstrset.get(1), linkstrset.get(3));
436     }
437   }
438
439   /**
440    * Build menus for annotation types that may be shown or hidden, and for
441    * 'reference annotations' that may be added to the alignment.
442    */
443   private void buildAnnotationSubmenus()
444   {
445     /*
446      * First for the currently selected sequence (if there is one):
447      */
448     final List<SequenceI> selectedSequence = (seq == null ? Collections
449             .<SequenceI> emptyList() : Arrays.asList(seq));
450     buildAnnotationTypesMenus(seqShowAnnotationsMenu,
451             seqHideAnnotationsMenu, selectedSequence);
452     configureReferenceAnnotationsMenu(seqAddReferenceAnnotations,
453             selectedSequence);
454
455     /*
456      * and repeat for the current selection group (if there is one):
457      */
458     final List<SequenceI> selectedGroup = (ap.av.getSelectionGroup() == null ? Collections
459             .<SequenceI> emptyList() : ap.av.getSelectionGroup()
460             .getSequences());
461     buildAnnotationTypesMenus(groupShowAnnotationsMenu,
462             groupHideAnnotationsMenu, selectedGroup);
463     configureReferenceAnnotationsMenu(groupAddReferenceAnnotations,
464             selectedGroup);
465   }
466
467   /**
468    * Determine whether or not to enable 'add reference annotations' menu item.
469    * It is enable if there are any annotations, on any of the selected
470    * sequences, which are not yet on the alignment (visible or not).
471    * 
472    * @param menu
473    * @param forSequences
474    */
475   private void configureReferenceAnnotationsMenu(MenuItem menuItem,
476           List<SequenceI> forSequences)
477   {
478     menuItem.setEnabled(false);
479
480     /*
481      * Temporary store to hold distinct calcId / type pairs for the tooltip.
482      * Using TreeMap means calcIds are shown in alphabetical order.
483      */
484     SortedMap<String, String> tipEntries = new TreeMap<String, String>();
485     final Map<SequenceI, List<AlignmentAnnotation>> candidates = new LinkedHashMap<SequenceI, List<AlignmentAnnotation>>();
486     AlignmentI al = this.ap.av.getAlignment();
487     AlignmentUtils.findAddableReferenceAnnotations(forSequences,
488             tipEntries, candidates, al);
489     if (!candidates.isEmpty())
490     {
491       StringBuilder tooltip = new StringBuilder(64);
492       tooltip.append(MessageManager.getString("label.add_annotations_for"));
493
494       /*
495        * Found annotations that could be added. Enable the menu item, and
496        * configure its action.
497        */
498       menuItem.setEnabled(true);
499
500       menuItem.addActionListener(new ActionListener()
501       {
502         @Override
503         public void actionPerformed(ActionEvent e)
504         {
505           addReferenceAnnotations_actionPerformed(candidates);
506         }
507       });
508     }
509   }
510
511   /**
512    * Add annotations to the sequences and to the alignment.
513    * 
514    * @param candidates
515    *          a map whose keys are sequences on the alignment, and values a list
516    *          of annotations to add to each sequence
517    */
518   protected void addReferenceAnnotations_actionPerformed(
519           Map<SequenceI, List<AlignmentAnnotation>> candidates)
520   {
521     final SequenceGroup selectionGroup = this.ap.av.getSelectionGroup();
522     final AlignmentI alignment = this.ap.getAlignment();
523     AlignmentUtils.addReferenceAnnotations(candidates, alignment,
524             selectionGroup);
525     refresh();
526   }
527
528   /**
529    * add a show URL menu item to the given linkMenu
530    * 
531    * @param linkMenu
532    * @param target
533    *          - menu label string
534    * @param url
535    *          - url to open
536    */
537   private void addshowLink(Menu linkMenu, final String target,
538           final String url)
539   {
540     addshowLink(linkMenu, target, target, url);
541   }
542
543   /**
544    * add a show URL menu item to the given linkMenu
545    * 
546    * @param linkMenu
547    * @param target
548    *          - URL target window
549    * @param label
550    *          - menu label string
551    * @param url
552    *          - url to open
553    */
554   private void addshowLink(Menu linkMenu, final String target,
555           final String label, final String url)
556   {
557     MenuItem item = new MenuItem(label);
558     item.addActionListener(new java.awt.event.ActionListener()
559     {
560       @Override
561       public void actionPerformed(ActionEvent e)
562       {
563         ap.alignFrame.showURL(url, target);
564       }
565     });
566     linkMenu.add(item);
567   }
568
569   /**
570    * Actions on selecting / unselecting a checkbox menu item
571    */
572   @Override
573   public void itemStateChanged(ItemEvent evt)
574   {
575     Object source = evt.getSource();
576     if (source == noColour)
577     {
578       noColourmenuItem_actionPerformed();
579     }
580     else if (source == clustalColour)
581     {
582       clustalColour_actionPerformed();
583     }
584     else if (source == BLOSUM62Colour)
585     {
586       BLOSUM62Colour_actionPerformed();
587     }
588     else if (evt.getSource() == PIDColour)
589     {
590       PIDColour_actionPerformed();
591     }
592     else if (source == zappoColour)
593     {
594       zappoColour_actionPerformed();
595     }
596     else if (source == taylorColour)
597     {
598       taylorColour_actionPerformed();
599     }
600     else if (source == hydrophobicityColour)
601     {
602       hydrophobicityColour_actionPerformed();
603     }
604     else if (source == helixColour)
605     {
606       helixColour_actionPerformed();
607     }
608     else if (source == strandColour)
609     {
610       strandColour_actionPerformed();
611     }
612     else if (source == turnColour)
613     {
614       turnColour_actionPerformed();
615     }
616     else if (source == buriedColour)
617     {
618       buriedColour_actionPerformed();
619     }
620     else if (source == nucleotideColour)
621     {
622       nucleotideMenuItem_actionPerformed();
623     }
624     else if (source == purinePyrimidineColour)
625     {
626       purinePyrimidineColour_actionPerformed();
627     }
628     else if (source == abovePIDColour)
629     {
630       abovePIDColour_itemStateChanged();
631     }
632     else if (source == conservationColour)
633     {
634       conservationMenuItem_itemStateChanged();
635     }
636     else if (source == showColourText)
637     {
638       showColourText_itemStateChanged();
639     }
640     else if (source == showText)
641     {
642       showText_itemStateChanged();
643     }
644     else if (source == showBoxes)
645     {
646       showBoxes_itemStateChanged();
647     }
648     else if (source == displayNonconserved)
649     {
650       this.showNonconserved_itemStateChanged();
651     }
652   }
653
654   /**
655    * Actions on clicking a menu item
656    */
657   @Override
658   public void actionPerformed(ActionEvent evt)
659   {
660     Object source = evt.getSource();
661     if (source == userDefinedColour)
662     {
663       userDefinedColour_actionPerformed();
664     }
665     else if (source == modifyConservation)
666     {
667       conservationMenuItem_itemStateChanged();
668     }
669     else if (source == modifyPID)
670     {
671       abovePIDColour_itemStateChanged();
672     }
673     else if (source == unGroupMenuItem)
674     {
675       unGroupMenuItem_actionPerformed();
676     }
677
678     else if (source == createGroupMenuItem)
679     {
680       createGroupMenuItem_actionPerformed();
681     }
682
683     else if (source == sequenceName)
684     {
685       editName();
686     }
687     else if (source == makeReferenceSeq)
688     {
689       makeReferenceSeq_actionPerformed();
690     }
691     else if (source == sequenceDetails)
692     {
693       showSequenceDetails();
694     }
695     else if (source == selSeqDetails)
696     {
697       showSequenceSelectionDetails();
698     }
699     else if (source == pdb)
700     {
701       addPDB();
702     }
703     else if (source == hideSeqs)
704     {
705       hideSequences(false);
706     }
707     else if (source == repGroup)
708     {
709       hideSequences(true);
710     }
711     else if (source == revealSeq)
712     {
713       ap.av.showSequence(revealSeq_index);
714     }
715     else if (source == revealAll)
716     {
717       ap.av.showAllHiddenSeqs();
718     }
719
720     else if (source == editGroupName)
721     {
722       EditNameDialog dialog = new EditNameDialog(getGroup().getName(),
723               getGroup().getDescription(), "       Group Name",
724               "Group Description", ap.alignFrame,
725               "Edit Group Name / Description", 500, 100, true);
726
727       if (dialog.accept)
728       {
729         getGroup().setName(dialog.getName().replace(' ', '_'));
730         getGroup().setDescription(dialog.getDescription());
731       }
732
733     }
734     else if (source == copy)
735     {
736       ap.alignFrame.copy_actionPerformed();
737     }
738     else if (source == cut)
739     {
740       ap.alignFrame.cut_actionPerformed();
741     }
742     else if (source == editSequence)
743     {
744       SequenceGroup sg = ap.av.getSelectionGroup();
745
746       if (sg != null)
747       {
748         if (seq == null)
749         {
750           seq = sg.getSequenceAt(0);
751         }
752
753         EditNameDialog dialog = new EditNameDialog(seq.getSequenceAsString(
754                 sg.getStartRes(), sg.getEndRes() + 1), null,
755                 "Edit Sequence ", null,
756
757                 ap.alignFrame, "Edit Sequence", 500, 100, true);
758
759         if (dialog.accept)
760         {
761           EditCommand editCommand = new EditCommand(
762                   MessageManager.getString("label.edit_sequences"),
763                   Action.REPLACE, dialog.getName().replace(' ',
764                           ap.av.getGapCharacter()),
765                   sg.getSequencesAsArray(ap.av.getHiddenRepSequences()),
766                   sg.getStartRes(), sg.getEndRes() + 1,
767                   ap.av.getAlignment());
768
769           ap.alignFrame.addHistoryItem(editCommand);
770
771           ap.av.firePropertyChange("alignment", null, ap.av.getAlignment()
772                   .getSequences());
773         }
774       }
775     }
776     else if (source == toUpper || source == toLower || source == toggleCase)
777     {
778       SequenceGroup sg = ap.av.getSelectionGroup();
779       if (sg != null)
780       {
781         List<int[]> startEnd = ap.av.getVisibleRegionBoundaries(
782                 sg.getStartRes(), sg.getEndRes() + 1);
783
784         String description;
785         int caseChange;
786
787         if (source == toggleCase)
788         {
789           description = "Toggle Case";
790           caseChange = ChangeCaseCommand.TOGGLE_CASE;
791         }
792         else if (source == toUpper)
793         {
794           description = "To Upper Case";
795           caseChange = ChangeCaseCommand.TO_UPPER;
796         }
797         else
798         {
799           description = "To Lower Case";
800           caseChange = ChangeCaseCommand.TO_LOWER;
801         }
802
803         ChangeCaseCommand caseCommand = new ChangeCaseCommand(description,
804                 sg.getSequencesAsArray(ap.av.getHiddenRepSequences()),
805                 startEnd, caseChange);
806
807         ap.alignFrame.addHistoryItem(caseCommand);
808
809         ap.av.firePropertyChange("alignment", null, ap.av.getAlignment()
810                 .getSequences());
811
812       }
813     }
814     else if (source == sequenceFeature)
815     {
816       SequenceGroup sg = ap.av.getSelectionGroup();
817       if (sg == null)
818       {
819         return;
820       }
821
822       int rsize = 0, gSize = sg.getSize();
823       SequenceI[] rseqs, seqs = new SequenceI[gSize];
824       SequenceFeature[] tfeatures, features = new SequenceFeature[gSize];
825
826       for (int i = 0; i < gSize; i++)
827       {
828         int start = sg.getSequenceAt(i).findPosition(sg.getStartRes());
829         int end = sg.findEndRes(sg.getSequenceAt(i));
830         if (start <= end)
831         {
832           seqs[rsize] = sg.getSequenceAt(i);
833           features[rsize] = new SequenceFeature(null, null, null, start,
834                   end, "Jalview");
835           rsize++;
836         }
837       }
838       rseqs = new SequenceI[rsize];
839       tfeatures = new SequenceFeature[rsize];
840       System.arraycopy(seqs, 0, rseqs, 0, rsize);
841       System.arraycopy(features, 0, tfeatures, 0, rsize);
842       features = tfeatures;
843       seqs = rseqs;
844
845       if (ap.seqPanel.seqCanvas.getFeatureRenderer().amendFeatures(seqs,
846               features, true, ap))
847       {
848         ap.alignFrame.sequenceFeatures.setState(true);
849         ap.av.setShowSequenceFeatures(true);
850         ;
851         ap.highlightSearchResults(null);
852       }
853     }
854     else
855     {
856       outputText(evt);
857     }
858
859   }
860
861   void outputText(ActionEvent e)
862   {
863     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, ap.alignFrame);
864
865     Frame frame = new Frame();
866     frame.add(cap);
867     JalviewLite.addFrame(frame, MessageManager.formatMessage(
868             "label.selection_output_command",
869             new Object[] { e.getActionCommand() }), 600, 500);
870     // JBPNote: getSelectionAsNewSequence behaviour has changed - this method
871     // now returns a full copy of sequence data
872     // TODO consider using getSequenceSelection instead here
873
874     FileFormatI fileFormat = FileFormats.getInstance().forName(
875             e.getActionCommand());
876     cap.setText(new AppletFormatAdapter().formatSequences(fileFormat,
877             ap.av.getShowJVSuffix(), ap, true));
878
879   }
880
881   protected void showSequenceSelectionDetails()
882   {
883     createSequenceDetailsReport(ap.av.getSequenceSelection());
884   }
885
886   protected void showSequenceDetails()
887   {
888     createSequenceDetailsReport(new SequenceI[] { seq });
889   }
890
891   public void createSequenceDetailsReport(SequenceI[] sequences)
892   {
893
894     CutAndPasteTransfer cap = new CutAndPasteTransfer(false, ap.alignFrame);
895
896     StringBuilder contents = new StringBuilder(128);
897     for (SequenceI seq : sequences)
898     {
899       contents.append(MessageManager.formatMessage(
900               "label.annotation_for_displayid",
901               new Object[] { seq.getDisplayId(true) }));
902       new SequenceAnnotationReport(null).createSequenceAnnotationReport(
903               contents,
904               seq,
905               true,
906               true,
907               (ap.seqPanel.seqCanvas.fr != null) ? ap.seqPanel.seqCanvas.fr
908                       .getMinMax() : null);
909       contents.append("</p>");
910     }
911     Frame frame = new Frame();
912     frame.add(cap);
913     jalview.bin.JalviewLite.addFrame(frame, "Sequence Details for "
914             + (sequences.length == 1 ? sequences[0].getDisplayId(true)
915                     : "Selection"), 600, 500);
916     cap.setText(MessageManager.formatMessage("label.html_content",
917             new Object[] { contents.toString() }));
918   }
919
920   void editName()
921   {
922     EditNameDialog dialog = new EditNameDialog(seq.getName(),
923             seq.getDescription(), "       Sequence Name",
924             "Sequence Description", ap.alignFrame,
925             "Edit Sequence Name / Description", 500, 100, true);
926
927     if (dialog.accept)
928     {
929       seq.setName(dialog.getName());
930       seq.setDescription(dialog.getDescription());
931       ap.paintAlignment(false);
932     }
933   }
934
935   void addPDB()
936   {
937     Vector<PDBEntry> pdbs = seq.getAllPDBEntries();
938     if (pdbs != null && !pdbs.isEmpty())
939     {
940       PDBEntry entry = pdbs.firstElement();
941
942       if (ap.av.applet.jmolAvailable)
943       {
944         new AppletJmol(entry, new SequenceI[] { seq }, null, ap,
945                 DataSourceType.URL);
946       }
947       else
948       {
949         new MCview.AppletPDBViewer(entry, new SequenceI[] { seq }, null,
950                 ap, DataSourceType.URL);
951       }
952
953     }
954     else
955     {
956       CutAndPasteTransfer cap = new CutAndPasteTransfer(true, ap.alignFrame);
957       cap.setText(MessageManager.getString("label.paste_pdb_file"));
958       cap.setPDBImport(seq);
959       Frame frame = new Frame();
960       frame.add(cap);
961       JalviewLite.addFrame(frame, MessageManager.formatMessage(
962               "label.paste_pdb_file_for_sequence",
963               new Object[] { seq.getName() }), 400, 300);
964     }
965   }
966
967   private void jbInit() throws Exception
968   {
969     groupMenu.setLabel(MessageManager.getString("label.selection"));
970     sequenceFeature.addActionListener(this);
971
972     editGroupName.addActionListener(this);
973     unGroupMenuItem.setLabel(MessageManager
974             .getString("action.remove_group"));
975     unGroupMenuItem.addActionListener(this);
976
977     createGroupMenuItem.setLabel(MessageManager
978             .getString("action.create_group"));
979     createGroupMenuItem.addActionListener(this);
980
981     modifyPID.setEnabled(abovePIDColour.getState());
982     modifyConservation.setEnabled(conservationColour.getState());
983     colourMenu.setLabel(MessageManager.getString("label.group_colour"));
984     showBoxes.setLabel(MessageManager.getString("action.boxes"));
985     showBoxes.setState(true);
986     showBoxes.addItemListener(this);
987     sequenceName.addActionListener(this);
988     sequenceDetails.addActionListener(this);
989     selSeqDetails.addActionListener(this);
990     displayNonconserved.setLabel(MessageManager
991             .getString("label.show_non_conserved"));
992     displayNonconserved.setState(false);
993     displayNonconserved.addItemListener(this);
994     showText.setLabel(MessageManager.getString("action.text"));
995     showText.addItemListener(this);
996     showColourText.setLabel(MessageManager.getString("label.colour_text"));
997     showColourText.addItemListener(this);
998     outputmenu.setLabel(MessageManager.getString("label.out_to_textbox"));
999     seqMenu.setLabel(MessageManager.getString("label.sequence"));
1000     pdb.setLabel(MessageManager.getString("label.view_pdb_structure"));
1001     hideSeqs.setLabel(MessageManager.getString("action.hide_sequences"));
1002     repGroup.setLabel(MessageManager.formatMessage(
1003             "label.represent_group_with", new Object[] { "" }));
1004     revealAll.setLabel(MessageManager.getString("action.reveal_all"));
1005     revealSeq.setLabel(MessageManager.getString("action.reveal_sequences"));
1006     menu1.setLabel(MessageManager.getString("label.group:"));
1007     add(groupMenu);
1008     this.add(seqMenu);
1009     this.add(hideSeqs);
1010     this.add(revealSeq);
1011     this.add(revealAll);
1012     // groupMenu.add(selSeqDetails);
1013     groupMenu.add(groupShowAnnotationsMenu);
1014     groupMenu.add(groupHideAnnotationsMenu);
1015     groupMenu.add(groupAddReferenceAnnotations);
1016     groupMenu.add(editMenu);
1017     groupMenu.add(outputmenu);
1018     groupMenu.add(sequenceFeature);
1019     groupMenu.add(createGroupMenuItem);
1020     groupMenu.add(unGroupMenuItem);
1021     groupMenu.add(menu1);
1022
1023     colourMenu.add(noColour);
1024     colourMenu.add(clustalColour);
1025     colourMenu.add(BLOSUM62Colour);
1026     colourMenu.add(PIDColour);
1027     colourMenu.add(zappoColour);
1028     colourMenu.add(taylorColour);
1029     colourMenu.add(hydrophobicityColour);
1030     colourMenu.add(helixColour);
1031     colourMenu.add(strandColour);
1032     colourMenu.add(turnColour);
1033     colourMenu.add(buriedColour);
1034     colourMenu.add(nucleotideColour);
1035     colourMenu.add(purinePyrimidineColour);
1036     colourMenu.add(userDefinedColour);
1037     colourMenu.addSeparator();
1038     colourMenu.add(conservationColour);
1039     colourMenu.add(modifyConservation);
1040     colourMenu.add(abovePIDColour);
1041     colourMenu.add(modifyPID);
1042
1043     noColour.setLabel(MessageManager.getString("label.none"));
1044     noColour.addItemListener(this);
1045
1046     /*
1047      * setName allows setSelectedColour to do its thing
1048      */
1049     clustalColour.setLabel(MessageManager
1050             .getString("label.colourScheme_clustal"));
1051     clustalColour.setName(JalviewColourScheme.Clustal.toString());
1052     clustalColour.addItemListener(this);
1053     BLOSUM62Colour.setLabel(MessageManager
1054             .getString("label.colourScheme_blosum62"));
1055     BLOSUM62Colour.setName(JalviewColourScheme.Blosum62.toString());
1056     BLOSUM62Colour.addItemListener(this);
1057     PIDColour.setLabel(MessageManager
1058             .getString("label.colourScheme_%_identity"));
1059     PIDColour.setName(JalviewColourScheme.PID.toString());
1060     PIDColour.addItemListener(this);
1061     zappoColour.setLabel(MessageManager
1062             .getString("label.colourScheme_zappo"));
1063     zappoColour.setName(JalviewColourScheme.Zappo.toString());
1064     zappoColour.addItemListener(this);
1065     taylorColour.setLabel(MessageManager
1066             .getString("label.colourScheme_taylor"));
1067     taylorColour.setName(JalviewColourScheme.Taylor.toString());
1068     taylorColour.addItemListener(this);
1069     hydrophobicityColour.setLabel(MessageManager
1070             .getString("label.colourScheme_hydrophobic"));
1071     hydrophobicityColour
1072             .setName(JalviewColourScheme.Hydrophobic.toString());
1073     hydrophobicityColour.addItemListener(this);
1074     helixColour.setLabel(MessageManager
1075             .getString("label.colourScheme_helix_propensity"));
1076     helixColour.setName(JalviewColourScheme.Helix.toString());
1077     helixColour.addItemListener(this);
1078     strandColour.setLabel(MessageManager
1079             .getString("label.colourScheme_strand_propensity"));
1080     strandColour.setName(JalviewColourScheme.Strand.toString());
1081     strandColour.addItemListener(this);
1082     turnColour.setLabel(MessageManager
1083             .getString("label.colourScheme_turn_propensity"));
1084     turnColour.setName(JalviewColourScheme.Turn.toString());
1085     turnColour.addItemListener(this);
1086     buriedColour.setLabel(MessageManager
1087             .getString("label.colourScheme_buried_index"));
1088     buriedColour.setName(JalviewColourScheme.Buried.toString());
1089     buriedColour.addItemListener(this);
1090     nucleotideColour.setLabel(MessageManager
1091             .getString("label.colourScheme_nucleotide"));
1092     nucleotideColour.setName(JalviewColourScheme.Nucleotide.toString());
1093     nucleotideColour.addItemListener(this);
1094     purinePyrimidineColour.setLabel(MessageManager
1095             .getString("label.colourScheme_purine/pyrimidine"));
1096     purinePyrimidineColour.setName(JalviewColourScheme.PurinePyrimidine
1097             .toString());
1098     purinePyrimidineColour.addItemListener(this);
1099
1100     userDefinedColour.setLabel(MessageManager
1101             .getString("action.user_defined"));
1102     userDefinedColour.addActionListener(this);
1103
1104     abovePIDColour.setLabel(MessageManager
1105             .getString("label.above_identity_threshold"));
1106     abovePIDColour.addItemListener(this);
1107     modifyPID.setLabel(MessageManager
1108             .getString("label.modify_identity_threshold"));
1109     modifyPID.addActionListener(this);
1110     conservationColour.setLabel(MessageManager
1111             .getString("action.by_conservation"));
1112     conservationColour.addItemListener(this);
1113     modifyConservation.setLabel(MessageManager
1114             .getString("label.modify_conservation_threshold"));
1115     modifyConservation.addActionListener(this);
1116
1117     PIDColour.addActionListener(this);
1118     BLOSUM62Colour.addActionListener(this);
1119
1120     editMenu.add(copy);
1121     copy.addActionListener(this);
1122     editMenu.add(cut);
1123     cut.addActionListener(this);
1124
1125     editMenu.add(editSequence);
1126     editSequence.addActionListener(this);
1127
1128     editMenu.add(toUpper);
1129     toUpper.addActionListener(this);
1130     editMenu.add(toLower);
1131     toLower.addActionListener(this);
1132     editMenu.add(toggleCase);
1133     seqMenu.add(seqShowAnnotationsMenu);
1134     seqMenu.add(seqHideAnnotationsMenu);
1135     seqMenu.add(seqAddReferenceAnnotations);
1136     seqMenu.add(sequenceName);
1137     seqMenu.add(makeReferenceSeq);
1138     // seqMenu.add(sequenceDetails);
1139
1140     if (!ap.av.applet.useXtrnalSviewer)
1141     {
1142       seqMenu.add(pdb);
1143     }
1144     seqMenu.add(repGroup);
1145     menu1.add(editGroupName);
1146     menu1.add(colourMenu);
1147     menu1.add(showBoxes);
1148     menu1.add(showText);
1149     menu1.add(showColourText);
1150     menu1.add(displayNonconserved);
1151     toggleCase.addActionListener(this);
1152     pdb.addActionListener(this);
1153     hideSeqs.addActionListener(this);
1154     repGroup.addActionListener(this);
1155     revealAll.addActionListener(this);
1156     revealSeq.addActionListener(this);
1157     makeReferenceSeq.addActionListener(this);
1158   }
1159
1160   void refresh()
1161   {
1162     ap.paintAlignment(true);
1163   }
1164
1165   protected void clustalColour_actionPerformed()
1166   {
1167     SequenceGroup sg = getGroup();
1168     sg.cs = new ResidueShader(new ClustalxColourScheme(sg,
1169             ap.av.getHiddenRepSequences()));
1170     refresh();
1171   }
1172
1173   protected void zappoColour_actionPerformed()
1174   {
1175     getGroup().cs = new ResidueShader(new ZappoColourScheme());
1176     refresh();
1177   }
1178
1179   protected void taylorColour_actionPerformed()
1180   {
1181     getGroup().cs = new ResidueShader(new TaylorColourScheme());
1182     refresh();
1183   }
1184
1185   protected void hydrophobicityColour_actionPerformed()
1186   {
1187     getGroup().cs = new ResidueShader(new HydrophobicColourScheme());
1188     refresh();
1189   }
1190
1191   protected void helixColour_actionPerformed()
1192   {
1193     getGroup().cs = new ResidueShader(new HelixColourScheme());
1194     refresh();
1195   }
1196
1197   protected void strandColour_actionPerformed()
1198   {
1199     getGroup().cs = new ResidueShader(new StrandColourScheme());
1200     refresh();
1201   }
1202
1203   protected void turnColour_actionPerformed()
1204   {
1205     getGroup().cs = new ResidueShader(new TurnColourScheme());
1206     refresh();
1207   }
1208
1209   protected void buriedColour_actionPerformed()
1210   {
1211     getGroup().cs = new ResidueShader(new BuriedColourScheme());
1212     refresh();
1213   }
1214
1215   public void nucleotideMenuItem_actionPerformed()
1216   {
1217     getGroup().cs = new ResidueShader(new NucleotideColourScheme());
1218     refresh();
1219   }
1220
1221   public void purinePyrimidineColour_actionPerformed()
1222   {
1223     getGroup().cs = new ResidueShader(
1224             new PurinePyrimidineColourScheme());
1225     refresh();
1226   }
1227
1228   protected void abovePIDColour_itemStateChanged()
1229   {
1230     SequenceGroup sg = getGroup();
1231     if (sg.cs == null)
1232     {
1233       return;
1234     }
1235
1236     if (abovePIDColour.getState())
1237     {
1238       sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(ap.av
1239               .getHiddenRepSequences()), 0, ap.av.getAlignment().getWidth()));
1240       int threshold = SliderPanel.setPIDSliderSource(ap, sg.cs, getGroup()
1241               .getName());
1242
1243       sg.cs.setThreshold(threshold, ap.av.isIgnoreGapsConsensus());
1244
1245       SliderPanel.showPIDSlider();
1246
1247     }
1248     else
1249     // remove PIDColouring
1250     {
1251       SliderPanel.hidePIDSlider();
1252       sg.cs.setThreshold(0, ap.av.isIgnoreGapsConsensus());
1253     }
1254     modifyPID.setEnabled(abovePIDColour.getState());
1255     refresh();
1256   }
1257
1258   protected void userDefinedColour_actionPerformed()
1259   {
1260     new UserDefinedColours(ap, getGroup());
1261   }
1262
1263   protected void PIDColour_actionPerformed()
1264   {
1265     SequenceGroup sg = getGroup();
1266     sg.cs = new ResidueShader(new PIDColourScheme());
1267     sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(ap.av
1268             .getHiddenRepSequences()), 0, ap.av.getAlignment().getWidth()));
1269     refresh();
1270   }
1271
1272   protected void BLOSUM62Colour_actionPerformed()
1273   {
1274     SequenceGroup sg = getGroup();
1275
1276     sg.cs = new ResidueShader(new Blosum62ColourScheme());
1277
1278     sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(ap.av
1279             .getHiddenRepSequences()), 0, ap.av.getAlignment().getWidth()));
1280
1281     refresh();
1282   }
1283
1284   protected void noColourmenuItem_actionPerformed()
1285   {
1286     getGroup().cs = null;
1287     refresh();
1288   }
1289
1290   protected void conservationMenuItem_itemStateChanged()
1291   {
1292     SequenceGroup sg = getGroup();
1293     if (sg.cs == null)
1294     {
1295       return;
1296     }
1297
1298     if (conservationColour.getState())
1299     {
1300       Conservation conservation = Conservation.calculateConservation(
1301               "Group", sg
1302               .getSequences(ap.av.getHiddenRepSequences()), 0, ap.av
1303               .getAlignment().getWidth(), false, ap.av.getConsPercGaps(),
1304               false);
1305       sg.getGroupColourScheme().setConservation(conservation);
1306       SliderPanel.setConservationSlider(ap, sg.cs, sg.getName());
1307       SliderPanel.showConservationSlider();
1308     }
1309     else
1310     // remove ConservationColouring
1311     {
1312       SliderPanel.hideConservationSlider();
1313       sg.cs.setConservation(null);
1314     }
1315     modifyConservation.setEnabled(conservationColour.getState());
1316     refresh();
1317   }
1318
1319   SequenceGroup getGroup()
1320   {
1321     SequenceGroup sg = ap.av.getSelectionGroup();
1322
1323     // this method won't add a new group if it already exists
1324     if (sg != null)
1325     {
1326       ap.av.getAlignment().addGroup(sg);
1327     }
1328
1329     return sg;
1330   }
1331
1332   void unGroupMenuItem_actionPerformed()
1333   {
1334     SequenceGroup sg = ap.av.getSelectionGroup();
1335     ap.av.getAlignment().deleteGroup(sg);
1336     ap.av.setSelectionGroup(null);
1337     ap.paintAlignment(true);
1338   }
1339
1340   void createGroupMenuItem_actionPerformed()
1341   {
1342     getGroup(); // implicitly create group
1343     refresh();
1344   }
1345
1346   public void showColourText_itemStateChanged()
1347   {
1348     getGroup().setColourText(showColourText.getState());
1349     refresh();
1350   }
1351
1352   public void showText_itemStateChanged()
1353   {
1354     getGroup().setDisplayText(showText.getState());
1355     refresh();
1356   }
1357
1358   public void makeReferenceSeq_actionPerformed()
1359   {
1360     if (!ap.av.getAlignment().hasSeqrep())
1361     {
1362       // initialise the display flags so the user sees something happen
1363       ap.av.setDisplayReferenceSeq(true);
1364       ap.av.setColourByReferenceSeq(true);
1365       ap.av.getAlignment().setSeqrep(seq);
1366     }
1367     else
1368     {
1369       if (ap.av.getAlignment().getSeqrep() == seq)
1370       {
1371         ap.av.getAlignment().setSeqrep(null);
1372       }
1373       else
1374       {
1375         ap.av.getAlignment().setSeqrep(seq);
1376       }
1377     }
1378     refresh();
1379   }
1380
1381   public void showNonconserved_itemStateChanged()
1382   {
1383     getGroup().setShowNonconserved(this.displayNonconserved.getState());
1384     refresh();
1385   }
1386
1387   public void showBoxes_itemStateChanged()
1388   {
1389     getGroup().setDisplayBoxes(showBoxes.getState());
1390     refresh();
1391   }
1392
1393   void hideSequences(boolean representGroup)
1394   {
1395     ap.av.hideSequences(seq, representGroup);
1396   }
1397
1398   /**
1399    * Add annotation types to 'Show annotations' and/or 'Hide annotations' menus.
1400    * "All" is added first, followed by a separator. Then add any annotation
1401    * types associated with the current selection. Separate menus are built for
1402    * the selected sequence group (if any), and the selected sequence.
1403    * <p>
1404    * Some annotation rows are always rendered together - these can be identified
1405    * by a common graphGroup property > -1. Only one of each group will be marked
1406    * as visible (to avoid duplication of the display). For such groups we add a
1407    * composite type name, e.g.
1408    * <p>
1409    * IUPredWS (Long), IUPredWS (Short)
1410    * 
1411    * @param seq
1412    */
1413   protected void buildAnnotationTypesMenus(Menu showMenu, Menu hideMenu,
1414           List<SequenceI> forSequences)
1415   {
1416     showMenu.removeAll();
1417     hideMenu.removeAll();
1418
1419     final List<String> all = Arrays.asList(new String[] { MessageManager
1420             .getString("label.all") });
1421     addAnnotationTypeToShowHide(showMenu, forSequences, "", all, true, true);
1422     addAnnotationTypeToShowHide(hideMenu, forSequences, "", all, true,
1423             false);
1424     showMenu.addSeparator();
1425     hideMenu.addSeparator();
1426
1427     final AlignmentAnnotation[] annotations = ap.getAlignment()
1428             .getAlignmentAnnotation();
1429
1430     /*
1431      * Find shown/hidden annotations types, distinguished by source (calcId),
1432      * and grouped by graphGroup. Using LinkedHashMap means we will retrieve in
1433      * the insertion order, which is the order of the annotations on the
1434      * alignment.
1435      */
1436     Map<String, List<List<String>>> shownTypes = new LinkedHashMap<String, List<List<String>>>();
1437     Map<String, List<List<String>>> hiddenTypes = new LinkedHashMap<String, List<List<String>>>();
1438     AlignmentAnnotationUtils.getShownHiddenTypes(shownTypes, hiddenTypes,
1439             AlignmentAnnotationUtils.asList(annotations), forSequences);
1440
1441     for (String calcId : hiddenTypes.keySet())
1442     {
1443       for (List<String> type : hiddenTypes.get(calcId))
1444       {
1445         addAnnotationTypeToShowHide(showMenu, forSequences, calcId, type,
1446                 false, true);
1447       }
1448     }
1449     // grey out 'show annotations' if none are hidden
1450     showMenu.setEnabled(!hiddenTypes.isEmpty());
1451
1452     for (String calcId : shownTypes.keySet())
1453     {
1454       for (List<String> type : shownTypes.get(calcId))
1455       {
1456         addAnnotationTypeToShowHide(hideMenu, forSequences, calcId, type,
1457                 false, false);
1458       }
1459     }
1460     // grey out 'hide annotations' if none are shown
1461     hideMenu.setEnabled(!shownTypes.isEmpty());
1462   }
1463
1464   /**
1465    * Add one annotation type to the 'Show Annotations' or 'Hide Annotations'
1466    * menus.
1467    * 
1468    * @param showOrHideMenu
1469    *          the menu to add to
1470    * @param forSequences
1471    *          the sequences whose annotations may be shown or hidden
1472    * @param calcId
1473    * @param types
1474    *          the label to add
1475    * @param allTypes
1476    *          if true this is a special label meaning 'All'
1477    * @param actionIsShow
1478    *          if true, the select menu item action is to show the annotation
1479    *          type, else hide
1480    */
1481   protected void addAnnotationTypeToShowHide(Menu showOrHideMenu,
1482           final List<SequenceI> forSequences, String calcId,
1483           final List<String> types, final boolean allTypes,
1484           final boolean actionIsShow)
1485   {
1486     String label = types.toString(); // [a, b, c]
1487     label = label.substring(1, label.length() - 1);
1488     final MenuItem item = new MenuItem(label);
1489     item.addActionListener(new java.awt.event.ActionListener()
1490     {
1491       @Override
1492       public void actionPerformed(ActionEvent e)
1493       {
1494         AlignmentUtils.showOrHideSequenceAnnotations(ap.getAlignment(),
1495                 types, forSequences, allTypes, actionIsShow);
1496         refresh();
1497       }
1498     });
1499     showOrHideMenu.add(item);
1500   }
1501
1502 }