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