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