src/jalview/gui/PopupMenu.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.gui;
  22
  23 import java.awt.Color;
  24 import java.awt.event.ActionEvent;
  25 import java.awt.event.ActionListener;
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.BitSet;
  29 import java.util.Collection;
  30 import java.util.Collections;
  31 import java.util.Hashtable;
  32 import java.util.LinkedHashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Objects;
  36 import java.util.SortedMap;
  37 import java.util.TreeMap;
  38 import java.util.Vector;
  39
  40 import javax.swing.ButtonGroup;
  41 import javax.swing.JCheckBoxMenuItem;
  42 import javax.swing.JColorChooser;
  43 import javax.swing.JMenu;
  44 import javax.swing.JMenuItem;
  45 import javax.swing.JPopupMenu;
  46 import javax.swing.JRadioButtonMenuItem;
  47
  48 import jalview.analysis.AAFrequency;
  49 import jalview.analysis.AlignmentAnnotationUtils;
  50 import jalview.analysis.AlignmentUtils;
  51 import jalview.analysis.Conservation;
  52 import jalview.api.AlignViewportI;
  53 import jalview.bin.Cache;
  54 import jalview.commands.ChangeCaseCommand;
  55 import jalview.commands.EditCommand;
  56 import jalview.commands.EditCommand.Action;
  57 import jalview.datamodel.AlignmentAnnotation;
  58 import jalview.datamodel.AlignmentI;
  59 import jalview.datamodel.DBRefEntry;
  60 import jalview.datamodel.HiddenColumns;
  61 import jalview.datamodel.MappedFeatures;
  62 import jalview.datamodel.PDBEntry;
  63 import jalview.datamodel.SequenceFeature;
  64 import jalview.datamodel.SequenceGroup;
  65 import jalview.datamodel.SequenceI;
  66 import jalview.gui.ColourMenuHelper.ColourChangeListener;
  67 import jalview.io.FileFormatI;
  68 import jalview.io.FileFormats;
  69 import jalview.io.FormatAdapter;
  70 import jalview.io.SequenceAnnotationReport;
  71 import jalview.schemes.Blosum62ColourScheme;
  72 import jalview.schemes.ColourSchemeI;
  73 import jalview.schemes.ColourSchemes;
  74 import jalview.schemes.PIDColourScheme;
  75 import jalview.schemes.ResidueColourScheme;
  76 import jalview.util.Comparison;
  77 import jalview.util.GroupUrlLink;
  78 import jalview.util.GroupUrlLink.UrlStringTooLongException;
  79 import jalview.util.MessageManager;
  80 import jalview.util.StringUtils;
  81 import jalview.util.UrlLink;
  82 import jalview.viewmodel.seqfeatures.FeatureRendererModel;
  83
  84 /**
  85  * The popup menu that is displayed on right-click on a sequence id, or in the
  86  * sequence alignment.
  87  */
  88 public class PopupMenu extends JPopupMenu implements ColourChangeListener
  89 {
  90   /*
  91    * maximum length of feature description to include in popup menu item text
  92    */
  93   private static final int FEATURE_DESC_MAX = 40;
  94
  95   /*
  96    * true for ID Panel menu, false for alignment panel menu
  97    */
  98   private final boolean forIdPanel;
  99
 100   private final AlignmentPanel ap;
 101
 102   /*
 103    * the sequence under the cursor when clicked
 104    * (additional sequences may be selected)
 105    */
 106   private final SequenceI sequence;
 107
 108   JMenu groupMenu = new JMenu();
 109
 110   JMenuItem groupName = new JMenuItem();
 111
 112   protected JCheckBoxMenuItem abovePIDColour = new JCheckBoxMenuItem();
 113
 114   protected JMenuItem modifyPID = new JMenuItem();
 115
 116   protected JCheckBoxMenuItem conservationMenuItem = new JCheckBoxMenuItem();
 117
 118   protected JRadioButtonMenuItem annotationColour;
 119
 120   protected JMenuItem modifyConservation = new JMenuItem();
 121
 122   JMenu sequenceMenu = new JMenu();
 123
 124   JMenuItem makeReferenceSeq = new JMenuItem();
 125
 126   JMenuItem createGroupMenuItem = new JMenuItem();
 127
 128   JMenuItem unGroupMenuItem = new JMenuItem();
 129
 130   JMenu colourMenu = new JMenu();
 131
 132   JCheckBoxMenuItem showBoxes = new JCheckBoxMenuItem();
 133
 134   JCheckBoxMenuItem showText = new JCheckBoxMenuItem();
 135
 136   JCheckBoxMenuItem showColourText = new JCheckBoxMenuItem();
 137
 138   JCheckBoxMenuItem displayNonconserved = new JCheckBoxMenuItem();
 139
 140   JMenu editMenu = new JMenu();
 141
 142   JMenuItem upperCase = new JMenuItem();
 143
 144   JMenuItem lowerCase = new JMenuItem();
 145
 146   JMenuItem toggle = new JMenuItem();
 147
 148   JMenu outputMenu = new JMenu();
 149
 150   JMenu seqShowAnnotationsMenu = new JMenu();
 151
 152   JMenu seqHideAnnotationsMenu = new JMenu();
 153
 154   JMenuItem seqAddReferenceAnnotations = new JMenuItem(
 155           MessageManager.getString("label.add_reference_annotations"));
 156
 157   JMenu groupShowAnnotationsMenu = new JMenu();
 158
 159   JMenu groupHideAnnotationsMenu = new JMenu();
 160
 161   JMenuItem groupAddReferenceAnnotations = new JMenuItem(
 162           MessageManager.getString("label.add_reference_annotations"));
 163
 164   JMenuItem textColour = new JMenuItem();
 165
 166   JMenu editGroupMenu = new JMenu();
 167
 168   JMenuItem chooseStructure = new JMenuItem();
 169
 170   JMenu rnaStructureMenu = new JMenu();
 171
 172   /**
 173    * Constructs a menu with sub-menu items for any hyperlinks for the sequence
 174    * and/or features provided. Hyperlinks may include a lookup by sequence id,
 175    * or database cross-references, depending on which links are enabled in user
 176    * preferences.
 177    *
 178    * @param seq
 179    * @param features
 180    * @return
 181    */
 182   protected static JMenu buildLinkMenu(final SequenceI seq,
 183           List<SequenceFeature> features)
 184   {
 185     JMenu linkMenu = new JMenu(MessageManager.getString("action.link"));
 186
 187     List<String> nlinks = null;
 188     if (seq != null)
 189     {
 190       nlinks = Preferences.sequenceUrlLinks.getLinksForMenu();
 191       UrlLink.sort(nlinks);
 192     }
 193     else
 194     {
 195       nlinks = new ArrayList<>();
 196     }
 197
 198     if (features != null)
 199     {
 200       for (SequenceFeature sf : features)
 201       {
 202         if (sf.links != null)
 203         {
 204           for (String link : sf.links)
 205           {
 206             nlinks.add(link);
 207           }
 208         }
 209       }
 210     }
 211
 212     /*
 213      * instantiate the hyperlinklink templates from sequence data;
 214      * note the order of the templates is preserved in the map
 215      */
 216     Map<String, List<String>> linkset = new LinkedHashMap<>();
 217     for (String link : nlinks)
 218     {
 219       UrlLink urlLink = null;
 220       try
 221       {
 222         urlLink = new UrlLink(link);
 223       } catch (Exception foo)
 224       {
 225         Cache.log.error("Exception for URLLink '" + link + "'", foo);
 226         continue;
 227       }
 228
 229       if (!urlLink.isValid())
 230       {
 231         Cache.log.error(urlLink.getInvalidMessage());
 232         continue;
 233       }
 234
 235       urlLink.createLinksFromSeq(seq, linkset);
 236     }
 237
 238     /*
 239      * construct menu items for the hyperlinks (still preserving
 240      * the order of the sorted templates)
 241      */
 242     addUrlLinks(linkMenu, linkset.values());
 243
 244     return linkMenu;
 245   }
 246
 247   /**
 248    * A helper method that builds menu items from the given links, with action
 249    * handlers to open the link URL, and adds them to the linkMenu. Each provided
 250    * link should be a list whose second item is the menu text, and whose fourth
 251    * item is the URL to open when the menu item is selected.
 252    *
 253    * @param linkMenu
 254    * @param linkset
 255    */
 256   static private void addUrlLinks(JMenu linkMenu,
 257           Collection<List<String>> linkset)
 258   {
 259     for (List<String> linkstrset : linkset)
 260     {
 261       final String url = linkstrset.get(3);
 262       JMenuItem item = new JMenuItem(linkstrset.get(1));
 263       item.setToolTipText(MessageManager
 264               .formatMessage("label.open_url_param", new Object[]
 265               { url }));
 266       item.addActionListener(new ActionListener()
 267       {
 268         @Override
 269         public void actionPerformed(ActionEvent e)
 270         {
 271           new Thread(new Runnable()
 272           {
 273             @Override
 274             public void run()
 275             {
 276               showLink(url);
 277             }
 278           }).start();
 279         }
 280       });
 281       linkMenu.add(item);
 282     }
 283   }
 284
 285   /**
 286    * Opens the provided url in the default web browser, or shows an error
 287    * message if this fails
 288    *
 289    * @param url
 290    */
 291   static void showLink(String url)
 292   {
 293     try
 294     {
 295       jalview.util.BrowserLauncher.openURL(url);
 296     } catch (Exception ex)
 297     {
 298       JvOptionPane.showInternalMessageDialog(Desktop.desktop,
 299               MessageManager.getString("label.web_browser_not_found_unix"),
 300               MessageManager.getString("label.web_browser_not_found"),
 301               JvOptionPane.WARNING_MESSAGE);
 302
 303       ex.printStackTrace();
 304     }
 305   }
 306
 307   /**
 308    * add a late bound groupURL item to the given linkMenu
 309    *
 310    * @param linkMenu
 311    * @param label
 312    *          - menu label string
 313    * @param urlgenerator
 314    *          GroupURLLink used to generate URL
 315    * @param urlstub
 316    *          Object array returned from the makeUrlStubs function.
 317    */
 318   static void addshowLink(JMenu linkMenu, String label,
 319           final GroupUrlLink urlgenerator, final Object[] urlstub)
 320   {
 321     JMenuItem item = new JMenuItem(label);
 322     item.setToolTipText(MessageManager
 323             .formatMessage("label.open_url_seqs_param", new Object[]
 324             { urlgenerator.getUrl_prefix(),
 325                 urlgenerator.getNumberInvolved(urlstub) }));
 326     // TODO: put in info about what is being sent.
 327     item.addActionListener(new ActionListener()
 328     {
 329       @Override
 330       public void actionPerformed(ActionEvent e)
 331       {
 332         new Thread(new Runnable()
 333         {
 334
 335           @Override
 336           public void run()
 337           {
 338             try
 339             {
 340               showLink(urlgenerator.constructFrom(urlstub));
 341             } catch (UrlStringTooLongException e2)
 342             {
 343             }
 344           }
 345
 346         }).start();
 347       }
 348     });
 349
 350     linkMenu.add(item);
 351   }
 352
 353   /**
 354    * Constructor for a PopupMenu for a click in the alignment panel (on a residue)
 355    *
 356    * @param ap
 357    *              the panel in which the mouse is clicked
 358    * @param seq
 359    *              the sequence under the mouse
 360    * @throws NullPointerException
 361    *                                if seq is null
 362    */
 363   public PopupMenu(final AlignmentPanel ap, SequenceI seq, int column)
 364   {
 365     this(false, ap, seq, column, null);
 366   }
 367
 368   /**
 369    * Constructor for a PopupMenu for a click in the sequence id panel
 370    *
 371    * @param alignPanel
 372    *                     the panel in which the mouse is clicked
 373    * @param seq
 374    *                     the sequence under the mouse click
 375    * @param groupLinks
 376    *                     templates for sequence external links
 377    * @throws NullPointerException
 378    *                                if seq is null
 379    */
 380   public PopupMenu(final AlignmentPanel alignPanel, final SequenceI seq,
 381           List<String> groupLinks)
 382   {
 383     this(true, alignPanel, seq, -1, groupLinks);
 384   }
 385
 386   /**
 387    * Private constructor that constructs a popup menu for either sequence ID
 388    * Panel, or alignment context
 389    *
 390    * @param fromIdPanel
 391    * @param alignPanel
 392    * @param seq
 393    * @param column
 394    *                      aligned column position (0...)
 395    * @param groupLinks
 396    */
 397   private PopupMenu(boolean fromIdPanel,
 398           final AlignmentPanel alignPanel,
 399           final SequenceI seq, final int column, List<String> groupLinks)
 400   {
 401     Objects.requireNonNull(seq);
 402     this.forIdPanel = fromIdPanel;
 403     this.ap = alignPanel;
 404     sequence = seq;
 405
 406     for (String ff : FileFormats.getInstance().getWritableFormats(true))
 407     {
 408       JMenuItem item = new JMenuItem(ff);
 409
 410       item.addActionListener(new ActionListener()
 411       {
 412         @Override
 413         public void actionPerformed(ActionEvent e)
 414         {
 415           outputText_actionPerformed(e);
 416         }
 417       });
 418
 419       outputMenu.add(item);
 420     }
 421
 422     /*
 423      * Build menus for annotation types that may be shown or hidden, and for
 424      * 'reference annotations' that may be added to the alignment. First for the
 425      * currently selected sequence (if there is one):
 426      */
 427     final List<SequenceI> selectedSequence = (forIdPanel && seq != null
 428             ? Arrays.asList(seq)
 429             : Collections.<SequenceI> emptyList());
 430     buildAnnotationTypesMenus(seqShowAnnotationsMenu,
 431             seqHideAnnotationsMenu, selectedSequence);
 432     configureReferenceAnnotationsMenu(seqAddReferenceAnnotations,
 433             selectedSequence);
 434
 435     /*
 436      * And repeat for the current selection group (if there is one):
 437      */
 438     final List<SequenceI> selectedGroup = (alignPanel.av.getSelectionGroup() == null
 439             ? Collections.<SequenceI> emptyList()
 440             : alignPanel.av.getSelectionGroup().getSequences());
 441     buildAnnotationTypesMenus(groupShowAnnotationsMenu,
 442             groupHideAnnotationsMenu, selectedGroup);
 443     configureReferenceAnnotationsMenu(groupAddReferenceAnnotations,
 444             selectedGroup);
 445
 446     try
 447     {
 448       jbInit();
 449     } catch (Exception e)
 450     {
 451       e.printStackTrace();
 452     }
 453
 454     if (forIdPanel)
 455     {
 456       JMenuItem menuItem;
 457       sequenceMenu.setText(sequence.getName());
 458       if (seq == alignPanel.av.getAlignment().getSeqrep())
 459       {
 460         makeReferenceSeq.setText(
 461                 MessageManager.getString("action.unmark_as_reference"));
 462       }
 463       else
 464       {
 465         makeReferenceSeq.setText(
 466                 MessageManager.getString("action.set_as_reference"));
 467       }
 468
 469       if (!alignPanel.av.getAlignment().isNucleotide())
 470       {
 471         remove(rnaStructureMenu);
 472       }
 473       else
 474       {
 475         int origCount = rnaStructureMenu.getItemCount();
 476         /*
 477          * add menu items to 2D-render any alignment or sequence secondary
 478          * structure annotation
 479          */
 480         AlignmentAnnotation[] aas = alignPanel.av.getAlignment()
 481                 .getAlignmentAnnotation();
 482         if (aas != null)
 483         {
 484           for (final AlignmentAnnotation aa : aas)
 485           {
 486             if (aa.isValidStruc() && aa.sequenceRef == null)
 487             {
 488               /*
 489                * valid alignment RNA secondary structure annotation
 490                */
 491               menuItem = new JMenuItem();
 492               menuItem.setText(MessageManager.formatMessage(
 493                       "label.2d_rna_structure_line", new Object[]
 494                       { aa.label }));
 495               menuItem.addActionListener(new ActionListener()
 496               {
 497                 @Override
 498                 public void actionPerformed(ActionEvent e)
 499                 {
 500                   new AppVarna(seq, aa, alignPanel);
 501                 }
 502               });
 503               rnaStructureMenu.add(menuItem);
 504             }
 505           }
 506         }
 507
 508         if (seq.getAnnotation() != null)
 509         {
 510           AlignmentAnnotation seqAnns[] = seq.getAnnotation();
 511           for (final AlignmentAnnotation aa : seqAnns)
 512           {
 513             if (aa.isValidStruc())
 514             {
 515               /*
 516                * valid sequence RNA secondary structure annotation
 517                */
 518               // TODO: make rnastrucF a bit more nice
 519               menuItem = new JMenuItem();
 520               menuItem.setText(MessageManager.formatMessage(
 521                       "label.2d_rna_sequence_name", new Object[]
 522                       { seq.getName() }));
 523               menuItem.addActionListener(new ActionListener()
 524               {
 525                 @Override
 526                 public void actionPerformed(ActionEvent e)
 527                 {
 528                   // TODO: VARNA does'nt print gaps in the sequence
 529                   new AppVarna(seq, aa, alignPanel);
 530                 }
 531               });
 532               rnaStructureMenu.add(menuItem);
 533             }
 534           }
 535         }
 536         if (rnaStructureMenu.getItemCount() == origCount)
 537         {
 538           remove(rnaStructureMenu);
 539         }
 540       }
 541
 542       menuItem = new JMenuItem(
 543               MessageManager.getString("action.hide_sequences"));
 544       menuItem.addActionListener(new ActionListener()
 545       {
 546         @Override
 547         public void actionPerformed(ActionEvent e)
 548         {
 549           hideSequences(false);
 550         }
 551       });
 552       add(menuItem);
 553
 554       if (alignPanel.av.getSelectionGroup() != null
 555               && alignPanel.av.getSelectionGroup().getSize() > 1)
 556       {
 557         menuItem = new JMenuItem(MessageManager
 558                 .formatMessage("label.represent_group_with", new Object[]
 559                 { seq.getName() }));
 560         menuItem.addActionListener(new ActionListener()
 561         {
 562           @Override
 563           public void actionPerformed(ActionEvent e)
 564           {
 565             hideSequences(true);
 566           }
 567         });
 568         sequenceMenu.add(menuItem);
 569       }
 570
 571       if (alignPanel.av.hasHiddenRows())
 572       {
 573         final int index = alignPanel.av.getAlignment().findIndex(seq);
 574
 575         if (alignPanel.av.adjustForHiddenSeqs(index)
 576                 - alignPanel.av.adjustForHiddenSeqs(index - 1) > 1)
 577         {
 578           menuItem = new JMenuItem(
 579                   MessageManager.getString("action.reveal_sequences"));
 580           menuItem.addActionListener(new ActionListener()
 581           {
 582             @Override
 583             public void actionPerformed(ActionEvent e)
 584             {
 585               alignPanel.av.showSequence(index);
 586               if (alignPanel.overviewPanel != null)
 587               {
 588                 alignPanel.overviewPanel.updateOverviewImage();
 589               }
 590             }
 591           });
 592           add(menuItem);
 593         }
 594       }
 595     }
 596
 597     /*
 598      * offer 'Reveal All'
 599      * - in the IdPanel (seq not null) if any sequence is hidden
 600      * - in the IdPanel or SeqPanel if all sequences are hidden (seq is null)
 601      */
 602     if (alignPanel.av.hasHiddenRows())
 603     {
 604       boolean addOption = seq != null;
 605       if (!addOption && alignPanel.av.getAlignment().getHeight() == 0)
 606       {
 607         addOption = true;
 608       }
 609       if (addOption)
 610       {
 611         JMenuItem menuItem = new JMenuItem(
 612                 MessageManager.getString("action.reveal_all"));
 613         menuItem.addActionListener(new ActionListener()
 614         {
 615           @Override
 616           public void actionPerformed(ActionEvent e)
 617           {
 618             alignPanel.av.showAllHiddenSeqs();
 619             if (alignPanel.overviewPanel != null)
 620             {
 621               alignPanel.overviewPanel.updateOverviewImage();
 622             }
 623           }
 624         });
 625         add(menuItem);
 626       }
 627     }
 628
 629     SequenceGroup sg = alignPanel.av.getSelectionGroup();
 630     boolean isDefinedGroup = (sg != null)
 631             ? alignPanel.av.getAlignment().getGroups().contains(sg)
 632             : false;
 633
 634     if (sg != null && sg.getSize() > 0)
 635     {
 636       groupName.setText(MessageManager
 637               .getString("label.edit_name_and_description_current_group"));
 638
 639       ColourMenuHelper.setColourSelected(colourMenu, sg.getColourScheme());
 640
 641       conservationMenuItem.setEnabled(!sg.isNucleotide());
 642
 643       if (sg.cs != null)
 644       {
 645         if (sg.cs.conservationApplied())
 646         {
 647           conservationMenuItem.setSelected(true);
 648         }
 649         if (sg.cs.getThreshold() > 0)
 650         {
 651           abovePIDColour.setSelected(true);
 652         }
 653       }
 654       modifyConservation.setEnabled(conservationMenuItem.isSelected());
 655       modifyPID.setEnabled(abovePIDColour.isSelected());
 656       displayNonconserved.setSelected(sg.getShowNonconserved());
 657       showText.setSelected(sg.getDisplayText());
 658       showColourText.setSelected(sg.getColourText());
 659       showBoxes.setSelected(sg.getDisplayBoxes());
 660       // add any groupURLs to the groupURL submenu and make it visible
 661       if (groupLinks != null && groupLinks.size() > 0)
 662       {
 663         buildGroupURLMenu(sg, groupLinks);
 664       }
 665       // Add a 'show all structures' for the current selection
 666       Hashtable<String, PDBEntry> pdbe = new Hashtable<>(), reppdb = new Hashtable<>();
 667
 668       SequenceI sqass = null;
 669       for (SequenceI sq : alignPanel.av.getSequenceSelection())
 670       {
 671         Vector<PDBEntry> pes = sq.getDatasetSequence().getAllPDBEntries();
 672         if (pes != null && pes.size() > 0)
 673         {
 674           reppdb.put(pes.get(0).getId(), pes.get(0));
 675           for (PDBEntry pe : pes)
 676           {
 677             pdbe.put(pe.getId(), pe);
 678             if (sqass == null)
 679             {
 680               sqass = sq;
 681             }
 682           }
 683         }
 684       }
 685       if (pdbe.size() > 0)
 686       {
 687         final PDBEntry[] pe = pdbe.values()
 688                 .toArray(new PDBEntry[pdbe.size()]),
 689                 pr = reppdb.values().toArray(new PDBEntry[reppdb.size()]);
 690         final JMenuItem gpdbview, rpdbview;
 691       }
 692     }
 693     else
 694     {
 695       groupMenu.setVisible(false);
 696       editMenu.setVisible(false);
 697     }
 698
 699     if (!isDefinedGroup)
 700     {
 701       createGroupMenuItem.setVisible(true);
 702       unGroupMenuItem.setVisible(false);
 703       editGroupMenu.setText(MessageManager.getString("action.edit_new_group"));
 704     }
 705     else
 706     {
 707       createGroupMenuItem.setVisible(false);
 708       unGroupMenuItem.setVisible(true);
 709       editGroupMenu.setText(MessageManager.getString("action.edit_group"));
 710     }
 711
 712     if (!forIdPanel)
 713     {
 714       sequenceMenu.setVisible(false);
 715       chooseStructure.setVisible(false);
 716       rnaStructureMenu.setVisible(false);
 717     }
 718
 719     addLinksAndFeatures(seq, column);
 720   }
 721
 722   /**
 723    * Adds
 724    * <ul>
 725    * <li>configured sequence database links (ID panel popup menu)</li>
 726    * <li>non-positional feature links (ID panel popup menu)</li>
 727    * <li>positional feature links (alignment panel popup menu)</li>
 728    * <li>feature details links (alignment panel popup menu)</li>
 729    * </ul>
 730    * If this panel is also showed complementary (CDS/protein) features, then links
 731    * to their feature details are also added.
 732    *
 733    * @param seq
 734    * @param column
 735    */
 736   void addLinksAndFeatures(final SequenceI seq, final int column)
 737   {
 738     List<SequenceFeature> features = null;
 739     if (forIdPanel)
 740     {
 741       features = sequence.getFeatures().getNonPositionalFeatures();
 742     }
 743     else
 744     {
 745       features = ap.getFeatureRenderer().findFeaturesAtColumn(sequence,
 746               column + 1);
 747     }
 748
 749     addLinks(seq, features);
 750
 751     if (!forIdPanel)
 752     {
 753       addFeatureDetails(features, seq, column);
 754     }
 755   }
 756
 757   /**
 758    * Add a menu item to show feature details for each sequence feature. Any
 759    * linked 'virtual' features (CDS/protein) are also optionally found and
 760    * included.
 761    *
 762    * @param features
 763    * @param seq
 764    * @param column
 765    */
 766   protected void addFeatureDetails(List<SequenceFeature> features,
 767           final SequenceI seq, final int column)
 768   {
 769     /*
 770      * add features in CDS/protein complement at the corresponding
 771      * position if configured to do so
 772      */
 773     MappedFeatures mf = null;
 774     if (ap.av.isShowComplementFeatures())
 775     {
 776       if (!Comparison.isGap(sequence.getCharAt(column)))
 777       {
 778         AlignViewportI complement = ap.getAlignViewport()
 779                 .getCodingComplement();
 780         AlignFrame af = Desktop.getAlignFrameFor(complement);
 781         FeatureRendererModel fr2 = af.getFeatureRenderer();
 782         int seqPos = sequence.findPosition(column);
 783         mf = fr2.findComplementFeaturesAtResidue(sequence, seqPos);
 784       }
 785     }
 786
 787     if (features.isEmpty() && mf == null)
 788     {
 789       /*
 790        * no features to show at this position
 791        */
 792       return;
 793     }
 794
 795     JMenu details = new JMenu(
 796             MessageManager.getString("label.feature_details"));
 797     add(details);
 798
 799     String name = seq.getName();
 800     for (final SequenceFeature sf : features)
 801     {
 802       addFeatureDetailsMenuItem(details, name, sf, null);
 803     }
 804
 805     if (mf != null)
 806     {
 807       for (final SequenceFeature sf : mf.features)
 808       {
 809         addFeatureDetailsMenuItem(details, name, sf, mf);
 810       }
 811     }
 812   }
 813
 814   /**
 815    * A helper method to add one menu item whose action is to show details for
 816    * one feature. The menu text includes feature description, but this may be
 817    * truncated.
 818    *
 819    * @param details
 820    * @param seqName
 821    * @param sf
 822    * @param mf
 823    */
 824   void addFeatureDetailsMenuItem(JMenu details, final String seqName,
 825           final SequenceFeature sf, MappedFeatures mf)
 826   {
 827     int start = sf.getBegin();
 828     int end = sf.getEnd();
 829     if (mf != null)
 830     {
 831       /*
 832        * show local rather than linked feature coordinates
 833        */
 834       int[] beginRange = mf.getMappedPositions(start, start);
 835       int[] endRange = mf.getMappedPositions(end, end);
 836       if (beginRange == null || endRange == null)
 837       {
 838         // e.g. variant extending to stop codon so not mappable
 839         return;
 840       }
 841       start = beginRange[0];
 842       end = endRange[endRange.length - 1];
 843     }
 844     StringBuilder desc = new StringBuilder();
 845     desc.append(sf.getType()).append(" ").append(String.valueOf(start));
 846     if (start != end)
 847     {
 848       desc.append(sf.isContactFeature() ? ":" : "-");
 849       desc.append(String.valueOf(end));
 850     }
 851     String description = sf.getDescription();
 852     if (description != null)
 853     {
 854       desc.append(" ");
 855       description = StringUtils.stripHtmlTags(description);
 856
 857       /*
 858        * truncate overlong descriptions unless they contain an href
 859        * (as truncation could leave corrupted html)
 860        */
 861       boolean hasLink = description.indexOf("a href") > -1;
 862       if (description.length() > FEATURE_DESC_MAX && !hasLink)
 863       {
 864         description = description.substring(0, FEATURE_DESC_MAX) + "...";
 865       }
 866       desc.append(description);
 867     }
 868     String featureGroup = sf.getFeatureGroup();
 869     if (featureGroup != null)
 870     {
 871       desc.append(" (").append(featureGroup).append(")");
 872     }
 873     String htmlText = JvSwingUtils.wrapTooltip(true, desc.toString());
 874     JMenuItem item = new JMenuItem(htmlText);
 875     item.addActionListener(new ActionListener()
 876     {
 877       @Override
 878       public void actionPerformed(ActionEvent e)
 879       {
 880         showFeatureDetails(sf, seqName, mf);
 881       }
 882     });
 883     details.add(item);
 884   }
 885
 886   /**
 887    * Opens a panel showing a text report of feature details
 888    *
 889    * @param sf
 890    * @param seqName
 891    * @param mf
 892    */
 893   protected void showFeatureDetails(SequenceFeature sf, String seqName,
 894           MappedFeatures mf)
 895   {
 896     CutAndPasteHtmlTransfer cap = new CutAndPasteHtmlTransfer();
 897     // it appears Java's CSS does not support border-collapse :-(
 898     cap.addStylesheetRule("table { border-collapse: collapse;}");
 899     cap.addStylesheetRule("table, td, th {border: 1px solid black;}");
 900     cap.setText(sf.getDetailsReport(seqName, mf));
 901
 902     Desktop.addInternalFrame(cap,
 903             MessageManager.getString("label.feature_details"), 500, 500);
 904   }
 905
 906   /**
 907    * Adds a 'Link' menu item with a sub-menu item for each hyperlink provided.
 908    * When seq is not null, these are links for the sequence id, which may be to
 909    * external web sites for the sequence accession, and/or links embedded in
 910    * non-positional features. When seq is null, only links embedded in the
 911    * provided features are added. If no links are found, the menu is not added.
 912    *
 913    * @param seq
 914    * @param features
 915    */
 916   void addLinks(final SequenceI seq, List<SequenceFeature> features)
 917   {
 918     JMenu linkMenu = buildLinkMenu(forIdPanel ? seq : null, features);
 919
 920     // only add link menu if it has entries
 921     if (linkMenu.getItemCount() > 0)
 922     {
 923       if (forIdPanel)
 924       {
 925         sequenceMenu.add(linkMenu);
 926       }
 927       else
 928       {
 929         add(linkMenu);
 930       }
 931     }
 932   }
 933
 934   /**
 935    * Add annotation types to 'Show annotations' and/or 'Hide annotations' menus.
 936    * "All" is added first, followed by a separator. Then add any annotation
 937    * types associated with the current selection. Separate menus are built for
 938    * the selected sequence group (if any), and the selected sequence.
 939    * <p>
 940    * Some annotation rows are always rendered together - these can be identified
 941    * by a common graphGroup property > -1. Only one of each group will be marked
 942    * as visible (to avoid duplication of the display). For such groups we add a
 943    * composite type name, e.g.
 944    * <p>
 945    * IUPredWS (Long), IUPredWS (Short)
 946    *
 947    * @param seq
 948    */
 949   protected void buildAnnotationTypesMenus(JMenu showMenu, JMenu hideMenu,
 950           List<SequenceI> forSequences)
 951   {
 952     showMenu.removeAll();
 953     hideMenu.removeAll();
 954
 955     final List<String> all = Arrays
 956             .asList(new String[]
 957             { MessageManager.getString("label.all") });
 958     addAnnotationTypeToShowHide(showMenu, forSequences, "", all, true,
 959             true);
 960     addAnnotationTypeToShowHide(hideMenu, forSequences, "", all, true,
 961             false);
 962     showMenu.addSeparator();
 963     hideMenu.addSeparator();
 964
 965     final AlignmentAnnotation[] annotations = ap.getAlignment()
 966             .getAlignmentAnnotation();
 967
 968     /*
 969      * Find shown/hidden annotations types, distinguished by source (calcId),
 970      * and grouped by graphGroup. Using LinkedHashMap means we will retrieve in
 971      * the insertion order, which is the order of the annotations on the
 972      * alignment.
 973      */
 974     Map<String, List<List<String>>> shownTypes = new LinkedHashMap<>();
 975     Map<String, List<List<String>>> hiddenTypes = new LinkedHashMap<>();
 976     AlignmentAnnotationUtils.getShownHiddenTypes(shownTypes, hiddenTypes,
 977             AlignmentAnnotationUtils.asList(annotations), forSequences);
 978
 979     for (String calcId : hiddenTypes.keySet())
 980     {
 981       for (List<String> type : hiddenTypes.get(calcId))
 982       {
 983         addAnnotationTypeToShowHide(showMenu, forSequences, calcId, type,
 984                 false, true);
 985       }
 986     }
 987     // grey out 'show annotations' if none are hidden
 988     showMenu.setEnabled(!hiddenTypes.isEmpty());
 989
 990     for (String calcId : shownTypes.keySet())
 991     {
 992       for (List<String> type : shownTypes.get(calcId))
 993       {
 994         addAnnotationTypeToShowHide(hideMenu, forSequences, calcId, type,
 995                 false, false);
 996       }
 997     }
 998     // grey out 'hide annotations' if none are shown
 999     hideMenu.setEnabled(!shownTypes.isEmpty());
1000   }
1001
1002   /**
1003    * Returns a list of sequences - either the current selection group (if there
1004    * is one), else the specified single sequence.
1005    *
1006    * @param seq
1007    * @return
1008    */
1009   protected List<SequenceI> getSequenceScope(SequenceI seq)
1010   {
1011     List<SequenceI> forSequences = null;
1012     final SequenceGroup selectionGroup = ap.av.getSelectionGroup();
1013     if (selectionGroup != null && selectionGroup.getSize() > 0)
1014     {
1015       forSequences = selectionGroup.getSequences();
1016     }
1017     else
1018     {
1019       forSequences = seq == null ? Collections.<SequenceI> emptyList()
1020               : Arrays.asList(seq);
1021     }
1022     return forSequences;
1023   }
1024
1025   /**
1026    * Add one annotation type to the 'Show Annotations' or 'Hide Annotations'
1027    * menus.
1028    *
1029    * @param showOrHideMenu
1030    *          the menu to add to
1031    * @param forSequences
1032    *          the sequences whose annotations may be shown or hidden
1033    * @param calcId
1034    * @param types
1035    *          the label to add
1036    * @param allTypes
1037    *          if true this is a special label meaning 'All'
1038    * @param actionIsShow
1039    *          if true, the select menu item action is to show the annotation
1040    *          type, else hide
1041    */
1042   protected void addAnnotationTypeToShowHide(JMenu showOrHideMenu,
1043           final List<SequenceI> forSequences, String calcId,
1044           final List<String> types, final boolean allTypes,
1045           final boolean actionIsShow)
1046   {
1047     String label = types.toString(); // [a, b, c]
1048     label = label.substring(1, label.length() - 1); // a, b, c
1049     final JMenuItem item = new JMenuItem(label);
1050     item.setToolTipText(calcId);
1051     item.addActionListener(new ActionListener()
1052     {
1053       @Override
1054       public void actionPerformed(ActionEvent e)
1055       {
1056         AlignmentUtils.showOrHideSequenceAnnotations(ap.getAlignment(),
1057                 types, forSequences, allTypes, actionIsShow);
1058         refresh();
1059       }
1060     });
1061     showOrHideMenu.add(item);
1062   }
1063
1064   private void buildGroupURLMenu(SequenceGroup sg, List<String> groupLinks)
1065   {
1066
1067     // TODO: usability: thread off the generation of group url content so root
1068     // menu appears asap
1069     // sequence only URLs
1070     // ID/regex match URLs
1071     JMenu groupLinksMenu = new JMenu(
1072             MessageManager.getString("action.group_link"));
1073     // three types of url that might be created.
1074     JMenu[] linkMenus = new JMenu[] { null,
1075         new JMenu(MessageManager.getString("action.ids")),
1076         new JMenu(MessageManager.getString("action.sequences")),
1077         new JMenu(MessageManager.getString("action.ids_sequences")) };
1078
1079     SequenceI[] seqs = ap.av.getSelectionAsNewSequence();
1080     String[][] idandseqs = GroupUrlLink.formStrings(seqs);
1081     Hashtable<String, Object[]> commonDbrefs = new Hashtable<>();
1082     for (int sq = 0; sq < seqs.length; sq++)
1083     {
1084
1085       int start = seqs[sq].findPosition(sg.getStartRes()),
1086               end = seqs[sq].findPosition(sg.getEndRes());
1087       // just collect ids from dataset sequence
1088       // TODO: check if IDs collected from selecton group intersects with the
1089       // current selection, too
1090       SequenceI sqi = seqs[sq];
1091       while (sqi.getDatasetSequence() != null)
1092       {
1093         sqi = sqi.getDatasetSequence();
1094       }
1095       DBRefEntry[] dbr = sqi.getDBRefs();
1096       if (dbr != null && dbr.length > 0)
1097       {
1098         for (int d = 0; d < dbr.length; d++)
1099         {
1100           String src = dbr[d].getSource(); // jalview.util.DBRefUtils.getCanonicalName(dbr[d].getSource()).toUpperCase();
1101           Object[] sarray = commonDbrefs.get(src);
1102           if (sarray == null)
1103           {
1104             sarray = new Object[2];
1105             sarray[0] = new int[] { 0 };
1106             sarray[1] = new String[seqs.length];
1107
1108             commonDbrefs.put(src, sarray);
1109           }
1110
1111           if (((String[]) sarray[1])[sq] == null)
1112           {
1113             if (!dbr[d].hasMap() || (dbr[d].getMap()
1114                     .locateMappedRange(start, end) != null))
1115             {
1116               ((String[]) sarray[1])[sq] = dbr[d].getAccessionId();
1117               ((int[]) sarray[0])[0]++;
1118             }
1119           }
1120         }
1121       }
1122     }
1123     // now create group links for all distinct ID/sequence sets.
1124     boolean addMenu = false; // indicates if there are any group links to give
1125                              // to user
1126     for (String link : groupLinks)
1127     {
1128       GroupUrlLink urlLink = null;
1129       try
1130       {
1131         urlLink = new GroupUrlLink(link);
1132       } catch (Exception foo)
1133       {
1134         Cache.log.error("Exception for GroupURLLink '" + link + "'", foo);
1135         continue;
1136       }
1137       ;
1138       if (!urlLink.isValid())
1139       {
1140         Cache.log.error(urlLink.getInvalidMessage());
1141         continue;
1142       }
1143       final String label = urlLink.getLabel();
1144       boolean usingNames = false;
1145       // Now see which parts of the group apply for this URL
1146       String ltarget = urlLink.getTarget(); // jalview.util.DBRefUtils.getCanonicalName(urlLink.getTarget());
1147       Object[] idset = commonDbrefs.get(ltarget.toUpperCase());
1148       String[] seqstr, ids; // input to makeUrl
1149       if (idset != null)
1150       {
1151         int numinput = ((int[]) idset[0])[0];
1152         String[] allids = ((String[]) idset[1]);
1153         seqstr = new String[numinput];
1154         ids = new String[numinput];
1155         for (int sq = 0, idcount = 0; sq < seqs.length; sq++)
1156         {
1157           if (allids[sq] != null)
1158           {
1159             ids[idcount] = allids[sq];
1160             seqstr[idcount++] = idandseqs[1][sq];
1161           }
1162         }
1163       }
1164       else
1165       {
1166         // just use the id/seq set
1167         seqstr = idandseqs[1];
1168         ids = idandseqs[0];
1169         usingNames = true;
1170       }
1171       // and try and make the groupURL!
1172
1173       Object[] urlset = null;
1174       try
1175       {
1176         urlset = urlLink.makeUrlStubs(ids, seqstr,
1177                 "FromJalview" + System.currentTimeMillis(), false);
1178       } catch (UrlStringTooLongException e)
1179       {
1180       }
1181       if (urlset != null)
1182       {
1183         int type = urlLink.getGroupURLType() & 3;
1184         // first two bits ofurlLink type bitfield are sequenceids and sequences
1185         // TODO: FUTURE: ensure the groupURL menu structure can be generalised
1186         addshowLink(linkMenus[type],
1187                 label + (((type & 1) == 1)
1188                         ? ("(" + (usingNames ? "Names" : ltarget) + ")")
1189                         : ""),
1190                 urlLink, urlset);
1191         addMenu = true;
1192       }
1193     }
1194     if (addMenu)
1195     {
1196       groupLinksMenu = new JMenu(
1197               MessageManager.getString("action.group_link"));
1198       for (int m = 0; m < linkMenus.length; m++)
1199       {
1200         if (linkMenus[m] != null
1201                 && linkMenus[m].getMenuComponentCount() > 0)
1202         {
1203           groupLinksMenu.add(linkMenus[m]);
1204         }
1205       }
1206
1207       groupMenu.add(groupLinksMenu);
1208     }
1209   }
1210
1211   /**
1212    * DOCUMENT ME!
1213    *
1214    * @throws Exception
1215    *           DOCUMENT ME!
1216    */
1217   private void jbInit() throws Exception
1218   {
1219     groupMenu.setText(MessageManager.getString("label.selection"));
1220     groupName.setText(MessageManager.getString("label.name"));
1221     groupName.addActionListener(new ActionListener()
1222     {
1223       @Override
1224       public void actionPerformed(ActionEvent e)
1225       {
1226         groupName_actionPerformed();
1227       }
1228     });
1229     sequenceMenu.setText(MessageManager.getString("label.sequence"));
1230
1231     JMenuItem sequenceName = new JMenuItem(
1232             MessageManager.getString("label.edit_name_description"));
1233     sequenceName.addActionListener(new ActionListener()
1234     {
1235       @Override
1236       public void actionPerformed(ActionEvent e)
1237       {
1238         sequenceName_actionPerformed();
1239       }
1240     });
1241     JMenuItem chooseAnnotations = new JMenuItem(
1242             MessageManager.getString("action.choose_annotations"));
1243     chooseAnnotations.addActionListener(new ActionListener()
1244     {
1245       @Override
1246       public void actionPerformed(ActionEvent e)
1247       {
1248         chooseAnnotations_actionPerformed(e);
1249       }
1250     });
1251     JMenuItem sequenceDetails = new JMenuItem(
1252             MessageManager.getString("label.sequence_details"));
1253     sequenceDetails.addActionListener(new ActionListener()
1254     {
1255       @Override
1256       public void actionPerformed(ActionEvent e)
1257       {
1258         createSequenceDetailsReport(new SequenceI[] { sequence });
1259       }
1260     });
1261     JMenuItem sequenceSelDetails = new JMenuItem(
1262             MessageManager.getString("label.sequence_details"));
1263     sequenceSelDetails.addActionListener(new ActionListener()
1264     {
1265       @Override
1266       public void actionPerformed(ActionEvent e)
1267       {
1268         createSequenceDetailsReport(ap.av.getSequenceSelection());
1269       }
1270     });
1271
1272     unGroupMenuItem
1273             .setText(MessageManager.getString("action.remove_group"));
1274     unGroupMenuItem.addActionListener(new ActionListener()
1275     {
1276       @Override
1277       public void actionPerformed(ActionEvent e)
1278       {
1279         unGroupMenuItem_actionPerformed();
1280       }
1281     });
1282     createGroupMenuItem
1283             .setText(MessageManager.getString("action.create_group"));
1284     createGroupMenuItem.addActionListener(new ActionListener()
1285     {
1286       @Override
1287       public void actionPerformed(ActionEvent e)
1288       {
1289         createGroupMenuItem_actionPerformed();
1290       }
1291     });
1292
1293     JMenuItem outline = new JMenuItem(
1294             MessageManager.getString("action.border_colour"));
1295     outline.addActionListener(new ActionListener()
1296     {
1297       @Override
1298       public void actionPerformed(ActionEvent e)
1299       {
1300         outline_actionPerformed();
1301       }
1302     });
1303     showBoxes.setText(MessageManager.getString("action.boxes"));
1304     showBoxes.setState(true);
1305     showBoxes.addActionListener(new ActionListener()
1306     {
1307       @Override
1308       public void actionPerformed(ActionEvent e)
1309       {
1310         showBoxes_actionPerformed();
1311       }
1312     });
1313     showText.setText(MessageManager.getString("action.text"));
1314     showText.setState(true);
1315     showText.addActionListener(new ActionListener()
1316     {
1317       @Override
1318       public void actionPerformed(ActionEvent e)
1319       {
1320         showText_actionPerformed();
1321       }
1322     });
1323     showColourText.setText(MessageManager.getString("label.colour_text"));
1324     showColourText.addActionListener(new ActionListener()
1325     {
1326       @Override
1327       public void actionPerformed(ActionEvent e)
1328       {
1329         showColourText_actionPerformed();
1330       }
1331     });
1332     displayNonconserved
1333             .setText(MessageManager.getString("label.show_non_conserved"));
1334     displayNonconserved.setState(true);
1335     displayNonconserved.addActionListener(new ActionListener()
1336     {
1337       @Override
1338       public void actionPerformed(ActionEvent e)
1339       {
1340         showNonconserved_actionPerformed();
1341       }
1342     });
1343     editMenu.setText(MessageManager.getString("action.edit"));
1344     JMenuItem cut = new JMenuItem(MessageManager.getString("action.cut"));
1345     cut.addActionListener(new ActionListener()
1346     {
1347       @Override
1348       public void actionPerformed(ActionEvent e)
1349       {
1350         cut_actionPerformed();
1351       }
1352     });
1353     upperCase.setText(MessageManager.getString("label.to_upper_case"));
1354     upperCase.addActionListener(new ActionListener()
1355     {
1356       @Override
1357       public void actionPerformed(ActionEvent e)
1358       {
1359         changeCase(e);
1360       }
1361     });
1362     JMenuItem copy = new JMenuItem(MessageManager.getString("action.copy"));
1363     copy.addActionListener(new ActionListener()
1364     {
1365       @Override
1366       public void actionPerformed(ActionEvent e)
1367       {
1368         copy_actionPerformed();
1369       }
1370     });
1371     lowerCase.setText(MessageManager.getString("label.to_lower_case"));
1372     lowerCase.addActionListener(new ActionListener()
1373     {
1374       @Override
1375       public void actionPerformed(ActionEvent e)
1376       {
1377         changeCase(e);
1378       }
1379     });
1380     toggle.setText(MessageManager.getString("label.toggle_case"));
1381     toggle.addActionListener(new ActionListener()
1382     {
1383       @Override
1384       public void actionPerformed(ActionEvent e)
1385       {
1386         changeCase(e);
1387       }
1388     });
1389     outputMenu.setText(
1390             MessageManager.getString("label.out_to_textbox") + "...");
1391     seqShowAnnotationsMenu
1392             .setText(MessageManager.getString("label.show_annotations"));
1393     seqHideAnnotationsMenu
1394             .setText(MessageManager.getString("label.hide_annotations"));
1395     groupShowAnnotationsMenu
1396             .setText(MessageManager.getString("label.show_annotations"));
1397     groupHideAnnotationsMenu
1398             .setText(MessageManager.getString("label.hide_annotations"));
1399     JMenuItem sequenceFeature = new JMenuItem(
1400             MessageManager.getString("label.create_sequence_feature"));
1401     sequenceFeature.addActionListener(new ActionListener()
1402     {
1403       @Override
1404       public void actionPerformed(ActionEvent e)
1405       {
1406         sequenceFeature_actionPerformed();
1407       }
1408     });
1409     editGroupMenu.setText(MessageManager.getString("label.group"));
1410     chooseStructure.setText(
1411             MessageManager.getString("label.show_pdbstruct_dialog"));
1412     chooseStructure.addActionListener(new ActionListener()
1413     {
1414       @Override
1415       public void actionPerformed(ActionEvent actionEvent)
1416       {
1417         SequenceI[] selectedSeqs = new SequenceI[] { sequence };
1418         if (ap.av.getSelectionGroup() != null)
1419         {
1420           selectedSeqs = ap.av.getSequenceSelection();
1421         }
1422         new StructureChooser(selectedSeqs, sequence, ap);
1423       }
1424     });
1425
1426     rnaStructureMenu
1427             .setText(MessageManager.getString("label.view_rna_structure"));
1428
1429     // colStructureMenu.setText("Colour By Structure");
1430     JMenuItem editSequence = new JMenuItem(
1431             MessageManager.getString("label.edit_sequence") + "...");
1432     editSequence.addActionListener(new ActionListener()
1433     {
1434       @Override
1435       public void actionPerformed(ActionEvent actionEvent)
1436       {
1437         editSequence_actionPerformed(actionEvent);
1438       }
1439     });
1440     makeReferenceSeq.setText(
1441             MessageManager.getString("label.mark_as_representative"));
1442     makeReferenceSeq.addActionListener(new ActionListener()
1443     {
1444
1445       @Override
1446       public void actionPerformed(ActionEvent actionEvent)
1447       {
1448         makeReferenceSeq_actionPerformed(actionEvent);
1449
1450       }
1451     });
1452
1453     groupMenu.add(sequenceSelDetails);
1454     add(groupMenu);
1455     add(sequenceMenu);
1456     add(rnaStructureMenu);
1457     add(chooseStructure);
1458     if (forIdPanel)
1459     {
1460       JMenuItem hideInsertions = new JMenuItem(
1461               MessageManager.getString("label.hide_insertions"));
1462       hideInsertions.addActionListener(new ActionListener()
1463       {
1464
1465         @Override
1466         public void actionPerformed(ActionEvent e)
1467         {
1468           hideInsertions_actionPerformed(e);
1469         }
1470       });
1471       add(hideInsertions);
1472     }
1473     // annotations configuration panel suppressed for now
1474     // groupMenu.add(chooseAnnotations);
1475
1476     /*
1477      * Add show/hide annotations to the Sequence menu, and to the Selection menu
1478      * (if a selection group is in force).
1479      */
1480     sequenceMenu.add(seqShowAnnotationsMenu);
1481     sequenceMenu.add(seqHideAnnotationsMenu);
1482     sequenceMenu.add(seqAddReferenceAnnotations);
1483     groupMenu.add(groupShowAnnotationsMenu);
1484     groupMenu.add(groupHideAnnotationsMenu);
1485     groupMenu.add(groupAddReferenceAnnotations);
1486     groupMenu.add(editMenu);
1487     groupMenu.add(outputMenu);
1488     groupMenu.add(sequenceFeature);
1489     groupMenu.add(createGroupMenuItem);
1490     groupMenu.add(unGroupMenuItem);
1491     groupMenu.add(editGroupMenu);
1492     sequenceMenu.add(sequenceName);
1493     sequenceMenu.add(sequenceDetails);
1494     sequenceMenu.add(makeReferenceSeq);
1495
1496     initColourMenu();
1497     buildColourMenu();
1498
1499     editMenu.add(copy);
1500     editMenu.add(cut);
1501     editMenu.add(editSequence);
1502     editMenu.add(upperCase);
1503     editMenu.add(lowerCase);
1504     editMenu.add(toggle);
1505     editGroupMenu.add(groupName);
1506     editGroupMenu.add(colourMenu);
1507     editGroupMenu.add(showBoxes);
1508     editGroupMenu.add(showText);
1509     editGroupMenu.add(showColourText);
1510     editGroupMenu.add(outline);
1511     editGroupMenu.add(displayNonconserved);
1512   }
1513
1514   /**
1515    * Constructs the entries for the colour menu
1516    */
1517   protected void initColourMenu()
1518   {
1519     colourMenu.setText(MessageManager.getString("label.group_colour"));
1520     textColour.setText(MessageManager.getString("label.text_colour"));
1521     textColour.addActionListener(new ActionListener()
1522     {
1523       @Override
1524       public void actionPerformed(ActionEvent e)
1525       {
1526         textColour_actionPerformed();
1527       }
1528     });
1529
1530     abovePIDColour.setText(
1531             MessageManager.getString("label.above_identity_threshold"));
1532     abovePIDColour.addActionListener(new ActionListener()
1533     {
1534       @Override
1535       public void actionPerformed(ActionEvent e)
1536       {
1537         abovePIDColour_actionPerformed(abovePIDColour.isSelected());
1538       }
1539     });
1540
1541     modifyPID.setText(
1542             MessageManager.getString("label.modify_identity_threshold"));
1543     modifyPID.addActionListener(new ActionListener()
1544     {
1545       @Override
1546       public void actionPerformed(ActionEvent e)
1547       {
1548         modifyPID_actionPerformed();
1549       }
1550     });
1551
1552     conservationMenuItem
1553             .setText(MessageManager.getString("action.by_conservation"));
1554     conservationMenuItem.addActionListener(new ActionListener()
1555     {
1556       @Override
1557       public void actionPerformed(ActionEvent e)
1558       {
1559         conservationMenuItem_actionPerformed(
1560                 conservationMenuItem.isSelected());
1561       }
1562     });
1563
1564     annotationColour = new JRadioButtonMenuItem(
1565             MessageManager.getString("action.by_annotation"));
1566     annotationColour.setName(ResidueColourScheme.ANNOTATION_COLOUR);
1567     annotationColour.setEnabled(false);
1568     annotationColour.setToolTipText(
1569             MessageManager.getString("label.by_annotation_tooltip"));
1570
1571     modifyConservation.setText(MessageManager
1572             .getString("label.modify_conservation_threshold"));
1573     modifyConservation.addActionListener(new ActionListener()
1574     {
1575       @Override
1576       public void actionPerformed(ActionEvent e)
1577       {
1578         modifyConservation_actionPerformed();
1579       }
1580     });
1581   }
1582
1583   /**
1584    * Builds the group colour sub-menu, including any user-defined colours which
1585    * were loaded at startup or during the Jalview session
1586    */
1587   protected void buildColourMenu()
1588   {
1589     SequenceGroup sg = ap.av.getSelectionGroup();
1590     if (sg == null)
1591     {
1592       /*
1593        * popup menu with no sequence group scope
1594        */
1595       return;
1596     }
1597     colourMenu.removeAll();
1598     colourMenu.add(textColour);
1599     colourMenu.addSeparator();
1600
1601     ButtonGroup bg = ColourMenuHelper.addMenuItems(colourMenu, this, sg,
1602             false);
1603     bg.add(annotationColour);
1604     colourMenu.add(annotationColour);
1605
1606     colourMenu.addSeparator();
1607     colourMenu.add(conservationMenuItem);
1608     colourMenu.add(modifyConservation);
1609     colourMenu.add(abovePIDColour);
1610     colourMenu.add(modifyPID);
1611   }
1612
1613   protected void modifyConservation_actionPerformed()
1614   {
1615     SequenceGroup sg = getGroup();
1616     if (sg.cs != null)
1617     {
1618       SliderPanel.setConservationSlider(ap, sg.cs, sg.getName());
1619       SliderPanel.showConservationSlider();
1620     }
1621   }
1622
1623   protected void modifyPID_actionPerformed()
1624   {
1625     SequenceGroup sg = getGroup();
1626     if (sg.cs != null)
1627     {
1628       // int threshold = SliderPanel.setPIDSliderSource(ap, sg.cs, getGroup()
1629       // .getName());
1630       // sg.cs.setThreshold(threshold, ap.av.isIgnoreGapsConsensus());
1631       SliderPanel.setPIDSliderSource(ap, sg.cs, getGroup().getName());
1632       SliderPanel.showPIDSlider();
1633     }
1634   }
1635
1636   /**
1637    * Check for any annotations on the underlying dataset sequences (for the
1638    * current selection group) which are not 'on the alignment'.If any are found,
1639    * enable the option to add them to the alignment. The criteria for 'on the
1640    * alignment' is finding an alignment annotation on the alignment, matched on
1641    * calcId, label and sequenceRef.
1642    *
1643    * A tooltip is also constructed that displays the source (calcId) and type
1644    * (label) of the annotations that can be added.
1645    *
1646    * @param menuItem
1647    * @param forSequences
1648    */
1649   protected void configureReferenceAnnotationsMenu(JMenuItem menuItem,
1650           List<SequenceI> forSequences)
1651   {
1652     menuItem.setEnabled(false);
1653
1654     /*
1655      * Temporary store to hold distinct calcId / type pairs for the tooltip.
1656      * Using TreeMap means calcIds are shown in alphabetical order.
1657      */
1658     SortedMap<String, String> tipEntries = new TreeMap<>();
1659     final Map<SequenceI, List<AlignmentAnnotation>> candidates = new LinkedHashMap<>();
1660     AlignmentI al = this.ap.av.getAlignment();
1661     AlignmentUtils.findAddableReferenceAnnotations(forSequences, tipEntries,
1662             candidates, al);
1663     if (!candidates.isEmpty())
1664     {
1665       StringBuilder tooltip = new StringBuilder(64);
1666       tooltip.append(MessageManager.getString("label.add_annotations_for"));
1667
1668       /*
1669        * Found annotations that could be added. Enable the menu item, and
1670        * configure its tooltip and action.
1671        */
1672       menuItem.setEnabled(true);
1673       for (String calcId : tipEntries.keySet())
1674       {
1675         tooltip.append("<br/>" + calcId + "/" + tipEntries.get(calcId));
1676       }
1677       String tooltipText = JvSwingUtils.wrapTooltip(true,
1678               tooltip.toString());
1679       menuItem.setToolTipText(tooltipText);
1680
1681       menuItem.addActionListener(new ActionListener()
1682       {
1683         @Override
1684         public void actionPerformed(ActionEvent e)
1685         {
1686           addReferenceAnnotations_actionPerformed(candidates);
1687         }
1688       });
1689     }
1690   }
1691
1692   /**
1693    * Add annotations to the sequences and to the alignment.
1694    *
1695    * @param candidates
1696    *          a map whose keys are sequences on the alignment, and values a list
1697    *          of annotations to add to each sequence
1698    */
1699   protected void addReferenceAnnotations_actionPerformed(
1700           Map<SequenceI, List<AlignmentAnnotation>> candidates)
1701   {
1702     final SequenceGroup selectionGroup = this.ap.av.getSelectionGroup();
1703     final AlignmentI alignment = this.ap.getAlignment();
1704     AlignmentUtils.addReferenceAnnotations(candidates, alignment,
1705             selectionGroup);
1706     refresh();
1707   }
1708
1709   protected void makeReferenceSeq_actionPerformed(ActionEvent actionEvent)
1710   {
1711     if (!ap.av.getAlignment().hasSeqrep())
1712     {
1713       // initialise the display flags so the user sees something happen
1714       ap.av.setDisplayReferenceSeq(true);
1715       ap.av.setColourByReferenceSeq(true);
1716       ap.av.getAlignment().setSeqrep(sequence);
1717     }
1718     else
1719     {
1720       if (ap.av.getAlignment().getSeqrep() == sequence)
1721       {
1722         ap.av.getAlignment().setSeqrep(null);
1723       }
1724       else
1725       {
1726         ap.av.getAlignment().setSeqrep(sequence);
1727       }
1728     }
1729     refresh();
1730   }
1731
1732   protected void hideInsertions_actionPerformed(ActionEvent actionEvent)
1733   {
1734     HiddenColumns hidden = ap.av.getAlignment().getHiddenColumns();
1735     BitSet inserts = new BitSet();
1736
1737     boolean markedPopup = false;
1738     // mark inserts in current selection
1739     if (ap.av.getSelectionGroup() != null)
1740     {
1741       // mark just the columns in the selection group to be hidden
1742       inserts.set(ap.av.getSelectionGroup().getStartRes(),
1743               ap.av.getSelectionGroup().getEndRes() + 1); // TODO why +1?
1744
1745       // now clear columns without gaps
1746       for (SequenceI sq : ap.av.getSelectionGroup().getSequences())
1747       {
1748         if (sq == sequence)
1749         {
1750           markedPopup = true;
1751         }
1752         inserts.and(sq.getInsertionsAsBits());
1753       }
1754       hidden.clearAndHideColumns(inserts, ap.av.getSelectionGroup().getStartRes(),
1755               ap.av.getSelectionGroup().getEndRes());
1756     }
1757
1758     // now mark for sequence under popup if we haven't already done it
1759     else if (!markedPopup && sequence != null)
1760     {
1761       inserts.or(sequence.getInsertionsAsBits());
1762
1763       // and set hidden columns accordingly
1764       hidden.hideColumns(inserts);
1765     }
1766     refresh();
1767   }
1768
1769   protected void sequenceSelectionDetails_actionPerformed()
1770   {
1771     createSequenceDetailsReport(ap.av.getSequenceSelection());
1772   }
1773
1774   public void createSequenceDetailsReport(SequenceI[] sequences)
1775   {
1776     CutAndPasteHtmlTransfer cap = new CutAndPasteHtmlTransfer();
1777     StringBuilder contents = new StringBuilder(128);
1778     for (SequenceI seq : sequences)
1779     {
1780       contents.append("<p><h2>" + MessageManager.formatMessage(
1781               "label.create_sequence_details_report_annotation_for",
1782               new Object[]
1783               { seq.getDisplayId(true) }) + "</h2></p><p>");
1784       new SequenceAnnotationReport(false).createSequenceAnnotationReport(
1785               contents, seq, true, true, ap.getSeqPanel().seqCanvas.fr);
1786       contents.append("</p>");
1787     }
1788     cap.setText("<html>" + contents.toString() + "</html>");
1789
1790     Desktop.addInternalFrame(cap,
1791             MessageManager.formatMessage("label.sequence_details_for",
1792                     (sequences.length == 1 ? new Object[]
1793                     { sequences[0].getDisplayId(true) }
1794                             : new Object[]
1795                             { MessageManager
1796                                     .getString("label.selection") })),
1797             500, 400);
1798
1799   }
1800
1801   protected void showNonconserved_actionPerformed()
1802   {
1803     getGroup().setShowNonconserved(displayNonconserved.isSelected());
1804     refresh();
1805   }
1806
1807   /**
1808    * call to refresh view after settings change
1809    */
1810   void refresh()
1811   {
1812     ap.updateAnnotation();
1813     // removed paintAlignment(true) here:
1814     // updateAnnotation calls paintAlignment already, so don't need to call
1815     // again
1816
1817     PaintRefresher.Refresh(this, ap.av.getSequenceSetId());
1818   }
1819
1820   /*
1821    * protected void covariationColour_actionPerformed() { getGroup().cs = new
1822    * CovariationColourScheme(sequence.getAnnotation()[0]); refresh(); }
1823    */
1824   /**
1825    * DOCUMENT ME!
1826    *
1827    * @param selected
1828    *
1829    * @param e
1830    *          DOCUMENT ME!
1831    */
1832   public void abovePIDColour_actionPerformed(boolean selected)
1833   {
1834     SequenceGroup sg = getGroup();
1835     if (sg.cs == null)
1836     {
1837       return;
1838     }
1839
1840     if (selected)
1841     {
1842       sg.cs.setConsensus(AAFrequency.calculate(
1843               sg.getSequences(ap.av.getHiddenRepSequences()),
1844               sg.getStartRes(), sg.getEndRes() + 1));
1845
1846       int threshold = SliderPanel.setPIDSliderSource(ap,
1847               sg.getGroupColourScheme(), getGroup().getName());
1848
1849       sg.cs.setThreshold(threshold, ap.av.isIgnoreGapsConsensus());
1850
1851       SliderPanel.showPIDSlider();
1852     }
1853     else
1854     // remove PIDColouring
1855     {
1856       sg.cs.setThreshold(0, ap.av.isIgnoreGapsConsensus());
1857       SliderPanel.hidePIDSlider();
1858     }
1859     modifyPID.setEnabled(selected);
1860
1861     refresh();
1862   }
1863
1864   /**
1865    * Open a panel where the user can choose which types of sequence annotation
1866    * to show or hide.
1867    *
1868    * @param e
1869    */
1870   protected void chooseAnnotations_actionPerformed(ActionEvent e)
1871   {
1872     // todo correct way to guard against opening a duplicate panel?
1873     new AnnotationChooser(ap);
1874   }
1875
1876   /**
1877    * DOCUMENT ME!
1878    *
1879    * @param e
1880    *          DOCUMENT ME!
1881    */
1882   public void conservationMenuItem_actionPerformed(boolean selected)
1883   {
1884     SequenceGroup sg = getGroup();
1885     if (sg.cs == null)
1886     {
1887       return;
1888     }
1889
1890     if (selected)
1891     {
1892       // JBPNote: Conservation name shouldn't be i18n translated
1893       Conservation c = new Conservation("Group",
1894               sg.getSequences(ap.av.getHiddenRepSequences()),
1895               sg.getStartRes(), sg.getEndRes() + 1);
1896
1897       c.calculate();
1898       c.verdict(false, ap.av.getConsPercGaps());
1899       sg.cs.setConservation(c);
1900
1901       SliderPanel.setConservationSlider(ap, sg.getGroupColourScheme(),
1902               sg.getName());
1903       SliderPanel.showConservationSlider();
1904     }
1905     else
1906     // remove ConservationColouring
1907     {
1908       sg.cs.setConservation(null);
1909       SliderPanel.hideConservationSlider();
1910     }
1911     modifyConservation.setEnabled(selected);
1912
1913     refresh();
1914   }
1915
1916   /**
1917    * DOCUMENT ME!
1918    *
1919    * @param e
1920    *          DOCUMENT ME!
1921    */
1922   protected void groupName_actionPerformed()
1923   {
1924
1925     SequenceGroup sg = getGroup();
1926     EditNameDialog dialog = new EditNameDialog(sg.getName(),
1927             sg.getDescription(),
1928             "       " + MessageManager.getString("label.group_name") + " ",
1929             MessageManager.getString("label.group_description") + " ",
1930             MessageManager.getString("label.edit_group_name_description"),
1931             ap.alignFrame);
1932
1933     if (!dialog.accept)
1934     {
1935       return;
1936     }
1937
1938     sg.setName(dialog.getName());
1939     sg.setDescription(dialog.getDescription());
1940     refresh();
1941   }
1942
1943   /**
1944    * Get selection group - adding it to the alignment if necessary.
1945    *
1946    * @return sequence group to operate on
1947    */
1948   SequenceGroup getGroup()
1949   {
1950     SequenceGroup sg = ap.av.getSelectionGroup();
1951     // this method won't add a new group if it already exists
1952     if (sg != null)
1953     {
1954       ap.av.getAlignment().addGroup(sg);
1955     }
1956
1957     return sg;
1958   }
1959
1960   /**
1961    * Shows a dialog where the sequence name and description may be edited. If a
1962    * name containing spaces is entered, these are converted to underscores, with a
1963    * warning message.
1964    */
1965   void sequenceName_actionPerformed()
1966   {
1967     EditNameDialog dialog = new EditNameDialog(sequence.getName(),
1968             sequence.getDescription(),
1969             "       " + MessageManager.getString("label.sequence_name")
1970                     + " ",
1971             MessageManager.getString("label.sequence_description") + " ",
1972             MessageManager.getString(
1973                     "label.edit_sequence_name_description"),
1974             ap.alignFrame);
1975
1976     if (!dialog.accept)
1977     {
1978       return;
1979     }
1980
1981     String name = dialog.getName();
1982     if (name != null)
1983     {
1984       if (name.indexOf(" ") > -1)
1985       {
1986         JvOptionPane.showMessageDialog(ap,
1987                 MessageManager
1988                         .getString("label.spaces_converted_to_backslashes"),
1989                 MessageManager
1990                         .getString("label.no_spaces_allowed_sequence_name"),
1991                 JvOptionPane.WARNING_MESSAGE);
1992         name = name.replace(' ', '_');
1993       }
1994
1995       sequence.setName(name);
1996       ap.paintAlignment(false, false);
1997     }
1998
1999     sequence.setDescription(dialog.getDescription());
2000
2001     ap.av.firePropertyChange("alignment", null,
2002             ap.av.getAlignment().getSequences());
2003
2004   }
2005
2006   /**
2007    * DOCUMENT ME!
2008    *
2009    * @param e
2010    *          DOCUMENT ME!
2011    */
2012   void unGroupMenuItem_actionPerformed()
2013   {
2014     SequenceGroup sg = ap.av.getSelectionGroup();
2015     ap.av.getAlignment().deleteGroup(sg);
2016     ap.av.setSelectionGroup(null);
2017     refresh();
2018   }
2019
2020   void createGroupMenuItem_actionPerformed()
2021   {
2022     getGroup(); // implicitly creates group - note - should apply defaults / use
2023                 // standard alignment window logic for this
2024     refresh();
2025   }
2026
2027   /**
2028    * DOCUMENT ME!
2029    *
2030    * @param e
2031    *          DOCUMENT ME!
2032    */
2033   protected void outline_actionPerformed()
2034   {
2035     SequenceGroup sg = getGroup();
2036     Color col = JColorChooser.showDialog(this,
2037             MessageManager.getString("label.select_outline_colour"),
2038             Color.BLUE);
2039
2040     if (col != null)
2041     {
2042       sg.setOutlineColour(col);
2043     }
2044
2045     refresh();
2046   }
2047
2048   /**
2049    * DOCUMENT ME!
2050    *
2051    * @param e
2052    *          DOCUMENT ME!
2053    */
2054   public void showBoxes_actionPerformed()
2055   {
2056     getGroup().setDisplayBoxes(showBoxes.isSelected());
2057     refresh();
2058   }
2059
2060   /**
2061    * DOCUMENT ME!
2062    *
2063    * @param e
2064    *          DOCUMENT ME!
2065    */
2066   public void showText_actionPerformed()
2067   {
2068     getGroup().setDisplayText(showText.isSelected());
2069     refresh();
2070   }
2071
2072   /**
2073    * DOCUMENT ME!
2074    *
2075    * @param e
2076    *          DOCUMENT ME!
2077    */
2078   public void showColourText_actionPerformed()
2079   {
2080     getGroup().setColourText(showColourText.isSelected());
2081     refresh();
2082   }
2083
2084   void hideSequences(boolean representGroup)
2085   {
2086     ap.av.hideSequences(sequence, representGroup);
2087   }
2088
2089   public void copy_actionPerformed()
2090   {
2091     ap.alignFrame.copy_actionPerformed(null);
2092   }
2093
2094   public void cut_actionPerformed()
2095   {
2096     ap.alignFrame.cut_actionPerformed(null);
2097   }
2098
2099   void changeCase(ActionEvent e)
2100   {
2101     Object source = e.getSource();
2102     SequenceGroup sg = ap.av.getSelectionGroup();
2103
2104     if (sg != null)
2105     {
2106       List<int[]> startEnd = ap.av.getVisibleRegionBoundaries(
2107               sg.getStartRes(), sg.getEndRes() + 1);
2108
2109       String description;
2110       int caseChange;
2111
2112       if (source == toggle)
2113       {
2114         description = MessageManager.getString("label.toggle_case");
2115         caseChange = ChangeCaseCommand.TOGGLE_CASE;
2116       }
2117       else if (source == upperCase)
2118       {
2119         description = MessageManager.getString("label.to_upper_case");
2120         caseChange = ChangeCaseCommand.TO_UPPER;
2121       }
2122       else
2123       {
2124         description = MessageManager.getString("label.to_lower_case");
2125         caseChange = ChangeCaseCommand.TO_LOWER;
2126       }
2127
2128       ChangeCaseCommand caseCommand = new ChangeCaseCommand(description,
2129               sg.getSequencesAsArray(ap.av.getHiddenRepSequences()),
2130               startEnd, caseChange);
2131
2132       ap.alignFrame.addHistoryItem(caseCommand);
2133
2134       ap.av.firePropertyChange("alignment", null,
2135               ap.av.getAlignment().getSequences());
2136
2137     }
2138   }
2139
2140   public void outputText_actionPerformed(ActionEvent e)
2141   {
2142     CutAndPasteTransfer cap = new CutAndPasteTransfer();
2143     cap.setForInput(null);
2144     Desktop.addInternalFrame(cap, MessageManager
2145             .formatMessage("label.alignment_output_command", new Object[]
2146             { e.getActionCommand() }), 600, 500);
2147
2148     String[] omitHidden = null;
2149
2150     System.out.println("PROMPT USER HERE"); // TODO: decide if a prompt happens
2151     // or we simply trust the user wants
2152     // wysiwig behaviour
2153
2154     FileFormatI fileFormat = FileFormats.getInstance()
2155             .forName(e.getActionCommand());
2156     cap.setText(
2157             new FormatAdapter(ap).formatSequences(fileFormat, ap, true));
2158   }
2159
2160   public void sequenceFeature_actionPerformed()
2161   {
2162     SequenceGroup sg = ap.av.getSelectionGroup();
2163     if (sg == null)
2164     {
2165       return;
2166     }
2167
2168     List<SequenceI> seqs = new ArrayList<>();
2169     List<SequenceFeature> features = new ArrayList<>();
2170
2171     /*
2172      * assemble dataset sequences, and template new sequence features,
2173      * for the amend features dialog
2174      */
2175     int gSize = sg.getSize();
2176     for (int i = 0; i < gSize; i++)
2177     {
2178       int start = sg.getSequenceAt(i).findPosition(sg.getStartRes());
2179       int end = sg.findEndRes(sg.getSequenceAt(i));
2180       if (start <= end)
2181       {
2182         seqs.add(sg.getSequenceAt(i).getDatasetSequence());
2183         features.add(new SequenceFeature(null, null, start, end, null));
2184       }
2185     }
2186
2187     /*
2188      * an entirely gapped region will generate empty lists of sequence / features
2189      */
2190     if (!seqs.isEmpty())
2191     {
2192       if (ap.getSeqPanel().seqCanvas.getFeatureRenderer()
2193               .amendFeatures(seqs, features, true, ap))
2194       {
2195         ap.alignFrame.setShowSeqFeatures(true);
2196         ap.av.setSearchResults(null); // clear highlighting
2197         ap.repaint(); // draw new/amended features
2198       }
2199     }
2200   }
2201
2202   public void textColour_actionPerformed()
2203   {
2204     SequenceGroup sg = getGroup();
2205     if (sg != null)
2206     {
2207       new TextColourChooser().chooseColour(ap, sg);
2208     }
2209   }
2210
2211   public void editSequence_actionPerformed(ActionEvent actionEvent)
2212   {
2213     SequenceGroup sg = ap.av.getSelectionGroup();
2214
2215     SequenceI seq = sequence;
2216     if (sg != null)
2217     {
2218       if (seq == null)
2219       {
2220         seq = sg.getSequenceAt(0);
2221       }
2222
2223       EditNameDialog dialog = new EditNameDialog(
2224               seq.getSequenceAsString(sg.getStartRes(),
2225                       sg.getEndRes() + 1),
2226               null, MessageManager.getString("label.edit_sequence"), null,
2227               MessageManager.getString("label.edit_sequence"),
2228               ap.alignFrame);
2229
2230       if (dialog.accept)
2231       {
2232         EditCommand editCommand = new EditCommand(
2233                 MessageManager.getString("label.edit_sequences"),
2234                 Action.REPLACE,
2235                 dialog.getName().replace(' ', ap.av.getGapCharacter()),
2236                 sg.getSequencesAsArray(ap.av.getHiddenRepSequences()),
2237                 sg.getStartRes(), sg.getEndRes() + 1, ap.av.getAlignment());
2238
2239         ap.alignFrame.addHistoryItem(editCommand);
2240
2241         ap.av.firePropertyChange("alignment", null,
2242                 ap.av.getAlignment().getSequences());
2243       }
2244     }
2245   }
2246
2247   /**
2248    * Action on user selecting an item from the colour menu (that does not have
2249    * its bespoke action handler)
2250    *
2251    * @return
2252    */
2253   @Override
2254   public void changeColour_actionPerformed(String colourSchemeName)
2255   {
2256     SequenceGroup sg = getGroup();
2257     /*
2258      * switch to the chosen colour scheme (or null for None)
2259      */
2260     ColourSchemeI colourScheme = ColourSchemes.getInstance()
2261             .getColourScheme(colourSchemeName, ap.av, sg,
2262                     ap.av.getHiddenRepSequences());
2263     sg.setColourScheme(colourScheme);
2264     if (colourScheme instanceof Blosum62ColourScheme
2265             || colourScheme instanceof PIDColourScheme)
2266     {
2267       sg.cs.setConsensus(AAFrequency.calculate(
2268               sg.getSequences(ap.av.getHiddenRepSequences()),
2269               sg.getStartRes(), sg.getEndRes() + 1));
2270     }
2271
2272     refresh();
2273   }
2274
2275 }