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