src/jalview/gui/AlignFrame.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 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.AlignmentSorter;
  25 import jalview.analysis.AlignmentUtils;
  26 import jalview.analysis.Conservation;
  27 import jalview.analysis.CrossRef;
  28 import jalview.analysis.NJTree;
  29 import jalview.analysis.ParseProperties;
  30 import jalview.analysis.SequenceIdMatcher;
  31 import jalview.api.AlignViewControllerGuiI;
  32 import jalview.api.AlignViewControllerI;
  33 import jalview.api.AlignmentViewPanel;
  34 import jalview.api.analysis.ScoreModelI;
  35 import jalview.bin.Cache;
  36 import jalview.commands.CommandI;
  37 import jalview.commands.EditCommand;
  38 import jalview.commands.EditCommand.Action;
  39 import jalview.commands.OrderCommand;
  40 import jalview.commands.RemoveGapColCommand;
  41 import jalview.commands.RemoveGapsCommand;
  42 import jalview.commands.SlideSequencesCommand;
  43 import jalview.commands.TrimRegionCommand;
  44 import jalview.datamodel.AlignedCodonFrame;
  45 import jalview.datamodel.Alignment;
  46 import jalview.datamodel.AlignmentAnnotation;
  47 import jalview.datamodel.AlignmentI;
  48 import jalview.datamodel.AlignmentOrder;
  49 import jalview.datamodel.AlignmentView;
  50 import jalview.datamodel.ColumnSelection;
  51 import jalview.datamodel.PDBEntry;
  52 import jalview.datamodel.SeqCigar;
  53 import jalview.datamodel.Sequence;
  54 import jalview.datamodel.SequenceGroup;
  55 import jalview.datamodel.SequenceI;
  56 import jalview.io.AlignmentProperties;
  57 import jalview.io.AnnotationFile;
  58 import jalview.io.BioJsHTMLOutput;
  59 import jalview.io.FeaturesFile;
  60 import jalview.io.FileLoader;
  61 import jalview.io.FormatAdapter;
  62 import jalview.io.HtmlSvgOutput;
  63 import jalview.io.IdentifyFile;
  64 import jalview.io.JalviewFileChooser;
  65 import jalview.io.JalviewFileView;
  66 import jalview.io.JnetAnnotationMaker;
  67 import jalview.io.NewickFile;
  68 import jalview.io.TCoffeeScoreFile;
  69 import jalview.jbgui.GAlignFrame;
  70 import jalview.schemes.Blosum62ColourScheme;
  71 import jalview.schemes.BuriedColourScheme;
  72 import jalview.schemes.ClustalxColourScheme;
  73 import jalview.schemes.ColourSchemeI;
  74 import jalview.schemes.ColourSchemeProperty;
  75 import jalview.schemes.HelixColourScheme;
  76 import jalview.schemes.HydrophobicColourScheme;
  77 import jalview.schemes.NucleotideColourScheme;
  78 import jalview.schemes.PIDColourScheme;
  79 import jalview.schemes.PurinePyrimidineColourScheme;
  80 import jalview.schemes.RNAHelicesColourChooser;
  81 import jalview.schemes.ResidueProperties;
  82 import jalview.schemes.StrandColourScheme;
  83 import jalview.schemes.TCoffeeColourScheme;
  84 import jalview.schemes.TaylorColourScheme;
  85 import jalview.schemes.TurnColourScheme;
  86 import jalview.schemes.UserColourScheme;
  87 import jalview.schemes.ZappoColourScheme;
  88 import jalview.util.MessageManager;
  89 import jalview.ws.jws1.Discoverer;
  90 import jalview.ws.jws2.Jws2Discoverer;
  91 import jalview.ws.jws2.jabaws2.Jws2Instance;
  92 import jalview.ws.seqfetcher.DbSourceProxy;
  93
  94 import java.awt.BorderLayout;
  95 import java.awt.Component;
  96 import java.awt.GridLayout;
  97 import java.awt.Rectangle;
  98 import java.awt.Toolkit;
  99 import java.awt.datatransfer.Clipboard;
 100 import java.awt.datatransfer.DataFlavor;
 101 import java.awt.datatransfer.StringSelection;
 102 import java.awt.datatransfer.Transferable;
 103 import java.awt.dnd.DnDConstants;
 104 import java.awt.dnd.DropTargetDragEvent;
 105 import java.awt.dnd.DropTargetDropEvent;
 106 import java.awt.dnd.DropTargetEvent;
 107 import java.awt.dnd.DropTargetListener;
 108 import java.awt.event.ActionEvent;
 109 import java.awt.event.ActionListener;
 110 import java.awt.event.KeyAdapter;
 111 import java.awt.event.KeyEvent;
 112 import java.awt.event.MouseAdapter;
 113 import java.awt.event.MouseEvent;
 114 import java.awt.print.PageFormat;
 115 import java.awt.print.PrinterJob;
 116 import java.beans.PropertyChangeEvent;
 117 import java.io.File;
 118 import java.net.URL;
 119 import java.util.ArrayList;
 120 import java.util.Arrays;
 121 import java.util.Enumeration;
 122 import java.util.Hashtable;
 123 import java.util.List;
 124 import java.util.Vector;
 125
 126 import javax.swing.JButton;
 127 import javax.swing.JCheckBoxMenuItem;
 128 import javax.swing.JEditorPane;
 129 import javax.swing.JInternalFrame;
 130 import javax.swing.JLabel;
 131 import javax.swing.JLayeredPane;
 132 import javax.swing.JMenu;
 133 import javax.swing.JMenuItem;
 134 import javax.swing.JOptionPane;
 135 import javax.swing.JPanel;
 136 import javax.swing.JProgressBar;
 137 import javax.swing.JRadioButtonMenuItem;
 138 import javax.swing.JScrollPane;
 139 import javax.swing.SwingUtilities;
 140
 141 /**
 142  * DOCUMENT ME!
 143  *
 144  * @author $author$
 145  * @version $Revision$
 146  */
 147 public class AlignFrame extends GAlignFrame implements DropTargetListener,
 148         IProgressIndicator, AlignViewControllerGuiI
 149 {
 150
 151   /** DOCUMENT ME!! */
 152   public static final int DEFAULT_WIDTH = 700;
 153
 154   /** DOCUMENT ME!! */
 155   public static final int DEFAULT_HEIGHT = 500;
 156
 157   public AlignmentPanel alignPanel;
 158
 159   AlignViewport viewport;
 160
 161   public AlignViewControllerI avc;
 162
 163   Vector alignPanels = new Vector();
 164
 165   /**
 166    * Last format used to load or save alignments in this window
 167    */
 168   String currentFileFormat = null;
 169
 170   /**
 171    * Current filename for this alignment
 172    */
 173   String fileName = null;
 174
 175   /**
 176    * Creates a new AlignFrame object with specific width and height.
 177    *
 178    * @param al
 179    * @param width
 180    * @param height
 181    */
 182   public AlignFrame(AlignmentI al, int width, int height)
 183   {
 184     this(al, null, width, height);
 185   }
 186
 187   /**
 188    * Creates a new AlignFrame object with specific width, height and
 189    * sequenceSetId
 190    *
 191    * @param al
 192    * @param width
 193    * @param height
 194    * @param sequenceSetId
 195    */
 196   public AlignFrame(AlignmentI al, int width, int height,
 197           String sequenceSetId)
 198   {
 199     this(al, null, width, height, sequenceSetId);
 200   }
 201
 202   /**
 203    * Creates a new AlignFrame object with specific width, height and
 204    * sequenceSetId
 205    *
 206    * @param al
 207    * @param width
 208    * @param height
 209    * @param sequenceSetId
 210    * @param viewId
 211    */
 212   public AlignFrame(AlignmentI al, int width, int height,
 213           String sequenceSetId, String viewId)
 214   {
 215     this(al, null, width, height, sequenceSetId, viewId);
 216   }
 217
 218   /**
 219    * new alignment window with hidden columns
 220    *
 221    * @param al
 222    *          AlignmentI
 223    * @param hiddenColumns
 224    *          ColumnSelection or null
 225    * @param width
 226    *          Width of alignment frame
 227    * @param height
 228    *          height of frame.
 229    */
 230   public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
 231           int width, int height)
 232   {
 233     this(al, hiddenColumns, width, height, null);
 234   }
 235
 236   /**
 237    * Create alignment frame for al with hiddenColumns, a specific width and
 238    * height, and specific sequenceId
 239    *
 240    * @param al
 241    * @param hiddenColumns
 242    * @param width
 243    * @param height
 244    * @param sequenceSetId
 245    *          (may be null)
 246    */
 247   public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
 248           int width, int height, String sequenceSetId)
 249   {
 250     this(al, hiddenColumns, width, height, sequenceSetId, null);
 251   }
 252
 253   /**
 254    * Create alignment frame for al with hiddenColumns, a specific width and
 255    * height, and specific sequenceId
 256    *
 257    * @param al
 258    * @param hiddenColumns
 259    * @param width
 260    * @param height
 261    * @param sequenceSetId
 262    *          (may be null)
 263    * @param viewId
 264    *          (may be null)
 265    */
 266   public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
 267           int width, int height, String sequenceSetId, String viewId)
 268   {
 269     setSize(width, height);
 270
 271     if (al.getDataset() == null)
 272     {
 273       al.setDataset(null);
 274     }
 275
 276     viewport = new AlignViewport(al, hiddenColumns, sequenceSetId, viewId);
 277
 278     alignPanel = new AlignmentPanel(this, viewport);
 279
 280
 281     addAlignmentPanel(alignPanel, true);
 282     init();
 283   }
 284
 285   /**
 286    * Make a new AlignFrame from existing alignmentPanels
 287    *
 288    * @param ap
 289    *          AlignmentPanel
 290    * @param av
 291    *          AlignViewport
 292    */
 293   public AlignFrame(AlignmentPanel ap)
 294   {
 295     viewport = ap.av;
 296     alignPanel = ap;
 297     addAlignmentPanel(ap, false);
 298     init();
 299   }
 300
 301   /**
 302    * initalise the alignframe from the underlying viewport data and the
 303    * configurations
 304    */
 305   void init()
 306   {
 307     avc = new jalview.controller.AlignViewController(this, viewport,
 308             alignPanel);
 309     if (viewport.getAlignmentConservationAnnotation() == null)
 310     {
 311       BLOSUM62Colour.setEnabled(false);
 312       conservationMenuItem.setEnabled(false);
 313       modifyConservation.setEnabled(false);
 314       // PIDColour.setEnabled(false);
 315       // abovePIDThreshold.setEnabled(false);
 316       // modifyPID.setEnabled(false);
 317     }
 318
 319     String sortby = jalview.bin.Cache.getDefault("SORT_ALIGNMENT",
 320             "No sort");
 321
 322     if (sortby.equals("Id"))
 323     {
 324       sortIDMenuItem_actionPerformed(null);
 325     }
 326     else if (sortby.equals("Pairwise Identity"))
 327     {
 328       sortPairwiseMenuItem_actionPerformed(null);
 329     }
 330
 331     if (Desktop.desktop != null)
 332     {
 333       this.setDropTarget(new java.awt.dnd.DropTarget(this, this));
 334       addServiceListeners();
 335       setGUINucleotide(viewport.getAlignment().isNucleotide());
 336     }
 337
 338     setMenusFromViewport(viewport);
 339     buildSortByAnnotationScoresMenu();
 340     buildTreeMenu();
 341
 342     if (viewport.wrapAlignment)
 343     {
 344       wrapMenuItem_actionPerformed(null);
 345     }
 346
 347     if (jalview.bin.Cache.getDefault("SHOW_OVERVIEW", false))
 348     {
 349       this.overviewMenuItem_actionPerformed(null);
 350     }
 351
 352     addKeyListener();
 353
 354   }
 355
 356   /**
 357    * Change the filename and format for the alignment, and enable the 'reload'
 358    * button functionality.
 359    *
 360    * @param file
 361    *          valid filename
 362    * @param format
 363    *          format of file
 364    */
 365   public void setFileName(String file, String format)
 366   {
 367     fileName = file;
 368     currentFileFormat = format;
 369     reload.setEnabled(true);
 370   }
 371
 372   void addKeyListener()
 373   {
 374     addKeyListener(new KeyAdapter()
 375     {
 376       @Override
 377       public void keyPressed(KeyEvent evt)
 378       {
 379         if (viewport.cursorMode
 380                 && ((evt.getKeyCode() >= KeyEvent.VK_0 && evt.getKeyCode() <= KeyEvent.VK_9) || (evt
 381                         .getKeyCode() >= KeyEvent.VK_NUMPAD0 && evt
 382                         .getKeyCode() <= KeyEvent.VK_NUMPAD9))
 383                 && Character.isDigit(evt.getKeyChar()))
 384         {
 385           alignPanel.getSeqPanel().numberPressed(evt.getKeyChar());
 386         }
 387
 388         switch (evt.getKeyCode())
 389         {
 390
 391         case 27: // escape key
 392           deselectAllSequenceMenuItem_actionPerformed(null);
 393
 394           break;
 395
 396         case KeyEvent.VK_DOWN:
 397           if (evt.isAltDown() || !viewport.cursorMode)
 398           {
 399             moveSelectedSequences(false);
 400           }
 401           if (viewport.cursorMode)
 402           {
 403             alignPanel.getSeqPanel().moveCursor(0, 1);
 404           }
 405           break;
 406
 407         case KeyEvent.VK_UP:
 408           if (evt.isAltDown() || !viewport.cursorMode)
 409           {
 410             moveSelectedSequences(true);
 411           }
 412           if (viewport.cursorMode)
 413           {
 414             alignPanel.getSeqPanel().moveCursor(0, -1);
 415           }
 416
 417           break;
 418
 419         case KeyEvent.VK_LEFT:
 420           if (evt.isAltDown() || !viewport.cursorMode)
 421           {
 422             slideSequences(false, alignPanel.getSeqPanel().getKeyboardNo1());
 423           }
 424           else
 425           {
 426             alignPanel.getSeqPanel().moveCursor(-1, 0);
 427           }
 428
 429           break;
 430
 431         case KeyEvent.VK_RIGHT:
 432           if (evt.isAltDown() || !viewport.cursorMode)
 433           {
 434             slideSequences(true, alignPanel.getSeqPanel().getKeyboardNo1());
 435           }
 436           else
 437           {
 438             alignPanel.getSeqPanel().moveCursor(1, 0);
 439           }
 440           break;
 441
 442         case KeyEvent.VK_SPACE:
 443           if (viewport.cursorMode)
 444           {
 445             alignPanel.getSeqPanel().insertGapAtCursor(evt.isControlDown()
 446                     || evt.isShiftDown() || evt.isAltDown());
 447           }
 448           break;
 449
 450         // case KeyEvent.VK_A:
 451         // if (viewport.cursorMode)
 452         // {
 453         // alignPanel.seqPanel.insertNucAtCursor(false,"A");
 454         // //System.out.println("A");
 455         // }
 456         // break;
 457         /*
 458          * case KeyEvent.VK_CLOSE_BRACKET: if (viewport.cursorMode) {
 459          * System.out.println("closing bracket"); } break;
 460          */
 461         case KeyEvent.VK_DELETE:
 462         case KeyEvent.VK_BACK_SPACE:
 463           if (!viewport.cursorMode)
 464           {
 465             cut_actionPerformed(null);
 466           }
 467           else
 468           {
 469             alignPanel.getSeqPanel().deleteGapAtCursor(evt.isControlDown()
 470                     || evt.isShiftDown() || evt.isAltDown());
 471           }
 472
 473           break;
 474
 475         case KeyEvent.VK_S:
 476           if (viewport.cursorMode)
 477           {
 478             alignPanel.getSeqPanel().setCursorRow();
 479           }
 480           break;
 481         case KeyEvent.VK_C:
 482           if (viewport.cursorMode && !evt.isControlDown())
 483           {
 484             alignPanel.getSeqPanel().setCursorColumn();
 485           }
 486           break;
 487         case KeyEvent.VK_P:
 488           if (viewport.cursorMode)
 489           {
 490             alignPanel.getSeqPanel().setCursorPosition();
 491           }
 492           break;
 493
 494         case KeyEvent.VK_ENTER:
 495         case KeyEvent.VK_COMMA:
 496           if (viewport.cursorMode)
 497           {
 498             alignPanel.getSeqPanel().setCursorRowAndColumn();
 499           }
 500           break;
 501
 502         case KeyEvent.VK_Q:
 503           if (viewport.cursorMode)
 504           {
 505             alignPanel.getSeqPanel().setSelectionAreaAtCursor(true);
 506           }
 507           break;
 508         case KeyEvent.VK_M:
 509           if (viewport.cursorMode)
 510           {
 511             alignPanel.getSeqPanel().setSelectionAreaAtCursor(false);
 512           }
 513           break;
 514
 515         case KeyEvent.VK_F2:
 516           viewport.cursorMode = !viewport.cursorMode;
 517           statusBar.setText(MessageManager.formatMessage(
 518                   "label.keyboard_editing_mode", new String[]
 519                   { (viewport.cursorMode ? "on" : "off") }));
 520           if (viewport.cursorMode)
 521           {
 522             alignPanel.getSeqPanel().seqCanvas.cursorX = viewport.startRes;
 523             alignPanel.getSeqPanel().seqCanvas.cursorY = viewport.startSeq;
 524           }
 525           alignPanel.getSeqPanel().seqCanvas.repaint();
 526           break;
 527
 528         case KeyEvent.VK_F1:
 529           try
 530           {
 531             Help.showHelpWindow();
 532           } catch (Exception ex)
 533           {
 534             ex.printStackTrace();
 535           }
 536           break;
 537         case KeyEvent.VK_H:
 538         {
 539           boolean toggleSeqs = !evt.isControlDown();
 540           boolean toggleCols = !evt.isShiftDown();
 541           toggleHiddenRegions(toggleSeqs, toggleCols);
 542           break;
 543         }
 544         case KeyEvent.VK_PAGE_UP:
 545           if (viewport.wrapAlignment)
 546           {
 547             alignPanel.scrollUp(true);
 548           }
 549           else
 550           {
 551             alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
 552                     - viewport.endSeq + viewport.startSeq);
 553           }
 554           break;
 555         case KeyEvent.VK_PAGE_DOWN:
 556           if (viewport.wrapAlignment)
 557           {
 558             alignPanel.scrollUp(false);
 559           }
 560           else
 561           {
 562             alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
 563                     + viewport.endSeq - viewport.startSeq);
 564           }
 565           break;
 566         }
 567       }
 568
 569       @Override
 570       public void keyReleased(KeyEvent evt)
 571       {
 572         switch (evt.getKeyCode())
 573         {
 574         case KeyEvent.VK_LEFT:
 575           if (evt.isAltDown() || !viewport.cursorMode)
 576           {
 577             viewport.firePropertyChange("alignment", null, viewport
 578                     .getAlignment().getSequences());
 579           }
 580           break;
 581
 582         case KeyEvent.VK_RIGHT:
 583           if (evt.isAltDown() || !viewport.cursorMode)
 584           {
 585             viewport.firePropertyChange("alignment", null, viewport
 586                     .getAlignment().getSequences());
 587           }
 588           break;
 589         }
 590       }
 591     });
 592   }
 593
 594   public void addAlignmentPanel(final AlignmentPanel ap, boolean newPanel)
 595   {
 596     ap.alignFrame = this;
 597     avc = new jalview.controller.AlignViewController(this, viewport,
 598             alignPanel);
 599
 600     alignPanels.addElement(ap);
 601
 602     PaintRefresher.Register(ap, ap.av.getSequenceSetId());
 603
 604     int aSize = alignPanels.size();
 605
 606     tabbedPane.setVisible(aSize > 1 || ap.av.viewName != null);
 607
 608     if (aSize == 1 && ap.av.viewName == null)
 609     {
 610       this.getContentPane().add(ap, BorderLayout.CENTER);
 611     }
 612     else
 613     {
 614       if (aSize == 2)
 615       {
 616         setInitialTabVisible();
 617       }
 618
 619       expandViews.setEnabled(true);
 620       gatherViews.setEnabled(true);
 621       tabbedPane.addTab(ap.av.viewName, ap);
 622
 623       ap.setVisible(false);
 624     }
 625
 626     if (newPanel)
 627     {
 628       if (ap.av.isPadGaps())
 629       {
 630         ap.av.getAlignment().padGaps();
 631       }
 632       ap.av.updateConservation(ap);
 633       ap.av.updateConsensus(ap);
 634       ap.av.updateStrucConsensus(ap);
 635     }
 636   }
 637
 638   public void setInitialTabVisible()
 639   {
 640     expandViews.setEnabled(true);
 641     gatherViews.setEnabled(true);
 642     tabbedPane.setVisible(true);
 643     AlignmentPanel first = (AlignmentPanel) alignPanels.firstElement();
 644     tabbedPane.addTab(first.av.viewName, first);
 645     this.getContentPane().add(tabbedPane, BorderLayout.CENTER);
 646   }
 647
 648   public AlignViewport getViewport()
 649   {
 650     return viewport;
 651   }
 652
 653   /* Set up intrinsic listeners for dynamically generated GUI bits. */
 654   private void addServiceListeners()
 655   {
 656     final java.beans.PropertyChangeListener thisListener;
 657     Desktop.instance.addJalviewPropertyChangeListener("services",
 658             thisListener = new java.beans.PropertyChangeListener()
 659             {
 660               @Override
 661               public void propertyChange(PropertyChangeEvent evt)
 662               {
 663                 // // System.out.println("Discoverer property change.");
 664                 // if (evt.getPropertyName().equals("services"))
 665                 {
 666                   SwingUtilities.invokeLater(new Runnable()
 667                   {
 668
 669                     @Override
 670                     public void run()
 671                     {
 672                       System.err
 673                               .println("Rebuild WS Menu for service change");
 674                       BuildWebServiceMenu();
 675                     }
 676
 677                   });
 678                 }
 679               }
 680             });
 681     addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
 682     {
 683       @Override
 684       public void internalFrameClosed(
 685               javax.swing.event.InternalFrameEvent evt)
 686       {
 687         System.out.println("deregistering discoverer listener");
 688         Desktop.instance.removeJalviewPropertyChangeListener("services",
 689                 thisListener);
 690         closeMenuItem_actionPerformed(true);
 691       };
 692     });
 693     // Finally, build the menu once to get current service state
 694     new Thread(new Runnable()
 695     {
 696       @Override
 697       public void run()
 698       {
 699         BuildWebServiceMenu();
 700       }
 701     }).start();
 702   }
 703
 704   public void setGUINucleotide(boolean nucleotide)
 705   {
 706     showTranslation.setVisible(nucleotide);
 707     conservationMenuItem.setEnabled(!nucleotide);
 708     modifyConservation.setEnabled(!nucleotide);
 709     showGroupConservation.setEnabled(!nucleotide);
 710     rnahelicesColour.setEnabled(nucleotide);
 711     purinePyrimidineColour.setEnabled(nucleotide);
 712     // Remember AlignFrame always starts as protein
 713     // if (!nucleotide)
 714     // {
 715     // showTr
 716     // calculateMenu.remove(calculateMenu.getItemCount() - 2);
 717     // }
 718   }
 719
 720   /**
 721    * set up menus for the currently viewport. This may be called after any
 722    * operation that affects the data in the current view (selection changed,
 723    * etc) to update the menus to reflect the new state.
 724    */
 725   public void setMenusForViewport()
 726   {
 727     setMenusFromViewport(viewport);
 728   }
 729
 730   /**
 731    * Need to call this method when tabs are selected for multiple views, or when
 732    * loading from Jalview2XML.java
 733    *
 734    * @param av
 735    *          AlignViewport
 736    */
 737   void setMenusFromViewport(AlignViewport av)
 738   {
 739     padGapsMenuitem.setSelected(av.isPadGaps());
 740     colourTextMenuItem.setSelected(av.showColourText);
 741     abovePIDThreshold.setSelected(av.getAbovePIDThreshold());
 742     conservationMenuItem.setSelected(av.getConservationSelected());
 743     seqLimits.setSelected(av.getShowJVSuffix());
 744     idRightAlign.setSelected(av.isRightAlignIds());
 745     centreColumnLabelsMenuItem.setState(av.centreColumnLabels);
 746     renderGapsMenuItem.setSelected(av.renderGaps);
 747     wrapMenuItem.setSelected(av.wrapAlignment);
 748     scaleAbove.setVisible(av.wrapAlignment);
 749     scaleLeft.setVisible(av.wrapAlignment);
 750     scaleRight.setVisible(av.wrapAlignment);
 751     annotationPanelMenuItem.setState(av.isShowAnnotation());
 752     /*
 753      * Show/hide annotations only enabled if annotation panel is shown
 754      */
 755     showAllSeqAnnotations.setEnabled(annotationPanelMenuItem.getState());
 756     hideAllSeqAnnotations.setEnabled(annotationPanelMenuItem.getState());
 757     showAllAlAnnotations.setEnabled(annotationPanelMenuItem.getState());
 758     hideAllAlAnnotations.setEnabled(annotationPanelMenuItem.getState());
 759     viewBoxesMenuItem.setSelected(av.showBoxes);
 760     viewTextMenuItem.setSelected(av.showText);
 761     showNonconservedMenuItem.setSelected(av.getShowUnconserved());
 762     showGroupConsensus.setSelected(av.isShowGroupConsensus());
 763     showGroupConservation.setSelected(av.isShowGroupConservation());
 764     showConsensusHistogram.setSelected(av.isShowConsensusHistogram());
 765     showSequenceLogo.setSelected(av.isShowSequenceLogo());
 766     normaliseSequenceLogo.setSelected(av.isNormaliseSequenceLogo());
 767
 768     setColourSelected(ColourSchemeProperty.getColourName(av
 769             .getGlobalColourScheme()));
 770
 771     showSeqFeatures.setSelected(av.isShowSequenceFeatures());
 772     hiddenMarkers.setState(av.showHiddenMarkers);
 773     applyToAllGroups.setState(av.getColourAppliesToAllGroups());
 774     showNpFeatsMenuitem.setSelected(av.isShowNpFeats());
 775     showDbRefsMenuitem.setSelected(av.isShowDbRefs());
 776     autoCalculate.setSelected(av.autoCalculateConsensus);
 777     sortByTree.setSelected(av.sortByTree);
 778     listenToViewSelections.setSelected(av.followSelection);
 779     rnahelicesColour.setEnabled(av.getAlignment().hasRNAStructure());
 780     rnahelicesColour
 781             .setSelected(av.getGlobalColourScheme() instanceof jalview.schemes.RNAHelicesColour);
 782     setShowProductsEnabled();
 783     updateEditMenuBar();
 784   }
 785
 786   // methods for implementing IProgressIndicator
 787   // need to refactor to a reusable stub class
 788   Hashtable progressBars, progressBarHandlers;
 789
 790   /*
 791    * (non-Javadoc)
 792    *
 793    * @see jalview.gui.IProgressIndicator#setProgressBar(java.lang.String, long)
 794    */
 795   @Override
 796   public void setProgressBar(String message, long id)
 797   {
 798     if (progressBars == null)
 799     {
 800       progressBars = new Hashtable();
 801       progressBarHandlers = new Hashtable();
 802     }
 803
 804     JPanel progressPanel;
 805     Long lId = new Long(id);
 806     GridLayout layout = (GridLayout) statusPanel.getLayout();
 807     if (progressBars.get(lId) != null)
 808     {
 809       progressPanel = (JPanel) progressBars.get(new Long(id));
 810       statusPanel.remove(progressPanel);
 811       progressBars.remove(lId);
 812       progressPanel = null;
 813       if (message != null)
 814       {
 815         statusBar.setText(message);
 816       }
 817       if (progressBarHandlers.contains(lId))
 818       {
 819         progressBarHandlers.remove(lId);
 820       }
 821       layout.setRows(layout.getRows() - 1);
 822     }
 823     else
 824     {
 825       progressPanel = new JPanel(new BorderLayout(10, 5));
 826
 827       JProgressBar progressBar = new JProgressBar();
 828       progressBar.setIndeterminate(true);
 829
 830       progressPanel.add(new JLabel(message), BorderLayout.WEST);
 831       progressPanel.add(progressBar, BorderLayout.CENTER);
 832
 833       layout.setRows(layout.getRows() + 1);
 834       statusPanel.add(progressPanel);
 835
 836       progressBars.put(lId, progressPanel);
 837     }
 838     // update GUI
 839     // setMenusForViewport();
 840     validate();
 841   }
 842
 843   @Override
 844   public void registerHandler(final long id,
 845           final IProgressIndicatorHandler handler)
 846   {
 847     if (progressBarHandlers == null || !progressBars.contains(new Long(id)))
 848     {
 849       throw new Error(MessageManager.getString("error.call_setprogressbar_before_registering_handler"));
 850     }
 851     progressBarHandlers.put(new Long(id), handler);
 852     final JPanel progressPanel = (JPanel) progressBars.get(new Long(id));
 853     if (handler.canCancel())
 854     {
 855       JButton cancel = new JButton(
 856               MessageManager.getString("action.cancel"));
 857       final IProgressIndicator us = this;
 858       cancel.addActionListener(new ActionListener()
 859       {
 860
 861         @Override
 862         public void actionPerformed(ActionEvent e)
 863         {
 864           handler.cancelActivity(id);
 865           us.setProgressBar(MessageManager.formatMessage("label.cancelled_params", new String[]{((JLabel) progressPanel.getComponent(0)).getText()}), id);
 866         }
 867       });
 868       progressPanel.add(cancel, BorderLayout.EAST);
 869     }
 870   }
 871
 872   /**
 873    *
 874    * @return true if any progress bars are still active
 875    */
 876   @Override
 877   public boolean operationInProgress()
 878   {
 879     if (progressBars != null && progressBars.size() > 0)
 880     {
 881       return true;
 882     }
 883     return false;
 884   }
 885
 886   @Override
 887   public void setStatus(String text)
 888   {
 889     statusBar.setText(text);
 890   };
 891
 892   /*
 893    * Added so Castor Mapping file can obtain Jalview Version
 894    */
 895   public String getVersion()
 896   {
 897     return jalview.bin.Cache.getProperty("VERSION");
 898   }
 899
 900   public FeatureRenderer getFeatureRenderer()
 901   {
 902     return alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer();
 903   }
 904
 905   @Override
 906   public void fetchSequence_actionPerformed(ActionEvent e)
 907   {
 908     new SequenceFetcher(this);
 909   }
 910
 911   @Override
 912   public void addFromFile_actionPerformed(ActionEvent e)
 913   {
 914     Desktop.instance.inputLocalFileMenuItem_actionPerformed(viewport);
 915   }
 916
 917   @Override
 918   public void reload_actionPerformed(ActionEvent e)
 919   {
 920     if (fileName != null)
 921     {
 922       // TODO: JAL-1108 - ensure all associated frames are closed regardless of
 923       // originating file's format
 924       // TODO: work out how to recover feature settings for correct view(s) when
 925       // file is reloaded.
 926       if (currentFileFormat.equals("Jalview"))
 927       {
 928         JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 929         for (int i = 0; i < frames.length; i++)
 930         {
 931           if (frames[i] instanceof AlignFrame && frames[i] != this
 932                   && ((AlignFrame) frames[i]).fileName != null
 933                   && ((AlignFrame) frames[i]).fileName.equals(fileName))
 934           {
 935             try
 936             {
 937               frames[i].setSelected(true);
 938               Desktop.instance.closeAssociatedWindows();
 939             } catch (java.beans.PropertyVetoException ex)
 940             {
 941             }
 942           }
 943
 944         }
 945         Desktop.instance.closeAssociatedWindows();
 946
 947         FileLoader loader = new FileLoader();
 948         String protocol = fileName.startsWith("http:") ? "URL" : "File";
 949         loader.LoadFile(viewport, fileName, protocol, currentFileFormat);
 950       }
 951       else
 952       {
 953         Rectangle bounds = this.getBounds();
 954
 955         FileLoader loader = new FileLoader();
 956         String protocol = fileName.startsWith("http:") ? "URL" : "File";
 957         AlignFrame newframe = loader.LoadFileWaitTillLoaded(fileName,
 958                 protocol, currentFileFormat);
 959
 960         newframe.setBounds(bounds);
 961         if (featureSettings != null && featureSettings.isShowing())
 962         {
 963           final Rectangle fspos = featureSettings.frame.getBounds();
 964           // TODO: need a 'show feature settings' function that takes bounds -
 965           // need to refactor Desktop.addFrame
 966           newframe.featureSettings_actionPerformed(null);
 967           final FeatureSettings nfs = newframe.featureSettings;
 968           SwingUtilities.invokeLater(new Runnable()
 969           {
 970             @Override
 971             public void run()
 972             {
 973               nfs.frame.setBounds(fspos);
 974             }
 975           });
 976           this.featureSettings.close();
 977           this.featureSettings = null;
 978         }
 979         this.closeMenuItem_actionPerformed(true);
 980       }
 981     }
 982   }
 983
 984   @Override
 985   public void addFromText_actionPerformed(ActionEvent e)
 986   {
 987     Desktop.instance.inputTextboxMenuItem_actionPerformed(viewport);
 988   }
 989
 990   @Override
 991   public void addFromURL_actionPerformed(ActionEvent e)
 992   {
 993     Desktop.instance.inputURLMenuItem_actionPerformed(viewport);
 994   }
 995
 996   @Override
 997   public void save_actionPerformed(ActionEvent e)
 998   {
 999     if (fileName == null
1000             || (currentFileFormat == null || !jalview.io.FormatAdapter
1001                     .isValidIOFormat(currentFileFormat, true))
1002             || fileName.startsWith("http"))
1003     {
1004       saveAs_actionPerformed(null);
1005     }
1006     else
1007     {
1008       saveAlignment(fileName, currentFileFormat);
1009     }
1010   }
1011
1012   /**
1013    * DOCUMENT ME!
1014    *
1015    * @param e
1016    *          DOCUMENT ME!
1017    */
1018   @Override
1019   public void saveAs_actionPerformed(ActionEvent e)
1020   {
1021     JalviewFileChooser chooser = new JalviewFileChooser(
1022             jalview.bin.Cache.getProperty("LAST_DIRECTORY"),
1023             jalview.io.AppletFormatAdapter.WRITABLE_EXTENSIONS,
1024             jalview.io.AppletFormatAdapter.WRITABLE_FNAMES,
1025             currentFileFormat, false);
1026
1027     chooser.setFileView(new JalviewFileView());
1028     chooser.setDialogTitle(MessageManager.getString("label.save_alignment_to_file"));
1029     chooser.setToolTipText(MessageManager.getString("action.save"));
1030
1031     int value = chooser.showSaveDialog(this);
1032
1033     if (value == JalviewFileChooser.APPROVE_OPTION)
1034     {
1035       currentFileFormat = chooser.getSelectedFormat();
1036       if (currentFileFormat == null)
1037       {
1038         JOptionPane
1039                 .showInternalMessageDialog(
1040                         Desktop.desktop,
1041                         MessageManager
1042                                 .getString("label.select_file_format_before_saving"),
1043                         MessageManager
1044                                 .getString("label.file_format_not_specified"),
1045                         JOptionPane.WARNING_MESSAGE);
1046         value = chooser.showSaveDialog(this);
1047         return;
1048       }
1049
1050       fileName = chooser.getSelectedFile().getPath();
1051
1052       jalview.bin.Cache.setProperty("DEFAULT_FILE_FORMAT",
1053               currentFileFormat);
1054
1055       jalview.bin.Cache.setProperty("LAST_DIRECTORY", fileName);
1056       if (currentFileFormat.indexOf(" ") > -1)
1057       {
1058         currentFileFormat = currentFileFormat.substring(0,
1059                 currentFileFormat.indexOf(" "));
1060       }
1061       saveAlignment(fileName, currentFileFormat);
1062     }
1063   }
1064
1065   public boolean saveAlignment(String file, String format)
1066   {
1067     boolean success = true;
1068
1069     if (format.equalsIgnoreCase("Jalview"))
1070     {
1071       String shortName = title;
1072
1073       if (shortName.indexOf(java.io.File.separatorChar) > -1)
1074       {
1075         shortName = shortName.substring(shortName
1076                 .lastIndexOf(java.io.File.separatorChar) + 1);
1077       }
1078
1079       success = new Jalview2XML().SaveAlignment(this, file, shortName);
1080
1081       statusBar.setText(MessageManager.formatMessage(
1082               "label.successfully_saved_to_file_in_format", new String[]
1083               { fileName, format }));
1084
1085     }
1086     else
1087     {
1088       if (!jalview.io.AppletFormatAdapter.isValidFormat(format, true))
1089       {
1090         warningMessage("Cannot save file " + fileName + " using format "
1091                 + format, "Alignment output format not supported");
1092         saveAs_actionPerformed(null);
1093         // JBPNote need to have a raise_gui flag here
1094         return false;
1095       }
1096
1097       String[] omitHidden = null;
1098
1099       if (viewport.hasHiddenColumns())
1100       {
1101         int reply = JOptionPane
1102                 .showInternalConfirmDialog(
1103                         Desktop.desktop,
1104                         MessageManager
1105                                 .getString("label.alignment_contains_hidden_columns"),
1106                         MessageManager
1107                                 .getString("action.save_omit_hidden_columns"),
1108                         JOptionPane.YES_NO_OPTION,
1109                         JOptionPane.QUESTION_MESSAGE);
1110
1111         if (reply == JOptionPane.YES_OPTION)
1112         {
1113           omitHidden = viewport.getViewAsString(false);
1114         }
1115       }
1116       FormatAdapter f = new FormatAdapter();
1117       String output = f.formatSequences(format,
1118               viewport.getAlignment(), // class cast exceptions will
1119               // occur in the distant future
1120               omitHidden, f.getCacheSuffixDefault(format),
1121               viewport.getColumnSelection());
1122
1123       if (output == null)
1124       {
1125         success = false;
1126       }
1127       else
1128       {
1129         try
1130         {
1131           java.io.PrintWriter out = new java.io.PrintWriter(
1132                   new java.io.FileWriter(file));
1133
1134           out.print(output);
1135           out.close();
1136           this.setTitle(file);
1137           statusBar.setText(MessageManager.formatMessage(
1138                   "label.successfully_saved_to_file_in_format",
1139                   new String[]
1140                   { fileName, format }));
1141         } catch (Exception ex)
1142         {
1143           success = false;
1144           ex.printStackTrace();
1145         }
1146       }
1147     }
1148
1149     if (!success)
1150     {
1151       JOptionPane.showInternalMessageDialog(this, MessageManager
1152               .formatMessage("label.couldnt_save_file", new String[]
1153               { fileName }), MessageManager
1154               .getString("label.error_saving_file"),
1155               JOptionPane.WARNING_MESSAGE);
1156     }
1157
1158     return success;
1159   }
1160
1161   private void warningMessage(String warning, String title)
1162   {
1163     if (new jalview.util.Platform().isHeadless())
1164     {
1165       System.err.println("Warning: " + title + "\nWarning: " + warning);
1166
1167     }
1168     else
1169     {
1170       JOptionPane.showInternalMessageDialog(this, warning, title,
1171               JOptionPane.WARNING_MESSAGE);
1172     }
1173     return;
1174   }
1175
1176   /**
1177    * DOCUMENT ME!
1178    *
1179    * @param e
1180    *          DOCUMENT ME!
1181    */
1182   @Override
1183   protected void outputText_actionPerformed(ActionEvent e)
1184   {
1185     String[] omitHidden = null;
1186
1187     if (viewport.hasHiddenColumns())
1188     {
1189       int reply = JOptionPane
1190               .showInternalConfirmDialog(
1191                       Desktop.desktop,
1192                       MessageManager
1193                               .getString("label.alignment_contains_hidden_columns"),
1194                       MessageManager
1195                               .getString("action.save_omit_hidden_columns"),
1196                       JOptionPane.YES_NO_OPTION,
1197                       JOptionPane.QUESTION_MESSAGE);
1198
1199       if (reply == JOptionPane.YES_OPTION)
1200       {
1201         omitHidden = viewport.getViewAsString(false);
1202       }
1203     }
1204
1205     CutAndPasteTransfer cap = new CutAndPasteTransfer();
1206     cap.setForInput(null);
1207
1208     try
1209     {
1210       cap.setText(new FormatAdapter().formatSequences(e.getActionCommand(),
1211               viewport.getAlignment(), omitHidden,
1212               viewport.getColumnSelection()));
1213       Desktop.addInternalFrame(cap, MessageManager.formatMessage(
1214               "label.alignment_output_command", new String[]
1215               { e.getActionCommand() }), 600, 500);
1216     } catch (OutOfMemoryError oom)
1217     {
1218       new OOMWarning("Outputting alignment as " + e.getActionCommand(), oom);
1219       cap.dispose();
1220     }
1221
1222   }
1223
1224   /**
1225    * DOCUMENT ME!
1226    *
1227    * @param e
1228    *          DOCUMENT ME!
1229    */
1230   @Override
1231   protected void htmlMenuItem_actionPerformed(ActionEvent e)
1232   {
1233     // new HTMLOutput(alignPanel,
1234     // alignPanel.getSeqPanel().seqCanvas.getSequenceRenderer(),
1235     // alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer());
1236     new HtmlSvgOutput(null, alignPanel);
1237   }
1238
1239   @Override
1240   public void bioJSMenuItem_actionPerformed(ActionEvent e)
1241   {
1242     new BioJsHTMLOutput(alignPanel,
1243             alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer());
1244   }
1245   public void createImageMap(File file, String image)
1246   {
1247     alignPanel.makePNGImageMap(file, image);
1248   }
1249
1250   /**
1251    * DOCUMENT ME!
1252    *
1253    * @param e
1254    *          DOCUMENT ME!
1255    */
1256   @Override
1257   public void createPNG(File f)
1258   {
1259     alignPanel.makePNG(f);
1260   }
1261
1262   /**
1263    * DOCUMENT ME!
1264    *
1265    * @param e
1266    *          DOCUMENT ME!
1267    */
1268   @Override
1269   public void createEPS(File f)
1270   {
1271     alignPanel.makeEPS(f);
1272   }
1273
1274   public void createSVG(File f)
1275   {
1276     alignPanel.makeSVG(f);
1277   }
1278   @Override
1279   public void pageSetup_actionPerformed(ActionEvent e)
1280   {
1281     PrinterJob printJob = PrinterJob.getPrinterJob();
1282     PrintThread.pf = printJob.pageDialog(printJob.defaultPage());
1283   }
1284
1285   /**
1286    * DOCUMENT ME!
1287    *
1288    * @param e
1289    *          DOCUMENT ME!
1290    */
1291   @Override
1292   public void printMenuItem_actionPerformed(ActionEvent e)
1293   {
1294     // Putting in a thread avoids Swing painting problems
1295     PrintThread thread = new PrintThread(alignPanel);
1296     thread.start();
1297   }
1298
1299   @Override
1300   public void exportFeatures_actionPerformed(ActionEvent e)
1301   {
1302     new AnnotationExporter().exportFeatures(alignPanel);
1303   }
1304
1305   @Override
1306   public void exportAnnotations_actionPerformed(ActionEvent e)
1307   {
1308     new AnnotationExporter().exportAnnotations(alignPanel,
1309             viewport.isShowAnnotation() ? viewport.getAlignment()
1310                     .getAlignmentAnnotation() : null, viewport
1311                     .getAlignment().getGroups(), ((Alignment) viewport
1312                     .getAlignment()).alignmentProperties);
1313   }
1314
1315   @Override
1316   public void associatedData_actionPerformed(ActionEvent e)
1317   {
1318     // Pick the tree file
1319     JalviewFileChooser chooser = new JalviewFileChooser(
1320             jalview.bin.Cache.getProperty("LAST_DIRECTORY"));
1321     chooser.setFileView(new JalviewFileView());
1322     chooser.setDialogTitle(MessageManager
1323             .getString("label.load_jalview_annotations"));
1324     chooser.setToolTipText(MessageManager
1325             .getString("label.load_jalview_annotations"));
1326
1327     int value = chooser.showOpenDialog(null);
1328
1329     if (value == JalviewFileChooser.APPROVE_OPTION)
1330     {
1331       String choice = chooser.getSelectedFile().getPath();
1332       jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);
1333       loadJalviewDataFile(choice, null, null, null);
1334     }
1335
1336   }
1337
1338   /**
1339    * Close the current view or all views in the alignment frame. If the frame
1340    * only contains one view then the alignment will be removed from memory.
1341    *
1342    * @param closeAllTabs
1343    */
1344   @Override
1345   public void closeMenuItem_actionPerformed(boolean closeAllTabs)
1346   {
1347     if (alignPanels != null && alignPanels.size() < 2)
1348     {
1349       closeAllTabs = true;
1350     }
1351
1352     try
1353     {
1354       if (alignPanels != null)
1355       {
1356         if (closeAllTabs)
1357         {
1358           if (this.isClosed())
1359           {
1360             // really close all the windows - otherwise wait till
1361             // setClosed(true) is called
1362             for (int i = 0; i < alignPanels.size(); i++)
1363             {
1364               AlignmentPanel ap = (AlignmentPanel) alignPanels.elementAt(i);
1365               ap.closePanel();
1366             }
1367           }
1368         }
1369         else
1370         {
1371           closeView(alignPanel);
1372         }
1373       }
1374
1375       if (closeAllTabs)
1376       {
1377         this.setClosed(true);
1378       }
1379     } catch (Exception ex)
1380     {
1381       ex.printStackTrace();
1382     }
1383   }
1384
1385   /**
1386    * close alignPanel2 and shuffle tabs appropriately.
1387    *
1388    * @param alignPanel2
1389    */
1390   public void closeView(AlignmentPanel alignPanel2)
1391   {
1392     int index = tabbedPane.getSelectedIndex();
1393     int closedindex = tabbedPane.indexOfComponent(alignPanel2);
1394     alignPanels.removeElement(alignPanel2);
1395     // Unnecessary
1396     // if (viewport == alignPanel2.av)
1397     // {
1398     // viewport = null;
1399     // }
1400     alignPanel2.closePanel();
1401     alignPanel2 = null;
1402
1403     tabbedPane.removeTabAt(closedindex);
1404     tabbedPane.validate();
1405
1406     if (index > closedindex || index == tabbedPane.getTabCount())
1407     {
1408       // modify currently selected tab index if necessary.
1409       index--;
1410     }
1411
1412     this.tabSelectionChanged(index);
1413   }
1414
1415   /**
1416    * DOCUMENT ME!
1417    */
1418   void updateEditMenuBar()
1419   {
1420
1421     if (viewport.historyList.size() > 0)
1422     {
1423       undoMenuItem.setEnabled(true);
1424       CommandI command = viewport.historyList.peek();
1425       undoMenuItem.setText(MessageManager.formatMessage(
1426               "label.undo_command", new String[]
1427               { command.getDescription() }));
1428     }
1429     else
1430     {
1431       undoMenuItem.setEnabled(false);
1432       undoMenuItem.setText(MessageManager.getString("action.undo"));
1433     }
1434
1435     if (viewport.redoList.size() > 0)
1436     {
1437       redoMenuItem.setEnabled(true);
1438
1439       CommandI command = viewport.redoList.peek();
1440       redoMenuItem.setText(MessageManager.formatMessage(
1441               "label.redo_command", new String[]
1442               { command.getDescription() }));
1443     }
1444     else
1445     {
1446       redoMenuItem.setEnabled(false);
1447       redoMenuItem.setText(MessageManager.getString("action.redo"));
1448     }
1449   }
1450
1451   public void addHistoryItem(CommandI command)
1452   {
1453     if (command.getSize() > 0)
1454     {
1455       viewport.historyList.push(command);
1456       viewport.redoList.clear();
1457       updateEditMenuBar();
1458       viewport.updateHiddenColumns();
1459       // viewport.hasHiddenColumns = (viewport.getColumnSelection() != null
1460       // && viewport.getColumnSelection().getHiddenColumns() != null &&
1461       // viewport.getColumnSelection()
1462       // .getHiddenColumns().size() > 0);
1463     }
1464   }
1465
1466   /**
1467    *
1468    * @return alignment objects for all views
1469    */
1470   AlignmentI[] getViewAlignments()
1471   {
1472     if (alignPanels != null)
1473     {
1474       Enumeration e = alignPanels.elements();
1475       AlignmentI[] als = new AlignmentI[alignPanels.size()];
1476       for (int i = 0; e.hasMoreElements(); i++)
1477       {
1478         als[i] = ((AlignmentPanel) e.nextElement()).av.getAlignment();
1479       }
1480       return als;
1481     }
1482     if (viewport != null)
1483     {
1484       return new AlignmentI[]
1485       { viewport.getAlignment() };
1486     }
1487     return null;
1488   }
1489
1490   /**
1491    * DOCUMENT ME!
1492    *
1493    * @param e
1494    *          DOCUMENT ME!
1495    */
1496   @Override
1497   protected void undoMenuItem_actionPerformed(ActionEvent e)
1498   {
1499     if (viewport.historyList.empty())
1500     {
1501       return;
1502     }
1503     CommandI command = viewport.historyList.pop();
1504     viewport.redoList.push(command);
1505     command.undoCommand(getViewAlignments());
1506
1507     AlignViewport originalSource = getOriginatingSource(command);
1508     updateEditMenuBar();
1509
1510     if (originalSource != null)
1511     {
1512       if (originalSource != viewport)
1513       {
1514         Cache.log
1515                 .warn("Implementation worry: mismatch of viewport origin for undo");
1516       }
1517       originalSource.updateHiddenColumns();
1518       // originalSource.hasHiddenColumns = (viewport.getColumnSelection() !=
1519       // null
1520       // && viewport.getColumnSelection().getHiddenColumns() != null &&
1521       // viewport.getColumnSelection()
1522       // .getHiddenColumns().size() > 0);
1523       originalSource.firePropertyChange("alignment", null, originalSource
1524               .getAlignment().getSequences());
1525     }
1526   }
1527
1528   /**
1529    * DOCUMENT ME!
1530    *
1531    * @param e
1532    *          DOCUMENT ME!
1533    */
1534   @Override
1535   protected void redoMenuItem_actionPerformed(ActionEvent e)
1536   {
1537     if (viewport.redoList.size() < 1)
1538     {
1539       return;
1540     }
1541
1542     CommandI command = viewport.redoList.pop();
1543     viewport.historyList.push(command);
1544     command.doCommand(getViewAlignments());
1545
1546     AlignViewport originalSource = getOriginatingSource(command);
1547     updateEditMenuBar();
1548
1549     if (originalSource != null)
1550     {
1551
1552       if (originalSource != viewport)
1553       {
1554         Cache.log
1555                 .warn("Implementation worry: mismatch of viewport origin for redo");
1556       }
1557       originalSource.updateHiddenColumns();
1558       // originalSource.hasHiddenColumns = (viewport.getColumnSelection() !=
1559       // null
1560       // && viewport.getColumnSelection().getHiddenColumns() != null &&
1561       // viewport.getColumnSelection()
1562       // .getHiddenColumns().size() > 0);
1563       originalSource.firePropertyChange("alignment", null, originalSource
1564               .getAlignment().getSequences());
1565     }
1566   }
1567
1568   AlignViewport getOriginatingSource(CommandI command)
1569   {
1570     AlignViewport originalSource = null;
1571     // For sequence removal and addition, we need to fire
1572     // the property change event FROM the viewport where the
1573     // original alignment was altered
1574     AlignmentI al = null;
1575     if (command instanceof EditCommand)
1576     {
1577       EditCommand editCommand = (EditCommand) command;
1578       al = editCommand.getAlignment();
1579       Vector comps = (Vector) PaintRefresher.components.get(viewport
1580               .getSequenceSetId());
1581
1582       for (int i = 0; i < comps.size(); i++)
1583       {
1584         if (comps.elementAt(i) instanceof AlignmentPanel)
1585         {
1586           if (al == ((AlignmentPanel) comps.elementAt(i)).av.getAlignment())
1587           {
1588             originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
1589             break;
1590           }
1591         }
1592       }
1593     }
1594
1595     if (originalSource == null)
1596     {
1597       // The original view is closed, we must validate
1598       // the current view against the closed view first
1599       if (al != null)
1600       {
1601         PaintRefresher.validateSequences(al, viewport.getAlignment());
1602       }
1603
1604       originalSource = viewport;
1605     }
1606
1607     return originalSource;
1608   }
1609
1610   /**
1611    * DOCUMENT ME!
1612    *
1613    * @param up
1614    *          DOCUMENT ME!
1615    */
1616   public void moveSelectedSequences(boolean up)
1617   {
1618     SequenceGroup sg = viewport.getSelectionGroup();
1619
1620     if (sg == null)
1621     {
1622       return;
1623     }
1624     viewport.getAlignment().moveSelectedSequencesByOne(sg,
1625             viewport.getHiddenRepSequences(), up);
1626     alignPanel.paintAlignment(true);
1627   }
1628
1629   synchronized void slideSequences(boolean right, int size)
1630   {
1631     List<SequenceI> sg = new Vector();
1632     if (viewport.cursorMode)
1633     {
1634       sg.add(viewport.getAlignment().getSequenceAt(
1635               alignPanel.getSeqPanel().seqCanvas.cursorY));
1636     }
1637     else if (viewport.getSelectionGroup() != null
1638             && viewport.getSelectionGroup().getSize() != viewport
1639                     .getAlignment().getHeight())
1640     {
1641       sg = viewport.getSelectionGroup().getSequences(
1642               viewport.getHiddenRepSequences());
1643     }
1644
1645     if (sg.size() < 1)
1646     {
1647       return;
1648     }
1649
1650     Vector invertGroup = new Vector();
1651
1652     for (int i = 0; i < viewport.getAlignment().getHeight(); i++)
1653     {
1654       if (!sg.contains(viewport.getAlignment().getSequenceAt(i)))
1655       {
1656         invertGroup.add(viewport.getAlignment().getSequenceAt(i));
1657       }
1658     }
1659
1660     SequenceI[] seqs1 = sg.toArray(new SequenceI[0]);
1661
1662     SequenceI[] seqs2 = new SequenceI[invertGroup.size()];
1663     for (int i = 0; i < invertGroup.size(); i++)
1664     {
1665       seqs2[i] = (SequenceI) invertGroup.elementAt(i);
1666     }
1667
1668     SlideSequencesCommand ssc;
1669     if (right)
1670     {
1671       ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1,
1672               size, viewport.getGapCharacter());
1673     }
1674     else
1675     {
1676       ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2,
1677               size, viewport.getGapCharacter());
1678     }
1679
1680     int groupAdjustment = 0;
1681     if (ssc.getGapsInsertedBegin() && right)
1682     {
1683       if (viewport.cursorMode)
1684       {
1685         alignPanel.getSeqPanel().moveCursor(size, 0);
1686       }
1687       else
1688       {
1689         groupAdjustment = size;
1690       }
1691     }
1692     else if (!ssc.getGapsInsertedBegin() && !right)
1693     {
1694       if (viewport.cursorMode)
1695       {
1696         alignPanel.getSeqPanel().moveCursor(-size, 0);
1697       }
1698       else
1699       {
1700         groupAdjustment = -size;
1701       }
1702     }
1703
1704     if (groupAdjustment != 0)
1705     {
1706       viewport.getSelectionGroup().setStartRes(
1707               viewport.getSelectionGroup().getStartRes() + groupAdjustment);
1708       viewport.getSelectionGroup().setEndRes(
1709               viewport.getSelectionGroup().getEndRes() + groupAdjustment);
1710     }
1711
1712     boolean appendHistoryItem = false;
1713     if (viewport.historyList != null && viewport.historyList.size() > 0
1714             && viewport.historyList.peek() instanceof SlideSequencesCommand)
1715     {
1716       appendHistoryItem = ssc
1717               .appendSlideCommand((SlideSequencesCommand) viewport.historyList
1718                       .peek());
1719     }
1720
1721     if (!appendHistoryItem)
1722     {
1723       addHistoryItem(ssc);
1724     }
1725
1726     repaint();
1727   }
1728
1729   /**
1730    * DOCUMENT ME!
1731    *
1732    * @param e
1733    *          DOCUMENT ME!
1734    */
1735   @Override
1736   protected void copy_actionPerformed(ActionEvent e)
1737   {
1738     System.gc();
1739     if (viewport.getSelectionGroup() == null)
1740     {
1741       return;
1742     }
1743     // TODO: preserve the ordering of displayed alignment annotation in any
1744     // internal paste (particularly sequence associated annotation)
1745     SequenceI[] seqs = viewport.getSelectionAsNewSequence();
1746     String[] omitHidden = null;
1747
1748     if (viewport.hasHiddenColumns())
1749     {
1750       omitHidden = viewport.getViewAsString(true);
1751     }
1752
1753     String output = new FormatAdapter().formatSequences("Fasta", seqs,
1754             omitHidden);
1755
1756     StringSelection ss = new StringSelection(output);
1757
1758     try
1759     {
1760       jalview.gui.Desktop.internalCopy = true;
1761       // Its really worth setting the clipboard contents
1762       // to empty before setting the large StringSelection!!
1763       Toolkit.getDefaultToolkit().getSystemClipboard()
1764               .setContents(new StringSelection(""), null);
1765
1766       Toolkit.getDefaultToolkit().getSystemClipboard()
1767               .setContents(ss, Desktop.instance);
1768     } catch (OutOfMemoryError er)
1769     {
1770       new OOMWarning("copying region", er);
1771       return;
1772     }
1773
1774     Vector hiddenColumns = null;
1775     if (viewport.hasHiddenColumns())
1776     {
1777       hiddenColumns = new Vector();
1778       int hiddenOffset = viewport.getSelectionGroup().getStartRes(), hiddenCutoff = viewport
1779               .getSelectionGroup().getEndRes();
1780       for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns()
1781               .size(); i++)
1782       {
1783         int[] region = (int[]) viewport.getColumnSelection()
1784                 .getHiddenColumns().elementAt(i);
1785         if (region[0] >= hiddenOffset && region[1] <= hiddenCutoff)
1786         {
1787           hiddenColumns.addElement(new int[]
1788           { region[0] - hiddenOffset, region[1] - hiddenOffset });
1789         }
1790       }
1791     }
1792
1793     Desktop.jalviewClipboard = new Object[]
1794     { seqs, viewport.getAlignment().getDataset(), hiddenColumns };
1795     statusBar.setText(MessageManager.formatMessage(
1796             "label.copied_sequences_to_clipboard", new String[]
1797             { Integer.valueOf(seqs.length).toString() }));
1798   }
1799
1800   /**
1801    * DOCUMENT ME!
1802    *
1803    * @param e
1804    *          DOCUMENT ME!
1805    */
1806   @Override
1807   protected void pasteNew_actionPerformed(ActionEvent e)
1808   {
1809     paste(true);
1810   }
1811
1812   /**
1813    * DOCUMENT ME!
1814    *
1815    * @param e
1816    *          DOCUMENT ME!
1817    */
1818   @Override
1819   protected void pasteThis_actionPerformed(ActionEvent e)
1820   {
1821     paste(false);
1822   }
1823
1824   /**
1825    * Paste contents of Jalview clipboard
1826    *
1827    * @param newAlignment
1828    *          true to paste to a new alignment, otherwise add to this.
1829    */
1830   void paste(boolean newAlignment)
1831   {
1832     boolean externalPaste = true;
1833     try
1834     {
1835       Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();
1836       Transferable contents = c.getContents(this);
1837
1838       if (contents == null)
1839       {
1840         return;
1841       }
1842
1843       String str, format;
1844       try
1845       {
1846         str = (String) contents.getTransferData(DataFlavor.stringFlavor);
1847         if (str.length() < 1)
1848         {
1849           return;
1850         }
1851
1852         format = new IdentifyFile().Identify(str, "Paste");
1853
1854       } catch (OutOfMemoryError er)
1855       {
1856         new OOMWarning("Out of memory pasting sequences!!", er);
1857         return;
1858       }
1859
1860       SequenceI[] sequences;
1861       boolean annotationAdded = false;
1862       AlignmentI alignment = null;
1863
1864       if (Desktop.jalviewClipboard != null)
1865       {
1866         // The clipboard was filled from within Jalview, we must use the
1867         // sequences
1868         // And dataset from the copied alignment
1869         SequenceI[] newseq = (SequenceI[]) Desktop.jalviewClipboard[0];
1870         // be doubly sure that we create *new* sequence objects.
1871         sequences = new SequenceI[newseq.length];
1872         for (int i = 0; i < newseq.length; i++)
1873         {
1874           sequences[i] = new Sequence(newseq[i]);
1875         }
1876         alignment = new Alignment(sequences);
1877         externalPaste = false;
1878       }
1879       else
1880       {
1881         // parse the clipboard as an alignment.
1882         alignment = new FormatAdapter().readFile(str, "Paste", format);
1883         sequences = alignment.getSequencesArray();
1884       }
1885
1886       int alwidth = 0;
1887       ArrayList<Integer> newGraphGroups = new ArrayList<Integer>();
1888       int fgroup = -1;
1889
1890       if (newAlignment)
1891       {
1892
1893         if (Desktop.jalviewClipboard != null)
1894         {
1895           // dataset is inherited
1896           alignment.setDataset((Alignment) Desktop.jalviewClipboard[1]);
1897         }
1898         else
1899         {
1900           // new dataset is constructed
1901           alignment.setDataset(null);
1902         }
1903         alwidth = alignment.getWidth() + 1;
1904       }
1905       else
1906       {
1907         AlignmentI pastedal = alignment; // preserve pasted alignment object
1908         // Add pasted sequences and dataset into existing alignment.
1909         alignment = viewport.getAlignment();
1910         alwidth = alignment.getWidth() + 1;
1911         // decide if we need to import sequences from an existing dataset
1912         boolean importDs = Desktop.jalviewClipboard != null
1913                 && Desktop.jalviewClipboard[1] != alignment.getDataset();
1914         // importDs==true instructs us to copy over new dataset sequences from
1915         // an existing alignment
1916         Vector newDs = (importDs) ? new Vector() : null; // used to create
1917         // minimum dataset set
1918
1919         for (int i = 0; i < sequences.length; i++)
1920         {
1921           if (importDs)
1922           {
1923             newDs.addElement(null);
1924           }
1925           SequenceI ds = sequences[i].getDatasetSequence(); // null for a simple
1926           // paste
1927           if (importDs && ds != null)
1928           {
1929             if (!newDs.contains(ds))
1930             {
1931               newDs.setElementAt(ds, i);
1932               ds = new Sequence(ds);
1933               // update with new dataset sequence
1934               sequences[i].setDatasetSequence(ds);
1935             }
1936             else
1937             {
1938               ds = sequences[newDs.indexOf(ds)].getDatasetSequence();
1939             }
1940           }
1941           else
1942           {
1943             // copy and derive new dataset sequence
1944             sequences[i] = sequences[i].deriveSequence();
1945             alignment.getDataset().addSequence(
1946                     sequences[i].getDatasetSequence());
1947             // TODO: avoid creation of duplicate dataset sequences with a
1948             // 'contains' method using SequenceI.equals()/SequenceI.contains()
1949           }
1950           alignment.addSequence(sequences[i]); // merges dataset
1951         }
1952         if (newDs != null)
1953         {
1954           newDs.clear(); // tidy up
1955         }
1956         if (alignment.getAlignmentAnnotation() != null)
1957         {
1958           for (AlignmentAnnotation alan : alignment
1959                   .getAlignmentAnnotation())
1960           {
1961             if (alan.graphGroup > fgroup)
1962             {
1963               fgroup = alan.graphGroup;
1964             }
1965           }
1966         }
1967         if (pastedal.getAlignmentAnnotation() != null)
1968         {
1969           // Add any annotation attached to alignment.
1970           AlignmentAnnotation[] alann = pastedal.getAlignmentAnnotation();
1971           for (int i = 0; i < alann.length; i++)
1972           {
1973             annotationAdded = true;
1974             if (alann[i].sequenceRef == null && !alann[i].autoCalculated)
1975             {
1976               AlignmentAnnotation newann = new AlignmentAnnotation(alann[i]);
1977               if (newann.graphGroup > -1)
1978               {
1979                 if (newGraphGroups.size() <= newann.graphGroup
1980                         || newGraphGroups.get(newann.graphGroup) == null)
1981                 {
1982                   for (int q = newGraphGroups.size(); q <= newann.graphGroup; q++)
1983                   {
1984                     newGraphGroups.add(q, null);
1985                   }
1986                   newGraphGroups.set(newann.graphGroup, new Integer(
1987                           ++fgroup));
1988                 }
1989                 newann.graphGroup = newGraphGroups.get(newann.graphGroup)
1990                         .intValue();
1991               }
1992
1993               newann.padAnnotation(alwidth);
1994               alignment.addAnnotation(newann);
1995             }
1996           }
1997         }
1998       }
1999       if (!newAlignment)
2000       {
2001         // /////
2002         // ADD HISTORY ITEM
2003         //
2004         addHistoryItem(new EditCommand(
2005                 MessageManager.getString("label.add_sequences"),
2006                 Action.PASTE,
2007                 sequences, 0, alignment.getWidth(), alignment));
2008       }
2009       // Add any annotations attached to sequences
2010       for (int i = 0; i < sequences.length; i++)
2011       {
2012         if (sequences[i].getAnnotation() != null)
2013         {
2014           AlignmentAnnotation newann;
2015           for (int a = 0; a < sequences[i].getAnnotation().length; a++)
2016           {
2017             annotationAdded = true;
2018             newann = sequences[i].getAnnotation()[a];
2019             newann.adjustForAlignment();
2020             newann.padAnnotation(alwidth);
2021             if (newann.graphGroup > -1)
2022             {
2023               if (newann.graphGroup > -1)
2024               {
2025                 if (newGraphGroups.size() <= newann.graphGroup
2026                         || newGraphGroups.get(newann.graphGroup) == null)
2027                 {
2028                   for (int q = newGraphGroups.size(); q <= newann.graphGroup; q++)
2029                   {
2030                     newGraphGroups.add(q, null);
2031                   }
2032                   newGraphGroups.set(newann.graphGroup, new Integer(
2033                           ++fgroup));
2034                 }
2035                 newann.graphGroup = newGraphGroups.get(newann.graphGroup)
2036                         .intValue();
2037               }
2038             }
2039             alignment.addAnnotation(sequences[i].getAnnotation()[a]); // annotation
2040             // was
2041             // duplicated
2042             // earlier
2043             alignment
2044                     .setAnnotationIndex(sequences[i].getAnnotation()[a], a);
2045           }
2046         }
2047       }
2048       if (!newAlignment)
2049       {
2050
2051         // propagate alignment changed.
2052         viewport.setEndSeq(alignment.getHeight());
2053         if (annotationAdded)
2054         {
2055           // Duplicate sequence annotation in all views.
2056           AlignmentI[] alview = this.getViewAlignments();
2057           for (int i = 0; i < sequences.length; i++)
2058           {
2059             AlignmentAnnotation sann[] = sequences[i].getAnnotation();
2060             if (sann == null)
2061             {
2062               continue;
2063             }
2064             for (int avnum = 0; avnum < alview.length; avnum++)
2065             {
2066               if (alview[avnum] != alignment)
2067               {
2068                 // duplicate in a view other than the one with input focus
2069                 int avwidth = alview[avnum].getWidth() + 1;
2070                 // this relies on sann being preserved after we
2071                 // modify the sequence's annotation array for each duplication
2072                 for (int a = 0; a < sann.length; a++)
2073                 {
2074                   AlignmentAnnotation newann = new AlignmentAnnotation(
2075                           sann[a]);
2076                   sequences[i].addAlignmentAnnotation(newann);
2077                   newann.padAnnotation(avwidth);
2078                   alview[avnum].addAnnotation(newann); // annotation was
2079                   // duplicated earlier
2080                   // TODO JAL-1145 graphGroups are not updated for sequence
2081                   // annotation added to several views. This may cause
2082                   // strangeness
2083                   alview[avnum].setAnnotationIndex(newann, a);
2084                 }
2085               }
2086             }
2087           }
2088           buildSortByAnnotationScoresMenu();
2089         }
2090         viewport.firePropertyChange("alignment", null,
2091                 alignment.getSequences());
2092         if (alignPanels != null)
2093         {
2094           for (AlignmentPanel ap : ((Vector<AlignmentPanel>) alignPanels))
2095           {
2096             ap.validateAnnotationDimensions(false);
2097           }
2098         }
2099         else
2100         {
2101           alignPanel.validateAnnotationDimensions(false);
2102         }
2103
2104       }
2105       else
2106       {
2107         AlignFrame af = new AlignFrame(alignment, DEFAULT_WIDTH,
2108                 DEFAULT_HEIGHT);
2109         String newtitle = new String("Copied sequences");
2110
2111         if (Desktop.jalviewClipboard != null
2112                 && Desktop.jalviewClipboard[2] != null)
2113         {
2114           Vector hc = (Vector) Desktop.jalviewClipboard[2];
2115           for (int i = 0; i < hc.size(); i++)
2116           {
2117             int[] region = (int[]) hc.elementAt(i);
2118             af.viewport.hideColumns(region[0], region[1]);
2119           }
2120         }
2121
2122         // >>>This is a fix for the moment, until a better solution is
2123         // found!!<<<
2124         af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer()
2125                 .transferSettings(
2126                         alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer());
2127
2128         // TODO: maintain provenance of an alignment, rather than just make the
2129         // title a concatenation of operations.
2130         if (!externalPaste)
2131         {
2132           if (title.startsWith("Copied sequences"))
2133           {
2134             newtitle = title;
2135           }
2136           else
2137           {
2138             newtitle = newtitle.concat("- from " + title);
2139           }
2140         }
2141         else
2142         {
2143           newtitle = new String("Pasted sequences");
2144         }
2145
2146         Desktop.addInternalFrame(af, newtitle, DEFAULT_WIDTH,
2147                 DEFAULT_HEIGHT);
2148
2149       }
2150
2151     } catch (Exception ex)
2152     {
2153       ex.printStackTrace();
2154       System.out.println("Exception whilst pasting: " + ex);
2155       // could be anything being pasted in here
2156     }
2157
2158   }
2159
2160   @Override
2161   protected void expand_newalign(ActionEvent e)
2162   {
2163     try
2164     {
2165       AlignmentI alignment = AlignmentUtils.expandContext(getViewport()
2166               .getAlignment(), -1);
2167       AlignFrame af = new AlignFrame(alignment, DEFAULT_WIDTH,
2168               DEFAULT_HEIGHT);
2169       String newtitle = new String("Flanking alignment");
2170
2171       if (Desktop.jalviewClipboard != null
2172               && Desktop.jalviewClipboard[2] != null)
2173       {
2174         Vector hc = (Vector) Desktop.jalviewClipboard[2];
2175         for (int i = 0; i < hc.size(); i++)
2176         {
2177           int[] region = (int[]) hc.elementAt(i);
2178           af.viewport.hideColumns(region[0], region[1]);
2179         }
2180       }
2181
2182       // >>>This is a fix for the moment, until a better solution is
2183       // found!!<<<
2184       af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer()
2185               .transferSettings(
2186                       alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer());
2187
2188       // TODO: maintain provenance of an alignment, rather than just make the
2189       // title a concatenation of operations.
2190       {
2191         if (title.startsWith("Copied sequences"))
2192         {
2193           newtitle = title;
2194         }
2195         else
2196         {
2197           newtitle = newtitle.concat("- from " + title);
2198         }
2199       }
2200
2201       Desktop.addInternalFrame(af, newtitle, DEFAULT_WIDTH, DEFAULT_HEIGHT);
2202
2203     } catch (Exception ex)
2204     {
2205       ex.printStackTrace();
2206       System.out.println("Exception whilst pasting: " + ex);
2207       // could be anything being pasted in here
2208     } catch (OutOfMemoryError oom)
2209     {
2210       new OOMWarning("Viewing flanking region of alignment", oom);
2211     }
2212   }
2213
2214   /**
2215    * DOCUMENT ME!
2216    *
2217    * @param e
2218    *          DOCUMENT ME!
2219    */
2220   @Override
2221   protected void cut_actionPerformed(ActionEvent e)
2222   {
2223     copy_actionPerformed(null);
2224     delete_actionPerformed(null);
2225   }
2226
2227   /**
2228    * DOCUMENT ME!
2229    *
2230    * @param e
2231    *          DOCUMENT ME!
2232    */
2233   @Override
2234   protected void delete_actionPerformed(ActionEvent evt)
2235   {
2236
2237     SequenceGroup sg = viewport.getSelectionGroup();
2238     if (sg == null)
2239     {
2240       return;
2241     }
2242
2243     List<SequenceI> seqs = new ArrayList<SequenceI>(sg.getSize());
2244     SequenceI seq;
2245     for (int i = 0; i < sg.getSize(); i++)
2246     {
2247       seq = sg.getSequenceAt(i);
2248       seqs.add(seq);
2249     }
2250
2251     // If the cut affects all sequences, warn, remove highlighted columns
2252     if (sg.getSize() == viewport.getAlignment().getHeight())
2253     {
2254       int confirm = JOptionPane.showConfirmDialog(this,
2255               MessageManager.getString("warn.delete_all"), // $NON-NLS-1$
2256               MessageManager.getString("label.delete_all"), // $NON-NLS-1$
2257               JOptionPane.OK_CANCEL_OPTION);
2258
2259       if (confirm == JOptionPane.CANCEL_OPTION
2260               || confirm == JOptionPane.CLOSED_OPTION)
2261       {
2262         return;
2263       }
2264       viewport.getColumnSelection().removeElements(sg.getStartRes(),
2265               sg.getEndRes() + 1);
2266     }
2267
2268     SequenceI[] cut = new SequenceI[seqs.size()];
2269     for (int i = 0; i < seqs.size(); i++)
2270     {
2271       cut[i] = seqs.get(i);
2272     }
2273
2274     /*
2275      * //ADD HISTORY ITEM
2276      */
2277     addHistoryItem(new EditCommand(
2278             MessageManager.getString("label.cut_sequences"), Action.CUT,
2279             cut, sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1,
2280             viewport.getAlignment()));
2281
2282     viewport.setSelectionGroup(null);
2283     viewport.sendSelection();
2284     viewport.getAlignment().deleteGroup(sg);
2285
2286     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2287             .getSequences());
2288     if (viewport.getAlignment().getHeight() < 1)
2289     {
2290       try
2291       {
2292         this.setClosed(true);
2293       } catch (Exception ex)
2294       {
2295       }
2296     }
2297   }
2298
2299   /**
2300    * DOCUMENT ME!
2301    *
2302    * @param e
2303    *          DOCUMENT ME!
2304    */
2305   @Override
2306   protected void deleteGroups_actionPerformed(ActionEvent e)
2307   {
2308     if (avc.deleteGroups())
2309     {
2310       PaintRefresher.Refresh(this, viewport.getSequenceSetId());
2311       alignPanel.updateAnnotation();
2312       alignPanel.paintAlignment(true);
2313     }
2314   }
2315
2316   /**
2317    * DOCUMENT ME!
2318    *
2319    * @param e
2320    *          DOCUMENT ME!
2321    */
2322   @Override
2323   public void selectAllSequenceMenuItem_actionPerformed(ActionEvent e)
2324   {
2325     SequenceGroup sg = new SequenceGroup();
2326
2327     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2328     {
2329       sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
2330     }
2331
2332     sg.setEndRes(viewport.getAlignment().getWidth() - 1);
2333     viewport.setSelectionGroup(sg);
2334     viewport.sendSelection();
2335     alignPanel.paintAlignment(true);
2336     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2337   }
2338
2339   /**
2340    * DOCUMENT ME!
2341    *
2342    * @param e
2343    *          DOCUMENT ME!
2344    */
2345   @Override
2346   public void deselectAllSequenceMenuItem_actionPerformed(ActionEvent e)
2347   {
2348     if (viewport.cursorMode)
2349     {
2350       alignPanel.getSeqPanel().keyboardNo1 = null;
2351       alignPanel.getSeqPanel().keyboardNo2 = null;
2352     }
2353     viewport.setSelectionGroup(null);
2354     viewport.getColumnSelection().clear();
2355     viewport.setSelectionGroup(null);
2356     alignPanel.getSeqPanel().seqCanvas.highlightSearchResults(null);
2357     alignPanel.getIdPanel().getIdCanvas().searchResults = null;
2358     alignPanel.paintAlignment(true);
2359     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2360     viewport.sendSelection();
2361   }
2362
2363   /**
2364    * DOCUMENT ME!
2365    *
2366    * @param e
2367    *          DOCUMENT ME!
2368    */
2369   @Override
2370   public void invertSequenceMenuItem_actionPerformed(ActionEvent e)
2371   {
2372     SequenceGroup sg = viewport.getSelectionGroup();
2373
2374     if (sg == null)
2375     {
2376       selectAllSequenceMenuItem_actionPerformed(null);
2377
2378       return;
2379     }
2380
2381     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2382     {
2383       sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
2384     }
2385
2386     alignPanel.paintAlignment(true);
2387     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2388     viewport.sendSelection();
2389   }
2390
2391   @Override
2392   public void invertColSel_actionPerformed(ActionEvent e)
2393   {
2394     viewport.invertColumnSelection();
2395     alignPanel.paintAlignment(true);
2396     viewport.sendSelection();
2397   }
2398
2399   /**
2400    * DOCUMENT ME!
2401    *
2402    * @param e
2403    *          DOCUMENT ME!
2404    */
2405   @Override
2406   public void remove2LeftMenuItem_actionPerformed(ActionEvent e)
2407   {
2408     trimAlignment(true);
2409   }
2410
2411   /**
2412    * DOCUMENT ME!
2413    *
2414    * @param e
2415    *          DOCUMENT ME!
2416    */
2417   @Override
2418   public void remove2RightMenuItem_actionPerformed(ActionEvent e)
2419   {
2420     trimAlignment(false);
2421   }
2422
2423   void trimAlignment(boolean trimLeft)
2424   {
2425     ColumnSelection colSel = viewport.getColumnSelection();
2426     int column;
2427
2428     if (colSel.size() > 0)
2429     {
2430       if (trimLeft)
2431       {
2432         column = colSel.getMin();
2433       }
2434       else
2435       {
2436         column = colSel.getMax();
2437       }
2438
2439       SequenceI[] seqs;
2440       if (viewport.getSelectionGroup() != null)
2441       {
2442         seqs = viewport.getSelectionGroup().getSequencesAsArray(
2443                 viewport.getHiddenRepSequences());
2444       }
2445       else
2446       {
2447         seqs = viewport.getAlignment().getSequencesArray();
2448       }
2449
2450       TrimRegionCommand trimRegion;
2451       if (trimLeft)
2452       {
2453         trimRegion = new TrimRegionCommand("Remove Left",
2454                 TrimRegionCommand.TRIM_LEFT, seqs, column,
2455                 viewport.getAlignment(), viewport.getColumnSelection(),
2456                 viewport.getSelectionGroup());
2457         viewport.setStartRes(0);
2458       }
2459       else
2460       {
2461         trimRegion = new TrimRegionCommand("Remove Right",
2462                 TrimRegionCommand.TRIM_RIGHT, seqs, column,
2463                 viewport.getAlignment(), viewport.getColumnSelection(),
2464                 viewport.getSelectionGroup());
2465       }
2466
2467       statusBar.setText(MessageManager.formatMessage(
2468               "label.removed_columns", new String[]
2469               { Integer.valueOf(trimRegion.getSize()).toString() }));
2470
2471       addHistoryItem(trimRegion);
2472
2473       for (SequenceGroup sg : viewport.getAlignment().getGroups())
2474       {
2475         if ((trimLeft && !sg.adjustForRemoveLeft(column))
2476                 || (!trimLeft && !sg.adjustForRemoveRight(column)))
2477         {
2478           viewport.getAlignment().deleteGroup(sg);
2479         }
2480       }
2481
2482       viewport.firePropertyChange("alignment", null, viewport
2483               .getAlignment().getSequences());
2484     }
2485   }
2486
2487   /**
2488    * DOCUMENT ME!
2489    *
2490    * @param e
2491    *          DOCUMENT ME!
2492    */
2493   @Override
2494   public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e)
2495   {
2496     int start = 0, end = viewport.getAlignment().getWidth() - 1;
2497
2498     SequenceI[] seqs;
2499     if (viewport.getSelectionGroup() != null)
2500     {
2501       seqs = viewport.getSelectionGroup().getSequencesAsArray(
2502               viewport.getHiddenRepSequences());
2503       start = viewport.getSelectionGroup().getStartRes();
2504       end = viewport.getSelectionGroup().getEndRes();
2505     }
2506     else
2507     {
2508       seqs = viewport.getAlignment().getSequencesArray();
2509     }
2510
2511     RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
2512             "Remove Gapped Columns", seqs, start, end,
2513             viewport.getAlignment());
2514
2515     addHistoryItem(removeGapCols);
2516
2517     statusBar.setText(MessageManager.formatMessage(
2518             "label.removed_empty_columns", new String[]
2519             { Integer.valueOf(removeGapCols.getSize()).toString() }));
2520
2521     // This is to maintain viewport position on first residue
2522     // of first sequence
2523     SequenceI seq = viewport.getAlignment().getSequenceAt(0);
2524     int startRes = seq.findPosition(viewport.startRes);
2525     // ShiftList shifts;
2526     // viewport.getAlignment().removeGaps(shifts=new ShiftList());
2527     // edit.alColumnChanges=shifts.getInverse();
2528     // if (viewport.hasHiddenColumns)
2529     // viewport.getColumnSelection().compensateForEdits(shifts);
2530     viewport.setStartRes(seq.findIndex(startRes) - 1);
2531     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2532             .getSequences());
2533
2534   }
2535
2536   /**
2537    * DOCUMENT ME!
2538    *
2539    * @param e
2540    *          DOCUMENT ME!
2541    */
2542   @Override
2543   public void removeAllGapsMenuItem_actionPerformed(ActionEvent e)
2544   {
2545     int start = 0, end = viewport.getAlignment().getWidth() - 1;
2546
2547     SequenceI[] seqs;
2548     if (viewport.getSelectionGroup() != null)
2549     {
2550       seqs = viewport.getSelectionGroup().getSequencesAsArray(
2551               viewport.getHiddenRepSequences());
2552       start = viewport.getSelectionGroup().getStartRes();
2553       end = viewport.getSelectionGroup().getEndRes();
2554     }
2555     else
2556     {
2557       seqs = viewport.getAlignment().getSequencesArray();
2558     }
2559
2560     // This is to maintain viewport position on first residue
2561     // of first sequence
2562     SequenceI seq = viewport.getAlignment().getSequenceAt(0);
2563     int startRes = seq.findPosition(viewport.startRes);
2564
2565     addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
2566             viewport.getAlignment()));
2567
2568     viewport.setStartRes(seq.findIndex(startRes) - 1);
2569
2570     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2571             .getSequences());
2572
2573   }
2574
2575   /**
2576    * DOCUMENT ME!
2577    *
2578    * @param e
2579    *          DOCUMENT ME!
2580    */
2581   @Override
2582   public void padGapsMenuitem_actionPerformed(ActionEvent e)
2583   {
2584     viewport.setPadGaps(padGapsMenuitem.isSelected());
2585     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2586             .getSequences());
2587   }
2588
2589   // else
2590   {
2591     // if (justifySeqs>0)
2592     {
2593       // alignment.justify(justifySeqs!=RIGHT_JUSTIFY);
2594     }
2595   }
2596
2597   // }
2598
2599   /**
2600    * DOCUMENT ME!
2601    *
2602    * @param e
2603    *          DOCUMENT ME!
2604    */
2605   @Override
2606   public void findMenuItem_actionPerformed(ActionEvent e)
2607   {
2608     new Finder();
2609   }
2610
2611   @Override
2612   public void newView_actionPerformed(ActionEvent e)
2613   {
2614     newView(true);
2615   }
2616
2617   /**
2618    *
2619    * @param copyAnnotation
2620    *          if true then duplicate all annnotation, groups and settings
2621    * @return new alignment panel, already displayed.
2622    */
2623   public AlignmentPanel newView(boolean copyAnnotation)
2624   {
2625     return newView(null, copyAnnotation);
2626   }
2627
2628   /**
2629    *
2630    * @param viewTitle
2631    *          title of newly created view
2632    * @return new alignment panel, already displayed.
2633    */
2634   public AlignmentPanel newView(String viewTitle)
2635   {
2636     return newView(viewTitle, true);
2637   }
2638
2639   /**
2640    *
2641    * @param viewTitle
2642    *          title of newly created view
2643    * @param copyAnnotation
2644    *          if true then duplicate all annnotation, groups and settings
2645    * @return new alignment panel, already displayed.
2646    */
2647   public AlignmentPanel newView(String viewTitle, boolean copyAnnotation)
2648   {
2649     AlignmentPanel newap = new Jalview2XML().copyAlignPanel(alignPanel,
2650             true);
2651     if (!copyAnnotation)
2652     {
2653       // just remove all the current annotation except for the automatic stuff
2654       newap.av.getAlignment().deleteAllGroups();
2655       for (AlignmentAnnotation alan : newap.av.getAlignment()
2656               .getAlignmentAnnotation())
2657       {
2658         if (!alan.autoCalculated)
2659         {
2660           newap.av.getAlignment().deleteAnnotation(alan);
2661         }
2662         ;
2663       }
2664     }
2665
2666     newap.av.gatherViewsHere = false;
2667
2668     if (viewport.viewName == null)
2669     {
2670       viewport.viewName = "Original";
2671     }
2672
2673     newap.av.historyList = viewport.historyList;
2674     newap.av.redoList = viewport.redoList;
2675
2676     int index = Desktop.getViewCount(viewport.getSequenceSetId());
2677     // make sure the new view has a unique name - this is essential for Jalview
2678     // 2 archives
2679     boolean addFirstIndex = false;
2680     if (viewTitle == null || viewTitle.trim().length() == 0)
2681     {
2682       viewTitle = MessageManager.getString("action.view");
2683       addFirstIndex = true;
2684     }
2685     else
2686     {
2687       index = 1;// we count from 1 if given a specific name
2688     }
2689     String newViewName = viewTitle + ((addFirstIndex) ? " " + index : "");
2690     Vector comps = (Vector) PaintRefresher.components.get(viewport
2691             .getSequenceSetId());
2692     Vector existingNames = new Vector();
2693     for (int i = 0; i < comps.size(); i++)
2694     {
2695       if (comps.elementAt(i) instanceof AlignmentPanel)
2696       {
2697         AlignmentPanel ap = (AlignmentPanel) comps.elementAt(i);
2698         if (!existingNames.contains(ap.av.viewName))
2699         {
2700           existingNames.addElement(ap.av.viewName);
2701         }
2702       }
2703     }
2704
2705     while (existingNames.contains(newViewName))
2706     {
2707       newViewName = viewTitle + " " + (++index);
2708     }
2709
2710     newap.av.viewName = newViewName;
2711
2712     addAlignmentPanel(newap, true);
2713     newap.alignmentChanged();
2714
2715     if (alignPanels.size() == 2)
2716     {
2717       viewport.gatherViewsHere = true;
2718     }
2719     tabbedPane.setSelectedIndex(tabbedPane.getTabCount() - 1);
2720     return newap;
2721   }
2722
2723   @Override
2724   public void expandViews_actionPerformed(ActionEvent e)
2725   {
2726     Desktop.instance.explodeViews(this);
2727   }
2728
2729   @Override
2730   public void gatherViews_actionPerformed(ActionEvent e)
2731   {
2732     Desktop.instance.gatherViews(this);
2733   }
2734
2735   /**
2736    * DOCUMENT ME!
2737    *
2738    * @param e
2739    *          DOCUMENT ME!
2740    */
2741   @Override
2742   public void font_actionPerformed(ActionEvent e)
2743   {
2744     new FontChooser(alignPanel);
2745   }
2746
2747   /**
2748    * DOCUMENT ME!
2749    *
2750    * @param e
2751    *          DOCUMENT ME!
2752    */
2753   @Override
2754   protected void seqLimit_actionPerformed(ActionEvent e)
2755   {
2756     viewport.setShowJVSuffix(seqLimits.isSelected());
2757
2758     alignPanel.getIdPanel().getIdCanvas().setPreferredSize(alignPanel
2759             .calculateIdWidth());
2760     alignPanel.paintAlignment(true);
2761   }
2762
2763   @Override
2764   public void idRightAlign_actionPerformed(ActionEvent e)
2765   {
2766     viewport.setRightAlignIds(idRightAlign.isSelected());
2767     alignPanel.paintAlignment(true);
2768   }
2769
2770   @Override
2771   public void centreColumnLabels_actionPerformed(ActionEvent e)
2772   {
2773     viewport.centreColumnLabels = centreColumnLabelsMenuItem.getState();
2774     alignPanel.paintAlignment(true);
2775   }
2776
2777   /*
2778    * (non-Javadoc)
2779    *
2780    * @see jalview.jbgui.GAlignFrame#followHighlight_actionPerformed()
2781    */
2782   @Override
2783   protected void followHighlight_actionPerformed()
2784   {
2785     if (viewport.followHighlight = this.followHighlightMenuItem.getState())
2786     {
2787       alignPanel.scrollToPosition(
2788               alignPanel.getSeqPanel().seqCanvas.searchResults, false);
2789     }
2790   }
2791
2792   /**
2793    * DOCUMENT ME!
2794    *
2795    * @param e
2796    *          DOCUMENT ME!
2797    */
2798   @Override
2799   protected void colourTextMenuItem_actionPerformed(ActionEvent e)
2800   {
2801     viewport.setColourText(colourTextMenuItem.isSelected());
2802     alignPanel.paintAlignment(true);
2803   }
2804
2805   /**
2806    * DOCUMENT ME!
2807    *
2808    * @param e
2809    *          DOCUMENT ME!
2810    */
2811   @Override
2812   public void wrapMenuItem_actionPerformed(ActionEvent e)
2813   {
2814     scaleAbove.setVisible(wrapMenuItem.isSelected());
2815     scaleLeft.setVisible(wrapMenuItem.isSelected());
2816     scaleRight.setVisible(wrapMenuItem.isSelected());
2817     viewport.setWrapAlignment(wrapMenuItem.isSelected());
2818     alignPanel.setWrapAlignment(wrapMenuItem.isSelected());
2819   }
2820
2821   @Override
2822   public void showAllSeqs_actionPerformed(ActionEvent e)
2823   {
2824     viewport.showAllHiddenSeqs();
2825   }
2826
2827   @Override
2828   public void showAllColumns_actionPerformed(ActionEvent e)
2829   {
2830     viewport.showAllHiddenColumns();
2831     repaint();
2832   }
2833
2834   @Override
2835   public void hideSelSequences_actionPerformed(ActionEvent e)
2836   {
2837     viewport.hideAllSelectedSeqs();
2838     alignPanel.paintAlignment(true);
2839   }
2840
2841   /**
2842    * called by key handler and the hide all/show all menu items
2843    *
2844    * @param toggleSeqs
2845    * @param toggleCols
2846    */
2847   private void toggleHiddenRegions(boolean toggleSeqs, boolean toggleCols)
2848   {
2849
2850     boolean hide = false;
2851     SequenceGroup sg = viewport.getSelectionGroup();
2852     if (!toggleSeqs && !toggleCols)
2853     {
2854       // Hide everything by the current selection - this is a hack - we do the
2855       // invert and then hide
2856       // first check that there will be visible columns after the invert.
2857       if ((viewport.getColumnSelection() != null
2858               && viewport.getColumnSelection().getSelected() != null && viewport
2859               .getColumnSelection().getSelected().size() > 0)
2860               || (sg != null && sg.getSize() > 0 && sg.getStartRes() <= sg
2861                       .getEndRes()))
2862       {
2863         // now invert the sequence set, if required - empty selection implies
2864         // that no hiding is required.
2865         if (sg != null)
2866         {
2867           invertSequenceMenuItem_actionPerformed(null);
2868           sg = viewport.getSelectionGroup();
2869           toggleSeqs = true;
2870
2871         }
2872         viewport.expandColSelection(sg, true);
2873         // finally invert the column selection and get the new sequence
2874         // selection.
2875         invertColSel_actionPerformed(null);
2876         toggleCols = true;
2877       }
2878     }
2879
2880     if (toggleSeqs)
2881     {
2882       if (sg != null && sg.getSize() != viewport.getAlignment().getHeight())
2883       {
2884         hideSelSequences_actionPerformed(null);
2885         hide = true;
2886       }
2887       else if (!(toggleCols && viewport.getColumnSelection().getSelected()
2888               .size() > 0))
2889       {
2890         showAllSeqs_actionPerformed(null);
2891       }
2892     }
2893
2894     if (toggleCols)
2895     {
2896       if (viewport.getColumnSelection().getSelected().size() > 0)
2897       {
2898         hideSelColumns_actionPerformed(null);
2899         if (!toggleSeqs)
2900         {
2901           viewport.setSelectionGroup(sg);
2902         }
2903       }
2904       else if (!hide)
2905       {
2906         showAllColumns_actionPerformed(null);
2907       }
2908     }
2909   }
2910
2911   /*
2912    * (non-Javadoc)
2913    *
2914    * @see
2915    * jalview.jbgui.GAlignFrame#hideAllButSelection_actionPerformed(java.awt.
2916    * event.ActionEvent)
2917    */
2918   @Override
2919   public void hideAllButSelection_actionPerformed(ActionEvent e)
2920   {
2921     toggleHiddenRegions(false, false);
2922   }
2923
2924   /*
2925    * (non-Javadoc)
2926    *
2927    * @see
2928    * jalview.jbgui.GAlignFrame#hideAllSelection_actionPerformed(java.awt.event
2929    * .ActionEvent)
2930    */
2931   @Override
2932   public void hideAllSelection_actionPerformed(ActionEvent e)
2933   {
2934     SequenceGroup sg = viewport.getSelectionGroup();
2935     viewport.expandColSelection(sg, false);
2936     viewport.hideAllSelectedSeqs();
2937     viewport.hideSelectedColumns();
2938     alignPanel.paintAlignment(true);
2939   }
2940
2941   /*
2942    * (non-Javadoc)
2943    *
2944    * @see
2945    * jalview.jbgui.GAlignFrame#showAllhidden_actionPerformed(java.awt.event.
2946    * ActionEvent)
2947    */
2948   @Override
2949   public void showAllhidden_actionPerformed(ActionEvent e)
2950   {
2951     viewport.showAllHiddenColumns();
2952     viewport.showAllHiddenSeqs();
2953     alignPanel.paintAlignment(true);
2954   }
2955
2956   @Override
2957   public void hideSelColumns_actionPerformed(ActionEvent e)
2958   {
2959     viewport.hideSelectedColumns();
2960     alignPanel.paintAlignment(true);
2961   }
2962
2963   @Override
2964   public void hiddenMarkers_actionPerformed(ActionEvent e)
2965   {
2966     viewport.setShowHiddenMarkers(hiddenMarkers.isSelected());
2967     repaint();
2968   }
2969
2970   /**
2971    * DOCUMENT ME!
2972    *
2973    * @param e
2974    *          DOCUMENT ME!
2975    */
2976   @Override
2977   protected void scaleAbove_actionPerformed(ActionEvent e)
2978   {
2979     viewport.setScaleAboveWrapped(scaleAbove.isSelected());
2980     alignPanel.paintAlignment(true);
2981   }
2982
2983   /**
2984    * DOCUMENT ME!
2985    *
2986    * @param e
2987    *          DOCUMENT ME!
2988    */
2989   @Override
2990   protected void scaleLeft_actionPerformed(ActionEvent e)
2991   {
2992     viewport.setScaleLeftWrapped(scaleLeft.isSelected());
2993     alignPanel.paintAlignment(true);
2994   }
2995
2996   /**
2997    * DOCUMENT ME!
2998    *
2999    * @param e
3000    *          DOCUMENT ME!
3001    */
3002   @Override
3003   protected void scaleRight_actionPerformed(ActionEvent e)
3004   {
3005     viewport.setScaleRightWrapped(scaleRight.isSelected());
3006     alignPanel.paintAlignment(true);
3007   }
3008
3009   /**
3010    * DOCUMENT ME!
3011    *
3012    * @param e
3013    *          DOCUMENT ME!
3014    */
3015   @Override
3016   public void viewBoxesMenuItem_actionPerformed(ActionEvent e)
3017   {
3018     viewport.setShowBoxes(viewBoxesMenuItem.isSelected());
3019     alignPanel.paintAlignment(true);
3020   }
3021
3022   /**
3023    * DOCUMENT ME!
3024    *
3025    * @param e
3026    *          DOCUMENT ME!
3027    */
3028   @Override
3029   public void viewTextMenuItem_actionPerformed(ActionEvent e)
3030   {
3031     viewport.setShowText(viewTextMenuItem.isSelected());
3032     alignPanel.paintAlignment(true);
3033   }
3034
3035   /**
3036    * DOCUMENT ME!
3037    *
3038    * @param e
3039    *          DOCUMENT ME!
3040    */
3041   @Override
3042   protected void renderGapsMenuItem_actionPerformed(ActionEvent e)
3043   {
3044     viewport.setRenderGaps(renderGapsMenuItem.isSelected());
3045     alignPanel.paintAlignment(true);
3046   }
3047
3048   public FeatureSettings featureSettings;
3049
3050   @Override
3051   public void featureSettings_actionPerformed(ActionEvent e)
3052   {
3053     if (featureSettings != null)
3054     {
3055       featureSettings.close();
3056       featureSettings = null;
3057     }
3058     if (!showSeqFeatures.isSelected())
3059     {
3060       // make sure features are actually displayed
3061       showSeqFeatures.setSelected(true);
3062       showSeqFeatures_actionPerformed(null);
3063     }
3064     featureSettings = new FeatureSettings(this);
3065   }
3066
3067   /**
3068    * Set or clear 'Show Sequence Features'
3069    *
3070    * @param evt
3071    *          DOCUMENT ME!
3072    */
3073   @Override
3074   public void showSeqFeatures_actionPerformed(ActionEvent evt)
3075   {
3076     viewport.setShowSequenceFeatures(showSeqFeatures.isSelected());
3077     alignPanel.paintAlignment(true);
3078     if (alignPanel.getOverviewPanel() != null)
3079     {
3080       alignPanel.getOverviewPanel().updateOverviewImage();
3081     }
3082   }
3083
3084   /**
3085    * Set or clear 'Show Sequence Features'
3086    *
3087    * @param evt
3088    *          DOCUMENT ME!
3089    */
3090   @Override
3091   public void showSeqFeaturesHeight_actionPerformed(ActionEvent evt)
3092   {
3093     viewport.setShowSequenceFeaturesHeight(showSeqFeaturesHeight
3094             .isSelected());
3095     if (viewport.isShowSequenceFeaturesHeight())
3096     {
3097       // ensure we're actually displaying features
3098       viewport.setShowSequenceFeatures(true);
3099       showSeqFeatures.setSelected(true);
3100     }
3101     alignPanel.paintAlignment(true);
3102     if (alignPanel.getOverviewPanel() != null)
3103     {
3104       alignPanel.getOverviewPanel().updateOverviewImage();
3105     }
3106   }
3107
3108   /**
3109    * Action on toggle of the 'Show annotations' menu item. This shows or hides
3110    * the annotations panel as a whole.
3111    *
3112    * The options to show/hide all annotations should be enabled when the panel
3113    * is shown, and disabled when the panel is hidden.
3114    *
3115    * @param e
3116    */
3117   @Override
3118   public void annotationPanelMenuItem_actionPerformed(ActionEvent e)
3119   {
3120     final boolean setVisible = annotationPanelMenuItem.isSelected();
3121     viewport.setShowAnnotation(setVisible);
3122     alignPanel.setAnnotationVisible(setVisible);
3123     this.showAllSeqAnnotations.setEnabled(setVisible);
3124     this.hideAllSeqAnnotations.setEnabled(setVisible);
3125     this.showAllAlAnnotations.setEnabled(setVisible);
3126     this.hideAllAlAnnotations.setEnabled(setVisible);
3127   }
3128
3129   @Override
3130   public void alignmentProperties()
3131   {
3132     JEditorPane editPane = new JEditorPane("text/html", "");
3133     editPane.setEditable(false);
3134     StringBuffer contents = new AlignmentProperties(viewport.getAlignment())
3135             .formatAsHtml();
3136     editPane.setText(MessageManager.formatMessage("label.html_content",
3137             new String[]
3138             { contents.toString() }));
3139     JInternalFrame frame = new JInternalFrame();
3140     frame.getContentPane().add(new JScrollPane(editPane));
3141
3142     Desktop.instance.addInternalFrame(frame, MessageManager.formatMessage(
3143             "label.alignment_properties", new String[]
3144             { getTitle() }), 500, 400);
3145   }
3146
3147   /**
3148    * DOCUMENT ME!
3149    *
3150    * @param e
3151    *          DOCUMENT ME!
3152    */
3153   @Override
3154   public void overviewMenuItem_actionPerformed(ActionEvent e)
3155   {
3156     if (alignPanel.overviewPanel != null)
3157     {
3158       return;
3159     }
3160
3161     JInternalFrame frame = new JInternalFrame();
3162     OverviewPanel overview = new OverviewPanel(alignPanel);
3163     frame.setContentPane(overview);
3164     Desktop.addInternalFrame(frame, MessageManager.formatMessage(
3165             "label.overview_params", new String[]
3166             { this.getTitle() }), frame.getWidth(), frame.getHeight());
3167     frame.pack();
3168     frame.setLayer(JLayeredPane.PALETTE_LAYER);
3169     frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
3170     {
3171       @Override
3172       public void internalFrameClosed(
3173               javax.swing.event.InternalFrameEvent evt)
3174       {
3175         alignPanel.setOverviewPanel(null);
3176       };
3177     });
3178
3179     alignPanel.setOverviewPanel(overview);
3180   }
3181
3182   @Override
3183   public void textColour_actionPerformed(ActionEvent e)
3184   {
3185     new TextColourChooser().chooseColour(alignPanel, null);
3186   }
3187
3188   /**
3189    * DOCUMENT ME!
3190    *
3191    * @param e
3192    *          DOCUMENT ME!
3193    */
3194   @Override
3195   protected void noColourmenuItem_actionPerformed(ActionEvent e)
3196   {
3197     changeColour(null);
3198   }
3199
3200   /**
3201    * DOCUMENT ME!
3202    *
3203    * @param e
3204    *          DOCUMENT ME!
3205    */
3206   @Override
3207   public void clustalColour_actionPerformed(ActionEvent e)
3208   {
3209     changeColour(new ClustalxColourScheme(viewport.getAlignment(),
3210             viewport.getHiddenRepSequences()));
3211   }
3212
3213   /**
3214    * DOCUMENT ME!
3215    *
3216    * @param e
3217    *          DOCUMENT ME!
3218    */
3219   @Override
3220   public void zappoColour_actionPerformed(ActionEvent e)
3221   {
3222     changeColour(new ZappoColourScheme());
3223   }
3224
3225   /**
3226    * DOCUMENT ME!
3227    *
3228    * @param e
3229    *          DOCUMENT ME!
3230    */
3231   @Override
3232   public void taylorColour_actionPerformed(ActionEvent e)
3233   {
3234     changeColour(new TaylorColourScheme());
3235   }
3236
3237   /**
3238    * DOCUMENT ME!
3239    *
3240    * @param e
3241    *          DOCUMENT ME!
3242    */
3243   @Override
3244   public void hydrophobicityColour_actionPerformed(ActionEvent e)
3245   {
3246     changeColour(new HydrophobicColourScheme());
3247   }
3248
3249   /**
3250    * DOCUMENT ME!
3251    *
3252    * @param e
3253    *          DOCUMENT ME!
3254    */
3255   @Override
3256   public void helixColour_actionPerformed(ActionEvent e)
3257   {
3258     changeColour(new HelixColourScheme());
3259   }
3260
3261   /**
3262    * DOCUMENT ME!
3263    *
3264    * @param e
3265    *          DOCUMENT ME!
3266    */
3267   @Override
3268   public void strandColour_actionPerformed(ActionEvent e)
3269   {
3270     changeColour(new StrandColourScheme());
3271   }
3272
3273   /**
3274    * DOCUMENT ME!
3275    *
3276    * @param e
3277    *          DOCUMENT ME!
3278    */
3279   @Override
3280   public void turnColour_actionPerformed(ActionEvent e)
3281   {
3282     changeColour(new TurnColourScheme());
3283   }
3284
3285   /**
3286    * DOCUMENT ME!
3287    *
3288    * @param e
3289    *          DOCUMENT ME!
3290    */
3291   @Override
3292   public void buriedColour_actionPerformed(ActionEvent e)
3293   {
3294     changeColour(new BuriedColourScheme());
3295   }
3296
3297   /**
3298    * DOCUMENT ME!
3299    *
3300    * @param e
3301    *          DOCUMENT ME!
3302    */
3303   @Override
3304   public void nucleotideColour_actionPerformed(ActionEvent e)
3305   {
3306     changeColour(new NucleotideColourScheme());
3307   }
3308
3309   @Override
3310   public void purinePyrimidineColour_actionPerformed(ActionEvent e)
3311   {
3312     changeColour(new PurinePyrimidineColourScheme());
3313   }
3314
3315   /*
3316    * public void covariationColour_actionPerformed(ActionEvent e) {
3317    * changeColour(new
3318    * CovariationColourScheme(viewport.getAlignment().getAlignmentAnnotation
3319    * ()[0])); }
3320    */
3321   @Override
3322   public void annotationColour_actionPerformed(ActionEvent e)
3323   {
3324     new AnnotationColourChooser(viewport, alignPanel);
3325   }
3326
3327   @Override
3328   public void rnahelicesColour_actionPerformed(ActionEvent e)
3329   {
3330     new RNAHelicesColourChooser(viewport, alignPanel);
3331   }
3332
3333   /**
3334    * DOCUMENT ME!
3335    *
3336    * @param e
3337    *          DOCUMENT ME!
3338    */
3339   @Override
3340   protected void applyToAllGroups_actionPerformed(ActionEvent e)
3341   {
3342     viewport.setColourAppliesToAllGroups(applyToAllGroups.isSelected());
3343   }
3344
3345   /**
3346    * DOCUMENT ME!
3347    *
3348    * @param cs
3349    *          DOCUMENT ME!
3350    */
3351   public void changeColour(ColourSchemeI cs)
3352   {
3353     // TODO: compare with applet and pull up to model method
3354     int threshold = 0;
3355
3356     if (cs != null)
3357     {
3358       if (viewport.getAbovePIDThreshold())
3359       {
3360         threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,
3361                 "Background");
3362         cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
3363       }
3364       else
3365       {
3366         cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
3367       }
3368
3369       if (viewport.getConservationSelected())
3370       {
3371
3372         Alignment al = (Alignment) viewport.getAlignment();
3373         Conservation c = new Conservation("All",
3374                 ResidueProperties.propHash, 3, al.getSequences(), 0,
3375                 al.getWidth() - 1);
3376
3377         c.calculate();
3378         c.verdict(false, viewport.getConsPercGaps());
3379
3380         cs.setConservation(c);
3381
3382         cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel,
3383                 cs, "Background"));
3384       }
3385       else
3386       {
3387         cs.setConservation(null);
3388       }
3389
3390       cs.setConsensus(viewport.getSequenceConsensusHash());
3391     }
3392
3393     viewport.setGlobalColourScheme(cs);
3394
3395     if (viewport.getColourAppliesToAllGroups())
3396     {
3397
3398       for (SequenceGroup sg : viewport.getAlignment().getGroups())
3399       {
3400         if (cs == null)
3401         {
3402           sg.cs = null;
3403           continue;
3404         }
3405
3406         if (cs instanceof ClustalxColourScheme)
3407         {
3408           sg.cs = new ClustalxColourScheme(sg,
3409                   viewport.getHiddenRepSequences());
3410         }
3411         else if (cs instanceof UserColourScheme)
3412         {
3413           sg.cs = new UserColourScheme(((UserColourScheme) cs).getColours());
3414         }
3415         else
3416         {
3417           try
3418           {
3419             sg.cs = cs.getClass().newInstance();
3420           } catch (Exception ex)
3421           {
3422           }
3423         }
3424
3425         if (viewport.getAbovePIDThreshold()
3426                 || cs instanceof PIDColourScheme
3427                 || cs instanceof Blosum62ColourScheme)
3428         {
3429           sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
3430
3431           sg.cs.setConsensus(AAFrequency.calculate(
3432                   sg.getSequences(viewport.getHiddenRepSequences()),
3433                   sg.getStartRes(), sg.getEndRes() + 1));
3434         }
3435         else
3436         {
3437           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
3438         }
3439
3440         if (viewport.getConservationSelected())
3441         {
3442           Conservation c = new Conservation("Group",
3443                   ResidueProperties.propHash, 3, sg.getSequences(viewport
3444                           .getHiddenRepSequences()), sg.getStartRes(),
3445                   sg.getEndRes() + 1);
3446           c.calculate();
3447           c.verdict(false, viewport.getConsPercGaps());
3448           sg.cs.setConservation(c);
3449         }
3450         else
3451         {
3452           sg.cs.setConservation(null);
3453         }
3454       }
3455     }
3456
3457     if (alignPanel.getOverviewPanel() != null)
3458     {
3459       alignPanel.getOverviewPanel().updateOverviewImage();
3460     }
3461
3462     alignPanel.paintAlignment(true);
3463   }
3464
3465   /**
3466    * DOCUMENT ME!
3467    *
3468    * @param e
3469    *          DOCUMENT ME!
3470    */
3471   @Override
3472   protected void modifyPID_actionPerformed(ActionEvent e)
3473   {
3474     if (viewport.getAbovePIDThreshold()
3475             && viewport.getGlobalColourScheme() != null)
3476     {
3477       SliderPanel.setPIDSliderSource(alignPanel,
3478               viewport.getGlobalColourScheme(), "Background");
3479       SliderPanel.showPIDSlider();
3480     }
3481   }
3482
3483   /**
3484    * DOCUMENT ME!
3485    *
3486    * @param e
3487    *          DOCUMENT ME!
3488    */
3489   @Override
3490   protected void modifyConservation_actionPerformed(ActionEvent e)
3491   {
3492     if (viewport.getConservationSelected()
3493             && viewport.getGlobalColourScheme() != null)
3494     {
3495       SliderPanel.setConservationSlider(alignPanel,
3496               viewport.getGlobalColourScheme(), "Background");
3497       SliderPanel.showConservationSlider();
3498     }
3499   }
3500
3501   /**
3502    * DOCUMENT ME!
3503    *
3504    * @param e
3505    *          DOCUMENT ME!
3506    */
3507   @Override
3508   protected void conservationMenuItem_actionPerformed(ActionEvent e)
3509   {
3510     viewport.setConservationSelected(conservationMenuItem.isSelected());
3511
3512     viewport.setAbovePIDThreshold(false);
3513     abovePIDThreshold.setSelected(false);
3514
3515     changeColour(viewport.getGlobalColourScheme());
3516
3517     modifyConservation_actionPerformed(null);
3518   }
3519
3520   /**
3521    * DOCUMENT ME!
3522    *
3523    * @param e
3524    *          DOCUMENT ME!
3525    */
3526   @Override
3527   public void abovePIDThreshold_actionPerformed(ActionEvent e)
3528   {
3529     viewport.setAbovePIDThreshold(abovePIDThreshold.isSelected());
3530
3531     conservationMenuItem.setSelected(false);
3532     viewport.setConservationSelected(false);
3533
3534     changeColour(viewport.getGlobalColourScheme());
3535
3536     modifyPID_actionPerformed(null);
3537   }
3538
3539   /**
3540    * DOCUMENT ME!
3541    *
3542    * @param e
3543    *          DOCUMENT ME!
3544    */
3545   @Override
3546   public void userDefinedColour_actionPerformed(ActionEvent e)
3547   {
3548     if (e.getActionCommand().equals(
3549             MessageManager.getString("action.user_defined")))
3550     {
3551       new UserDefinedColours(alignPanel, null);
3552     }
3553     else
3554     {
3555       UserColourScheme udc = (UserColourScheme) UserDefinedColours
3556               .getUserColourSchemes().get(e.getActionCommand());
3557
3558       changeColour(udc);
3559     }
3560   }
3561
3562   public void updateUserColourMenu()
3563   {
3564
3565     Component[] menuItems = colourMenu.getMenuComponents();
3566     int i, iSize = menuItems.length;
3567     for (i = 0; i < iSize; i++)
3568     {
3569       if (menuItems[i].getName() != null
3570               && menuItems[i].getName().equals("USER_DEFINED"))
3571       {
3572         colourMenu.remove(menuItems[i]);
3573         iSize--;
3574       }
3575     }
3576     if (jalview.gui.UserDefinedColours.getUserColourSchemes() != null)
3577     {
3578       java.util.Enumeration userColours = jalview.gui.UserDefinedColours
3579               .getUserColourSchemes().keys();
3580
3581       while (userColours.hasMoreElements())
3582       {
3583         final JRadioButtonMenuItem radioItem = new JRadioButtonMenuItem(
3584                 userColours.nextElement().toString());
3585         radioItem.setName("USER_DEFINED");
3586         radioItem.addMouseListener(new MouseAdapter()
3587         {
3588           @Override
3589           public void mousePressed(MouseEvent evt)
3590           {
3591             if (evt.isControlDown()
3592                     || SwingUtilities.isRightMouseButton(evt))
3593             {
3594               radioItem.removeActionListener(radioItem.getActionListeners()[0]);
3595
3596               int option = JOptionPane.showInternalConfirmDialog(
3597                       jalview.gui.Desktop.desktop,
3598                       MessageManager
3599                               .getString("label.remove_from_default_list"),
3600                       MessageManager
3601                               .getString("label.remove_user_defined_colour"),
3602                       JOptionPane.YES_NO_OPTION);
3603               if (option == JOptionPane.YES_OPTION)
3604               {
3605                 jalview.gui.UserDefinedColours
3606                         .removeColourFromDefaults(radioItem.getText());
3607                 colourMenu.remove(radioItem);
3608               }
3609               else
3610               {
3611                 radioItem.addActionListener(new ActionListener()
3612                 {
3613                   @Override
3614                   public void actionPerformed(ActionEvent evt)
3615                   {
3616                     userDefinedColour_actionPerformed(evt);
3617                   }
3618                 });
3619               }
3620             }
3621           }
3622         });
3623         radioItem.addActionListener(new ActionListener()
3624         {
3625           @Override
3626           public void actionPerformed(ActionEvent evt)
3627           {
3628             userDefinedColour_actionPerformed(evt);
3629           }
3630         });
3631
3632         colourMenu.insert(radioItem, 15);
3633         colours.add(radioItem);
3634       }
3635     }
3636   }
3637
3638   /**
3639    * DOCUMENT ME!
3640    *
3641    * @param e
3642    *          DOCUMENT ME!
3643    */
3644   @Override
3645   public void PIDColour_actionPerformed(ActionEvent e)
3646   {
3647     changeColour(new PIDColourScheme());
3648   }
3649
3650   /**
3651    * DOCUMENT ME!
3652    *
3653    * @param e
3654    *          DOCUMENT ME!
3655    */
3656   @Override
3657   public void BLOSUM62Colour_actionPerformed(ActionEvent e)
3658   {
3659     changeColour(new Blosum62ColourScheme());
3660   }
3661
3662   /**
3663    * DOCUMENT ME!
3664    *
3665    * @param e
3666    *          DOCUMENT ME!
3667    */
3668   @Override
3669   public void sortPairwiseMenuItem_actionPerformed(ActionEvent e)
3670   {
3671     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3672     AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
3673             .getAlignment().getSequenceAt(0), null);
3674     addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
3675             viewport.getAlignment()));
3676     alignPanel.paintAlignment(true);
3677   }
3678
3679   /**
3680    * DOCUMENT ME!
3681    *
3682    * @param e
3683    *          DOCUMENT ME!
3684    */
3685   @Override
3686   public void sortIDMenuItem_actionPerformed(ActionEvent e)
3687   {
3688     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3689     AlignmentSorter.sortByID(viewport.getAlignment());
3690     addHistoryItem(new OrderCommand("ID Sort", oldOrder,
3691             viewport.getAlignment()));
3692     alignPanel.paintAlignment(true);
3693   }
3694
3695   /**
3696    * DOCUMENT ME!
3697    *
3698    * @param e
3699    *          DOCUMENT ME!
3700    */
3701   @Override
3702   public void sortLengthMenuItem_actionPerformed(ActionEvent e)
3703   {
3704     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3705     AlignmentSorter.sortByLength(viewport.getAlignment());
3706     addHistoryItem(new OrderCommand("Length Sort", oldOrder,
3707             viewport.getAlignment()));
3708     alignPanel.paintAlignment(true);
3709   }
3710
3711   /**
3712    * DOCUMENT ME!
3713    *
3714    * @param e
3715    *          DOCUMENT ME!
3716    */
3717   @Override
3718   public void sortGroupMenuItem_actionPerformed(ActionEvent e)
3719   {
3720     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3721     AlignmentSorter.sortByGroup(viewport.getAlignment());
3722     addHistoryItem(new OrderCommand("Group Sort", oldOrder,
3723             viewport.getAlignment()));
3724
3725     alignPanel.paintAlignment(true);
3726   }
3727
3728   /**
3729    * DOCUMENT ME!
3730    *
3731    * @param e
3732    *          DOCUMENT ME!
3733    */
3734   @Override
3735   public void removeRedundancyMenuItem_actionPerformed(ActionEvent e)
3736   {
3737     new RedundancyPanel(alignPanel, this);
3738   }
3739
3740   /**
3741    * DOCUMENT ME!
3742    *
3743    * @param e
3744    *          DOCUMENT ME!
3745    */
3746   @Override
3747   public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e)
3748   {
3749     if ((viewport.getSelectionGroup() == null)
3750             || (viewport.getSelectionGroup().getSize() < 2))
3751     {
3752       JOptionPane.showInternalMessageDialog(this, MessageManager
3753               .getString("label.you_must_select_least_two_sequences"),
3754               MessageManager.getString("label.invalid_selection"),
3755               JOptionPane.WARNING_MESSAGE);
3756     }
3757     else
3758     {
3759       JInternalFrame frame = new JInternalFrame();
3760       frame.setContentPane(new PairwiseAlignPanel(viewport));
3761       Desktop.addInternalFrame(frame,
3762               MessageManager.getString("action.pairwise_alignment"), 600,
3763               500);
3764     }
3765   }
3766
3767   /**
3768    * DOCUMENT ME!
3769    *
3770    * @param e
3771    *          DOCUMENT ME!
3772    */
3773   @Override
3774   public void PCAMenuItem_actionPerformed(ActionEvent e)
3775   {
3776     if (((viewport.getSelectionGroup() != null)
3777             && (viewport.getSelectionGroup().getSize() < 4) && (viewport
3778             .getSelectionGroup().getSize() > 0))
3779             || (viewport.getAlignment().getHeight() < 4))
3780     {
3781       JOptionPane
3782               .showInternalMessageDialog(
3783                       this,
3784                       MessageManager
3785                               .getString("label.principal_component_analysis_must_take_least_four_input_sequences"),
3786                       MessageManager
3787                               .getString("label.sequence_selection_insufficient"),
3788                       JOptionPane.WARNING_MESSAGE);
3789
3790       return;
3791     }
3792
3793     new PCAPanel(alignPanel);
3794   }
3795
3796   @Override
3797   public void autoCalculate_actionPerformed(ActionEvent e)
3798   {
3799     viewport.autoCalculateConsensus = autoCalculate.isSelected();
3800     if (viewport.autoCalculateConsensus)
3801     {
3802       viewport.firePropertyChange("alignment", null, viewport
3803               .getAlignment().getSequences());
3804     }
3805   }
3806
3807   @Override
3808   public void sortByTreeOption_actionPerformed(ActionEvent e)
3809   {
3810     viewport.sortByTree = sortByTree.isSelected();
3811   }
3812
3813   @Override
3814   protected void listenToViewSelections_actionPerformed(ActionEvent e)
3815   {
3816     viewport.followSelection = listenToViewSelections.isSelected();
3817   }
3818
3819   /**
3820    * DOCUMENT ME!
3821    *
3822    * @param e
3823    *          DOCUMENT ME!
3824    */
3825   @Override
3826   public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e)
3827   {
3828     NewTreePanel("AV", "PID", "Average distance tree using PID");
3829   }
3830
3831   /**
3832    * DOCUMENT ME!
3833    *
3834    * @param e
3835    *          DOCUMENT ME!
3836    */
3837   @Override
3838   public void neighbourTreeMenuItem_actionPerformed(ActionEvent e)
3839   {
3840     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
3841   }
3842
3843   /**
3844    * DOCUMENT ME!
3845    *
3846    * @param e
3847    *          DOCUMENT ME!
3848    */
3849   @Override
3850   protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e)
3851   {
3852     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
3853   }
3854
3855   /**
3856    * DOCUMENT ME!
3857    *
3858    * @param e
3859    *          DOCUMENT ME!
3860    */
3861   @Override
3862   protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e)
3863   {
3864     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");
3865   }
3866
3867   /**
3868    * DOCUMENT ME!
3869    *
3870    * @param type
3871    *          DOCUMENT ME!
3872    * @param pwType
3873    *          DOCUMENT ME!
3874    * @param title
3875    *          DOCUMENT ME!
3876    */
3877   void NewTreePanel(String type, String pwType, String title)
3878   {
3879     TreePanel tp;
3880
3881     if (viewport.getSelectionGroup() != null
3882             && viewport.getSelectionGroup().getSize() > 0)
3883     {
3884       if (viewport.getSelectionGroup().getSize() < 3)
3885       {
3886         JOptionPane
3887                 .showMessageDialog(
3888                         Desktop.desktop,
3889                         MessageManager
3890                                 .getString("label.you_need_more_two_sequences_selected_build_tree"),
3891                         MessageManager
3892                                 .getString("label.not_enough_sequences"),
3893                         JOptionPane.WARNING_MESSAGE);
3894         return;
3895       }
3896
3897       SequenceGroup sg = viewport.getSelectionGroup();
3898
3899       /* Decide if the selection is a column region */
3900       for (SequenceI _s : sg.getSequences())
3901       {
3902         if (_s.getLength() < sg.getEndRes())
3903         {
3904           JOptionPane
3905                   .showMessageDialog(
3906                           Desktop.desktop,
3907                           MessageManager
3908                                   .getString("label.selected_region_to_tree_may_only_contain_residues_or_gaps"),
3909                           MessageManager
3910                                   .getString("label.sequences_selection_not_aligned"),
3911                           JOptionPane.WARNING_MESSAGE);
3912
3913           return;
3914         }
3915       }
3916
3917       title = title + " on region";
3918       tp = new TreePanel(alignPanel, type, pwType);
3919     }
3920     else
3921     {
3922       // are the visible sequences aligned?
3923       if (!viewport.getAlignment().isAligned(false))
3924       {
3925         JOptionPane
3926                 .showMessageDialog(
3927                         Desktop.desktop,
3928                         MessageManager
3929                                 .getString("label.sequences_must_be_aligned_before_creating_tree"),
3930                         MessageManager
3931                                 .getString("label.sequences_not_aligned"),
3932                         JOptionPane.WARNING_MESSAGE);
3933
3934         return;
3935       }
3936
3937       if (viewport.getAlignment().getHeight() < 2)
3938       {
3939         return;
3940       }
3941
3942       tp = new TreePanel(alignPanel, type, pwType);
3943     }
3944
3945     title += " from ";
3946
3947     if (viewport.viewName != null)
3948     {
3949       title += viewport.viewName + " of ";
3950     }
3951
3952     title += this.title;
3953
3954     Desktop.addInternalFrame(tp, title, 600, 500);
3955   }
3956
3957   /**
3958    * DOCUMENT ME!
3959    *
3960    * @param title
3961    *          DOCUMENT ME!
3962    * @param order
3963    *          DOCUMENT ME!
3964    */
3965   public void addSortByOrderMenuItem(String title,
3966           final AlignmentOrder order)
3967   {
3968     final JMenuItem item = new JMenuItem(MessageManager.formatMessage("action.by_title_param", new String[]{title}));
3969     sort.add(item);
3970     item.addActionListener(new java.awt.event.ActionListener()
3971     {
3972       @Override
3973       public void actionPerformed(ActionEvent e)
3974       {
3975         SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3976
3977         // TODO: JBPNote - have to map order entries to curent SequenceI
3978         // pointers
3979         AlignmentSorter.sortBy(viewport.getAlignment(), order);
3980
3981         addHistoryItem(new OrderCommand(order.getName(), oldOrder, viewport
3982                 .getAlignment()));
3983
3984         alignPanel.paintAlignment(true);
3985       }
3986     });
3987   }
3988
3989   /**
3990    * Add a new sort by annotation score menu item
3991    *
3992    * @param sort
3993    *          the menu to add the option to
3994    * @param scoreLabel
3995    *          the label used to retrieve scores for each sequence on the
3996    *          alignment
3997    */
3998   public void addSortByAnnotScoreMenuItem(JMenu sort,
3999           final String scoreLabel)
4000   {
4001     final JMenuItem item = new JMenuItem(scoreLabel);
4002     sort.add(item);
4003     item.addActionListener(new java.awt.event.ActionListener()
4004     {
4005       @Override
4006       public void actionPerformed(ActionEvent e)
4007       {
4008         SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
4009         AlignmentSorter.sortByAnnotationScore(scoreLabel,
4010                 viewport.getAlignment());// ,viewport.getSelectionGroup());
4011         addHistoryItem(new OrderCommand("Sort by " + scoreLabel, oldOrder,
4012                 viewport.getAlignment()));
4013         alignPanel.paintAlignment(true);
4014       }
4015     });
4016   }
4017
4018   /**
4019    * last hash for alignment's annotation array - used to minimise cost of
4020    * rebuild.
4021    */
4022   protected int _annotationScoreVectorHash;
4023
4024   /**
4025    * search the alignment and rebuild the sort by annotation score submenu the
4026    * last alignment annotation vector hash is stored to minimize cost of
4027    * rebuilding in subsequence calls.
4028    *
4029    */
4030   @Override
4031   public void buildSortByAnnotationScoresMenu()
4032   {
4033     if (viewport.getAlignment().getAlignmentAnnotation() == null)
4034     {
4035       return;
4036     }
4037
4038     if (viewport.getAlignment().getAlignmentAnnotation().hashCode() != _annotationScoreVectorHash)
4039     {
4040       sortByAnnotScore.removeAll();
4041       // almost certainly a quicker way to do this - but we keep it simple
4042       Hashtable scoreSorts = new Hashtable();
4043       AlignmentAnnotation aann[];
4044       for (SequenceI sqa : viewport.getAlignment().getSequences())
4045       {
4046         aann = sqa.getAnnotation();
4047         for (int i = 0; aann != null && i < aann.length; i++)
4048         {
4049           if (aann[i].hasScore() && aann[i].sequenceRef != null)
4050           {
4051             scoreSorts.put(aann[i].label, aann[i].label);
4052           }
4053         }
4054       }
4055       Enumeration labels = scoreSorts.keys();
4056       while (labels.hasMoreElements())
4057       {
4058         addSortByAnnotScoreMenuItem(sortByAnnotScore,
4059                 (String) labels.nextElement());
4060       }
4061       sortByAnnotScore.setVisible(scoreSorts.size() > 0);
4062       scoreSorts.clear();
4063
4064       _annotationScoreVectorHash = viewport.getAlignment()
4065               .getAlignmentAnnotation().hashCode();
4066     }
4067   }
4068
4069   /**
4070    * Maintain the Order by->Displayed Tree menu. Creates a new menu item for a
4071    * TreePanel with an appropriate <code>jalview.analysis.AlignmentSorter</code>
4072    * call. Listeners are added to remove the menu item when the treePanel is
4073    * closed, and adjust the tree leaf to sequence mapping when the alignment is
4074    * modified.
4075    *
4076    * @param treePanel
4077    *          Displayed tree window.
4078    * @param title
4079    *          SortBy menu item title.
4080    */
4081   @Override
4082   public void buildTreeMenu()
4083   {
4084     calculateTree.removeAll();
4085     // build the calculate menu
4086
4087     for (final String type : new String[]
4088     { "NJ", "AV" })
4089     {
4090       String treecalcnm = MessageManager.getString("label.tree_calc_"
4091               + type.toLowerCase());
4092       for (final Object pwtype : ResidueProperties.scoreMatrices.keySet())
4093       {
4094         JMenuItem tm = new JMenuItem();
4095         ScoreModelI sm = ResidueProperties.scoreMatrices.get(pwtype);
4096         if (sm.isProtein() == !viewport.getAlignment().isNucleotide())
4097         {
4098           String smn = MessageManager.getStringOrReturn(
4099                   "label.score_model_", sm.getName());
4100           final String title = MessageManager.formatMessage(
4101                   "label.treecalc_title", treecalcnm, smn);
4102           tm.setText(title);//
4103           tm.addActionListener(new java.awt.event.ActionListener()
4104           {
4105             @Override
4106             public void actionPerformed(ActionEvent e)
4107             {
4108               NewTreePanel(type, (String) pwtype, title);
4109             }
4110           });
4111           calculateTree.add(tm);
4112         }
4113
4114       }
4115     }
4116     sortByTreeMenu.removeAll();
4117
4118     Vector comps = (Vector) PaintRefresher.components.get(viewport
4119             .getSequenceSetId());
4120     Vector treePanels = new Vector();
4121     int i, iSize = comps.size();
4122     for (i = 0; i < iSize; i++)
4123     {
4124       if (comps.elementAt(i) instanceof TreePanel)
4125       {
4126         treePanels.add(comps.elementAt(i));
4127       }
4128     }
4129
4130     iSize = treePanels.size();
4131
4132     if (iSize < 1)
4133     {
4134       sortByTreeMenu.setVisible(false);
4135       return;
4136     }
4137
4138     sortByTreeMenu.setVisible(true);
4139
4140     for (i = 0; i < treePanels.size(); i++)
4141     {
4142       final TreePanel tp = (TreePanel) treePanels.elementAt(i);
4143       final JMenuItem item = new JMenuItem(tp.getTitle());
4144       final NJTree tree = ((TreePanel) treePanels.elementAt(i)).getTree();
4145       item.addActionListener(new java.awt.event.ActionListener()
4146       {
4147         @Override
4148         public void actionPerformed(ActionEvent e)
4149         {
4150           tp.sortByTree_actionPerformed(null);
4151           addHistoryItem(tp.sortAlignmentIn(alignPanel));
4152
4153         }
4154       });
4155
4156       sortByTreeMenu.add(item);
4157     }
4158   }
4159
4160   public boolean sortBy(AlignmentOrder alorder, String undoname)
4161   {
4162     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
4163     AlignmentSorter.sortBy(viewport.getAlignment(), alorder);
4164     if (undoname != null)
4165     {
4166       addHistoryItem(new OrderCommand(undoname, oldOrder,
4167               viewport.getAlignment()));
4168     }
4169     alignPanel.paintAlignment(true);
4170     return true;
4171   }
4172
4173   /**
4174    * Work out whether the whole set of sequences or just the selected set will
4175    * be submitted for multiple alignment.
4176    *
4177    */
4178   public jalview.datamodel.AlignmentView gatherSequencesForAlignment()
4179   {
4180     // Now, check we have enough sequences
4181     AlignmentView msa = null;
4182
4183     if ((viewport.getSelectionGroup() != null)
4184             && (viewport.getSelectionGroup().getSize() > 1))
4185     {
4186       // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to
4187       // some common interface!
4188       /*
4189        * SequenceGroup seqs = viewport.getSelectionGroup(); int sz; msa = new
4190        * SequenceI[sz = seqs.getSize(false)];
4191        *
4192        * for (int i = 0; i < sz; i++) { msa[i] = (SequenceI)
4193        * seqs.getSequenceAt(i); }
4194        */
4195       msa = viewport.getAlignmentView(true);
4196     }
4197     else if (viewport.getSelectionGroup() != null
4198             && viewport.getSelectionGroup().getSize() == 1)
4199     {
4200       int option = JOptionPane.showConfirmDialog(this,
4201               MessageManager.getString("warn.oneseq_msainput_selection"),
4202               MessageManager.getString("label.invalid_selection"),
4203               JOptionPane.OK_CANCEL_OPTION);
4204       if (option == JOptionPane.OK_OPTION)
4205       {
4206         msa = viewport.getAlignmentView(false);
4207       }
4208     }
4209     else
4210     {
4211       msa = viewport.getAlignmentView(false);
4212     }
4213     return msa;
4214   }
4215
4216   /**
4217    * Decides what is submitted to a secondary structure prediction service: the
4218    * first sequence in the alignment, or in the current selection, or, if the
4219    * alignment is 'aligned' (ie padded with gaps), then the currently selected
4220    * region or the whole alignment. (where the first sequence in the set is the
4221    * one that the prediction will be for).
4222    */
4223   public AlignmentView gatherSeqOrMsaForSecStrPrediction()
4224   {
4225     AlignmentView seqs = null;
4226
4227     if ((viewport.getSelectionGroup() != null)
4228             && (viewport.getSelectionGroup().getSize() > 0))
4229     {
4230       seqs = viewport.getAlignmentView(true);
4231     }
4232     else
4233     {
4234       seqs = viewport.getAlignmentView(false);
4235     }
4236     // limit sequences - JBPNote in future - could spawn multiple prediction
4237     // jobs
4238     // TODO: viewport.getAlignment().isAligned is a global state - the local
4239     // selection may well be aligned - we preserve 2.0.8 behaviour for moment.
4240     if (!viewport.getAlignment().isAligned(false))
4241     {
4242       seqs.setSequences(new SeqCigar[]
4243       { seqs.getSequences()[0] });
4244       // TODO: if seqs.getSequences().length>1 then should really have warned
4245       // user!
4246
4247     }
4248     return seqs;
4249   }
4250
4251   /**
4252    * DOCUMENT ME!
4253    *
4254    * @param e
4255    *          DOCUMENT ME!
4256    */
4257   @Override
4258   protected void LoadtreeMenuItem_actionPerformed(ActionEvent e)
4259   {
4260     // Pick the tree file
4261     JalviewFileChooser chooser = new JalviewFileChooser(
4262             jalview.bin.Cache.getProperty("LAST_DIRECTORY"));
4263     chooser.setFileView(new JalviewFileView());
4264     chooser.setDialogTitle(MessageManager
4265             .getString("label.select_newick_like_tree_file"));
4266     chooser.setToolTipText(MessageManager.getString("label.load_tree_file"));
4267
4268     int value = chooser.showOpenDialog(null);
4269
4270     if (value == JalviewFileChooser.APPROVE_OPTION)
4271     {
4272       String choice = chooser.getSelectedFile().getPath();
4273       jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);
4274       jalview.io.NewickFile fin = null;
4275       try
4276       {
4277         fin = new jalview.io.NewickFile(choice, "File");
4278         viewport.setCurrentTree(ShowNewickTree(fin, choice).getTree());
4279       } catch (Exception ex)
4280       {
4281         JOptionPane
4282                 .showMessageDialog(
4283                         Desktop.desktop,
4284                         ex.getMessage(),
4285                         MessageManager
4286                                 .getString("label.problem_reading_tree_file"),
4287                         JOptionPane.WARNING_MESSAGE);
4288         ex.printStackTrace();
4289       }
4290       if (fin != null && fin.hasWarningMessage())
4291       {
4292         JOptionPane.showMessageDialog(Desktop.desktop, fin
4293                 .getWarningMessage(), MessageManager
4294                 .getString("label.possible_problem_with_tree_file"),
4295                 JOptionPane.WARNING_MESSAGE);
4296       }
4297     }
4298   }
4299
4300   @Override
4301   protected void tcoffeeColorScheme_actionPerformed(ActionEvent e)
4302   {
4303     changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
4304   }
4305
4306   public TreePanel ShowNewickTree(NewickFile nf, String title)
4307   {
4308     return ShowNewickTree(nf, title, 600, 500, 4, 5);
4309   }
4310
4311   public TreePanel ShowNewickTree(NewickFile nf, String title,
4312           AlignmentView input)
4313   {
4314     return ShowNewickTree(nf, title, input, 600, 500, 4, 5);
4315   }
4316
4317   public TreePanel ShowNewickTree(NewickFile nf, String title, int w,
4318           int h, int x, int y)
4319   {
4320     return ShowNewickTree(nf, title, null, w, h, x, y);
4321   }
4322
4323   /**
4324    * Add a treeviewer for the tree extracted from a newick file object to the
4325    * current alignment view
4326    *
4327    * @param nf
4328    *          the tree
4329    * @param title
4330    *          tree viewer title
4331    * @param input
4332    *          Associated alignment input data (or null)
4333    * @param w
4334    *          width
4335    * @param h
4336    *          height
4337    * @param x
4338    *          position
4339    * @param y
4340    *          position
4341    * @return TreePanel handle
4342    */
4343   public TreePanel ShowNewickTree(NewickFile nf, String title,
4344           AlignmentView input, int w, int h, int x, int y)
4345   {
4346     TreePanel tp = null;
4347
4348     try
4349     {
4350       nf.parse();
4351
4352       if (nf.getTree() != null)
4353       {
4354         tp = new TreePanel(alignPanel, "FromFile", title, nf, input);
4355
4356         tp.setSize(w, h);
4357
4358         if (x > 0 && y > 0)
4359         {
4360           tp.setLocation(x, y);
4361         }
4362
4363         Desktop.addInternalFrame(tp, title, w, h);
4364       }
4365     } catch (Exception ex)
4366     {
4367       ex.printStackTrace();
4368     }
4369
4370     return tp;
4371   }
4372
4373   private boolean buildingMenu = false;
4374
4375   /**
4376    * Generates menu items and listener event actions for web service clients
4377    *
4378    */
4379   public void BuildWebServiceMenu()
4380   {
4381     while (buildingMenu)
4382     {
4383       try
4384       {
4385         System.err.println("Waiting for building menu to finish.");
4386         Thread.sleep(10);
4387       } catch (Exception e)
4388       {
4389       }
4390       ;
4391     }
4392     final AlignFrame me = this;
4393     buildingMenu = true;
4394     new Thread(new Runnable()
4395     {
4396       @Override
4397       public void run()
4398       {
4399         final List<JMenuItem> legacyItems = new ArrayList<JMenuItem>();
4400         try
4401         {
4402           System.err.println("Building ws menu again "
4403                   + Thread.currentThread());
4404           // TODO: add support for context dependent disabling of services based
4405           // on
4406           // alignment and current selection
4407           // TODO: add additional serviceHandle parameter to specify abstract
4408           // handler
4409           // class independently of AbstractName
4410           // TODO: add in rediscovery GUI function to restart discoverer
4411           // TODO: group services by location as well as function and/or
4412           // introduce
4413           // object broker mechanism.
4414           final Vector<JMenu> wsmenu = new Vector<JMenu>();
4415           final IProgressIndicator af = me;
4416           final JMenu msawsmenu = new JMenu("Alignment");
4417           final JMenu secstrmenu = new JMenu(
4418                   "Secondary Structure Prediction");
4419           final JMenu seqsrchmenu = new JMenu("Sequence Database Search");
4420           final JMenu analymenu = new JMenu("Analysis");
4421           final JMenu dismenu = new JMenu("Protein Disorder");
4422           // final JMenu msawsmenu = new
4423           // JMenu(MessageManager.getString("label.alignment"));
4424           // final JMenu secstrmenu = new
4425           // JMenu(MessageManager.getString("label.secondary_structure_prediction"));
4426           // final JMenu seqsrchmenu = new
4427           // JMenu(MessageManager.getString("label.sequence_database_search"));
4428           // final JMenu analymenu = new
4429           // JMenu(MessageManager.getString("label.analysis"));
4430           // final JMenu dismenu = new
4431           // JMenu(MessageManager.getString("label.protein_disorder"));
4432           // JAL-940 - only show secondary structure prediction services from
4433           // the legacy server
4434           if (// Cache.getDefault("SHOW_JWS1_SERVICES", true)
4435               // &&
4436           Discoverer.services != null && (Discoverer.services.size() > 0))
4437           {
4438             // TODO: refactor to allow list of AbstractName/Handler bindings to
4439             // be
4440             // stored or retrieved from elsewhere
4441             // No MSAWS used any more:
4442             // Vector msaws = null; // (Vector)
4443             // Discoverer.services.get("MsaWS");
4444             Vector secstrpr = (Vector) Discoverer.services
4445                     .get("SecStrPred");
4446             if (secstrpr != null)
4447             {
4448               // Add any secondary structure prediction services
4449               for (int i = 0, j = secstrpr.size(); i < j; i++)
4450               {
4451                 final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) secstrpr
4452                         .get(i);
4453                 jalview.ws.WSMenuEntryProviderI impl = jalview.ws.jws1.Discoverer
4454                         .getServiceClient(sh);
4455                 int p = secstrmenu.getItemCount();
4456                 impl.attachWSMenuEntry(secstrmenu, me);
4457                 int q = secstrmenu.getItemCount();
4458                 for (int litm = p; litm < q; litm++)
4459                 {
4460                   legacyItems.add(secstrmenu.getItem(litm));
4461                 }
4462               }
4463             }
4464           }
4465
4466           // Add all submenus in the order they should appear on the web
4467           // services menu
4468           wsmenu.add(msawsmenu);
4469           wsmenu.add(secstrmenu);
4470           wsmenu.add(dismenu);
4471           wsmenu.add(analymenu);
4472           // No search services yet
4473           // wsmenu.add(seqsrchmenu);
4474
4475           javax.swing.SwingUtilities.invokeLater(new Runnable()
4476           {
4477             @Override
4478             public void run()
4479             {
4480               try
4481               {
4482                 webService.removeAll();
4483                 // first, add discovered services onto the webservices menu
4484                 if (wsmenu.size() > 0)
4485                 {
4486                   for (int i = 0, j = wsmenu.size(); i < j; i++)
4487                   {
4488                     webService.add(wsmenu.get(i));
4489                   }
4490                 }
4491                 else
4492                 {
4493                   webService.add(me.webServiceNoServices);
4494                 }
4495                 // TODO: move into separate menu builder class.
4496                 boolean new_sspred = false;
4497                 if (Cache.getDefault("SHOW_JWS2_SERVICES", true))
4498                 {
4499                   Jws2Discoverer jws2servs = Jws2Discoverer.getDiscoverer();
4500                   if (jws2servs != null)
4501                   {
4502                     if (jws2servs.hasServices())
4503                     {
4504                       jws2servs.attachWSMenuEntry(webService, me);
4505                       for (Jws2Instance sv : jws2servs.getServices())
4506                       {
4507                         if (sv.description.toLowerCase().contains("jpred"))
4508                         {
4509                           for (JMenuItem jmi : legacyItems)
4510                           {
4511                             jmi.setVisible(false);
4512                           }
4513                         }
4514                       }
4515
4516                     }
4517                     if (jws2servs.isRunning())
4518                     {
4519                       JMenuItem tm = new JMenuItem(
4520                               "Still discovering JABA Services");
4521                       tm.setEnabled(false);
4522                       webService.add(tm);
4523                     }
4524                   }
4525                 }
4526                 build_urlServiceMenu(me.webService);
4527                 build_fetchdbmenu(webService);
4528                 for (JMenu item : wsmenu)
4529                 {
4530                   if (item.getItemCount() == 0)
4531                   {
4532                     item.setEnabled(false);
4533                   }
4534                   else
4535                   {
4536                     item.setEnabled(true);
4537                   }
4538                 }
4539               } catch (Exception e)
4540               {
4541                 Cache.log
4542                         .debug("Exception during web service menu building process.",
4543                                 e);
4544               }
4545               ;
4546             }
4547           });
4548         } catch (Exception e)
4549         {
4550         }
4551         ;
4552
4553         buildingMenu = false;
4554       }
4555     }).start();
4556
4557   }
4558
4559   /**
4560    * construct any groupURL type service menu entries.
4561    *
4562    * @param webService
4563    */
4564   private void build_urlServiceMenu(JMenu webService)
4565   {
4566     // TODO: remove this code when 2.7 is released
4567     // DEBUG - alignmentView
4568     /*
4569      * JMenuItem testAlView = new JMenuItem("Test AlignmentView"); final
4570      * AlignFrame af = this; testAlView.addActionListener(new ActionListener() {
4571      *
4572      * @Override public void actionPerformed(ActionEvent e) {
4573      * jalview.datamodel.AlignmentView
4574      * .testSelectionViews(af.viewport.getAlignment(),
4575      * af.viewport.getColumnSelection(), af.viewport.selectionGroup); }
4576      *
4577      * }); webService.add(testAlView);
4578      */
4579     // TODO: refactor to RestClient discoverer and merge menu entries for
4580     // rest-style services with other types of analysis/calculation service
4581     // SHmmr test client - still being implemented.
4582     // DEBUG - alignmentView
4583
4584     for (jalview.ws.rest.RestClient client : jalview.ws.rest.RestClient
4585             .getRestClients())
4586     {
4587       client.attachWSMenuEntry(
4588               JvSwingUtils.findOrCreateMenu(webService, client.getAction()),
4589               this);
4590     }
4591   }
4592
4593   /*
4594    * public void vamsasStore_actionPerformed(ActionEvent e) { JalviewFileChooser
4595    * chooser = new JalviewFileChooser(jalview.bin.Cache.
4596    * getProperty("LAST_DIRECTORY"));
4597    *
4598    * chooser.setFileView(new JalviewFileView()); chooser.setDialogTitle("Export
4599    * to Vamsas file"); chooser.setToolTipText("Export");
4600    *
4601    * int value = chooser.showSaveDialog(this);
4602    *
4603    * if (value == JalviewFileChooser.APPROVE_OPTION) {
4604    * jalview.io.VamsasDatastore vs = new jalview.io.VamsasDatastore(viewport);
4605    * //vs.store(chooser.getSelectedFile().getAbsolutePath() ); vs.storeJalview(
4606    * chooser.getSelectedFile().getAbsolutePath(), this); } }
4607    */
4608   /**
4609    * prototype of an automatically enabled/disabled analysis function
4610    *
4611    */
4612   protected void setShowProductsEnabled()
4613   {
4614     SequenceI[] selection = viewport.getSequenceSelection();
4615     if (canShowProducts(selection, viewport.getSelectionGroup() != null,
4616             viewport.getAlignment().getDataset()))
4617     {
4618       showProducts.setEnabled(true);
4619
4620     }
4621     else
4622     {
4623       showProducts.setEnabled(false);
4624     }
4625   }
4626
4627   /**
4628    * search selection for sequence xRef products and build the show products
4629    * menu.
4630    *
4631    * @param selection
4632    * @param dataset
4633    * @return true if showProducts menu should be enabled.
4634    */
4635   public boolean canShowProducts(SequenceI[] selection,
4636           boolean isRegionSelection, Alignment dataset)
4637   {
4638     boolean showp = false;
4639     try
4640     {
4641       showProducts.removeAll();
4642       final boolean dna = viewport.getAlignment().isNucleotide();
4643       final Alignment ds = dataset;
4644       String[] ptypes = (selection == null || selection.length == 0) ? null
4645               : CrossRef.findSequenceXrefTypes(dna, selection, dataset);
4646       // Object[] prods =
4647       // CrossRef.buildXProductsList(viewport.getAlignment().isNucleotide(),
4648       // selection, dataset, true);
4649       final SequenceI[] sel = selection;
4650       for (int t = 0; ptypes != null && t < ptypes.length; t++)
4651       {
4652         showp = true;
4653         final boolean isRegSel = isRegionSelection;
4654         final AlignFrame af = this;
4655         final String source = ptypes[t];
4656         JMenuItem xtype = new JMenuItem(ptypes[t]);
4657         xtype.addActionListener(new ActionListener()
4658         {
4659
4660           @Override
4661           public void actionPerformed(ActionEvent e)
4662           {
4663             // TODO: new thread for this call with vis-delay
4664             af.showProductsFor(af.viewport.getSequenceSelection(), ds,
4665                     isRegSel, dna, source);
4666           }
4667
4668         });
4669         showProducts.add(xtype);
4670       }
4671       showProducts.setVisible(showp);
4672       showProducts.setEnabled(showp);
4673     } catch (Exception e)
4674     {
4675       jalview.bin.Cache.log
4676               .warn("canTranslate threw an exception - please report to help@jalview.org",
4677                       e);
4678       return false;
4679     }
4680     return showp;
4681   }
4682
4683   protected void showProductsFor(SequenceI[] sel, Alignment ds,
4684           boolean isRegSel, boolean dna, String source)
4685   {
4686     final boolean fisRegSel = isRegSel;
4687     final boolean fdna = dna;
4688     final String fsrc = source;
4689     final AlignFrame ths = this;
4690     final SequenceI[] fsel = sel;
4691     Runnable foo = new Runnable()
4692     {
4693
4694       @Override
4695       public void run()
4696       {
4697         final long sttime = System.currentTimeMillis();
4698         ths.setProgressBar(MessageManager.formatMessage("status.searching_for_sequences_from", new String[]{fsrc}), sttime);
4699         try
4700         {
4701           Alignment ds = ths.getViewport().getAlignment().getDataset(); // update
4702           // our local
4703           // dataset
4704           // reference
4705           Alignment prods = CrossRef
4706                   .findXrefSequences(fsel, fdna, fsrc, ds);
4707           if (prods != null)
4708           {
4709             SequenceI[] sprods = new SequenceI[prods.getHeight()];
4710             for (int s = 0; s < sprods.length; s++)
4711             {
4712               sprods[s] = (prods.getSequenceAt(s)).deriveSequence();
4713               if (ds.getSequences() == null
4714                       || !ds.getSequences().contains(
4715                               sprods[s].getDatasetSequence()))
4716               {
4717                 ds.addSequence(sprods[s].getDatasetSequence());
4718               }
4719               sprods[s].updatePDBIds();
4720             }
4721             Alignment al = new Alignment(sprods);
4722             AlignedCodonFrame[] cf = prods.getCodonFrames();
4723             al.setDataset(ds);
4724             for (int s = 0; cf != null && s < cf.length; s++)
4725             {
4726               al.addCodonFrame(cf[s]);
4727               cf[s] = null;
4728             }
4729             AlignFrame naf = new AlignFrame(al, DEFAULT_WIDTH,
4730                     DEFAULT_HEIGHT);
4731             String newtitle = "" + ((fdna) ? "Proteins " : "Nucleotides ")
4732                     + " for " + ((fisRegSel) ? "selected region of " : "")
4733                     + getTitle();
4734             Desktop.addInternalFrame(naf, newtitle, DEFAULT_WIDTH,
4735                     DEFAULT_HEIGHT);
4736           }
4737           else
4738           {
4739             System.err.println("No Sequences generated for xRef type "
4740                     + fsrc);
4741           }
4742         } catch (Exception e)
4743         {
4744           jalview.bin.Cache.log.error(
4745                   "Exception when finding crossreferences", e);
4746         } catch (OutOfMemoryError e)
4747         {
4748           new OOMWarning("whilst fetching crossreferences", e);
4749         } catch (Error e)
4750         {
4751           jalview.bin.Cache.log.error("Error when finding crossreferences",
4752                   e);
4753         }
4754         ths.setProgressBar(MessageManager.formatMessage("status.finished_searching_for_sequences_from", new String[]{fsrc}),
4755                 sttime);
4756       }
4757
4758     };
4759     Thread frunner = new Thread(foo);
4760     frunner.start();
4761   }
4762
4763   public boolean canShowTranslationProducts(SequenceI[] selection,
4764           AlignmentI alignment)
4765   {
4766     // old way
4767     try
4768     {
4769       return (jalview.analysis.Dna.canTranslate(selection,
4770               viewport.getViewAsVisibleContigs(true)));
4771     } catch (Exception e)
4772     {
4773       jalview.bin.Cache.log
4774               .warn("canTranslate threw an exception - please report to help@jalview.org",
4775                       e);
4776       return false;
4777     }
4778   }
4779
4780   @Override
4781   public void showProducts_actionPerformed(ActionEvent e)
4782   {
4783     // /////////////////////////////
4784     // Collect Data to be translated/transferred
4785
4786     SequenceI[] selection = viewport.getSequenceSelection();
4787     AlignmentI al = null;
4788     try
4789     {
4790       al = jalview.analysis.Dna.CdnaTranslate(selection, viewport
4791               .getViewAsVisibleContigs(true), viewport.getGapCharacter(),
4792               viewport.getAlignment().getDataset());
4793     } catch (Exception ex)
4794     {
4795       al = null;
4796       jalview.bin.Cache.log.debug("Exception during translation.", ex);
4797     }
4798     if (al == null)
4799     {
4800       JOptionPane
4801               .showMessageDialog(
4802                       Desktop.desktop,
4803                       MessageManager
4804                               .getString("label.select_at_least_three_bases_in_at_least_one_sequence_to_cDNA_translation"),
4805                       MessageManager.getString("label.translation_failed"),
4806                       JOptionPane.WARNING_MESSAGE);
4807     }
4808     else
4809     {
4810       AlignFrame af = new AlignFrame(al, DEFAULT_WIDTH, DEFAULT_HEIGHT);
4811       Desktop.addInternalFrame(af, MessageManager.formatMessage(
4812               "label.translation_of_params", new String[]
4813               { this.getTitle() }), DEFAULT_WIDTH, DEFAULT_HEIGHT);
4814     }
4815   }
4816
4817   @Override
4818   public void showTranslation_actionPerformed(ActionEvent e)
4819   {
4820     // /////////////////////////////
4821     // Collect Data to be translated/transferred
4822
4823     SequenceI[] selection = viewport.getSequenceSelection();
4824     String[] seqstring = viewport.getViewAsString(true);
4825     AlignmentI al = null;
4826     try
4827     {
4828       al = jalview.analysis.Dna.CdnaTranslate(selection, seqstring,
4829               viewport.getViewAsVisibleContigs(true), viewport
4830                       .getGapCharacter(), viewport.getAlignment()
4831                       .getAlignmentAnnotation(), viewport.getAlignment()
4832                       .getWidth(), viewport.getAlignment().getDataset());
4833     } catch (Exception ex)
4834     {
4835       al = null;
4836       jalview.bin.Cache.log.error(
4837               "Exception during translation. Please report this !", ex);
4838       JOptionPane
4839               .showMessageDialog(
4840                       Desktop.desktop,
4841                       MessageManager
4842                               .getString("label.error_when_translating_sequences_submit_bug_report"),
4843                       MessageManager
4844                               .getString("label.implementation_error")
4845                               + MessageManager
4846                                       .getString("translation_failed"),
4847                       JOptionPane.ERROR_MESSAGE);
4848       return;
4849     }
4850     if (al == null)
4851     {
4852       JOptionPane
4853               .showMessageDialog(
4854                       Desktop.desktop,
4855                       MessageManager
4856                               .getString("label.select_at_least_three_bases_in_at_least_one_sequence_to_cDNA_translation"),
4857                       MessageManager.getString("label.translation_failed"),
4858                       JOptionPane.WARNING_MESSAGE);
4859     }
4860     else
4861     {
4862       AlignFrame af = new AlignFrame(al, DEFAULT_WIDTH, DEFAULT_HEIGHT);
4863       Desktop.addInternalFrame(af, MessageManager.formatMessage(
4864               "label.translation_of_params", new String[]
4865               { this.getTitle() }), DEFAULT_WIDTH, DEFAULT_HEIGHT);
4866     }
4867   }
4868
4869   /**
4870    * Try to load a features file onto the alignment.
4871    *
4872    * @param file
4873    *          contents or path to retrieve file
4874    * @param type
4875    *          access mode of file (see jalview.io.AlignFile)
4876    * @return true if features file was parsed corectly.
4877    */
4878   public boolean parseFeaturesFile(String file, String type)
4879   {
4880     boolean featuresFile = false;
4881     try
4882     {
4883       featuresFile = new FeaturesFile(file, type).parse(viewport
4884               .getAlignment().getDataset(), alignPanel.getSeqPanel().seqCanvas
4885               .getFeatureRenderer().getFeatureColours(), false,
4886               jalview.bin.Cache.getDefault("RELAXEDSEQIDMATCHING", false));
4887     } catch (Exception ex)
4888     {
4889       ex.printStackTrace();
4890     }
4891
4892     if (featuresFile)
4893     {
4894       viewport.setShowSequenceFeatures(true);
4895       showSeqFeatures.setSelected(true);
4896       if (alignPanel.getSeqPanel().seqCanvas.fr != null)
4897       {
4898         // update the min/max ranges where necessary
4899         alignPanel.getSeqPanel().seqCanvas.fr.findAllFeatures(true);
4900       }
4901       if (featureSettings != null)
4902       {
4903         featureSettings.setTableData();
4904       }
4905       alignPanel.paintAlignment(true);
4906     }
4907
4908     return featuresFile;
4909   }
4910
4911   @Override
4912   public void dragEnter(DropTargetDragEvent evt)
4913   {
4914   }
4915
4916   @Override
4917   public void dragExit(DropTargetEvent evt)
4918   {
4919   }
4920
4921   @Override
4922   public void dragOver(DropTargetDragEvent evt)
4923   {
4924   }
4925
4926   @Override
4927   public void dropActionChanged(DropTargetDragEvent evt)
4928   {
4929   }
4930
4931   @Override
4932   public void drop(DropTargetDropEvent evt)
4933   {
4934     Transferable t = evt.getTransferable();
4935     java.util.List files = null;
4936
4937     try
4938     {
4939       DataFlavor uriListFlavor = new DataFlavor(
4940               "text/uri-list;class=java.lang.String");
4941       if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor))
4942       {
4943         // Works on Windows and MacOSX
4944         evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
4945         files = (java.util.List) t
4946                 .getTransferData(DataFlavor.javaFileListFlavor);
4947       }
4948       else if (t.isDataFlavorSupported(uriListFlavor))
4949       {
4950         // This is used by Unix drag system
4951         evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
4952         String data = (String) t.getTransferData(uriListFlavor);
4953         files = new java.util.ArrayList(1);
4954         for (java.util.StringTokenizer st = new java.util.StringTokenizer(
4955                 data, "\r\n"); st.hasMoreTokens();)
4956         {
4957           String s = st.nextToken();
4958           if (s.startsWith("#"))
4959           {
4960             // the line is a comment (as per the RFC 2483)
4961             continue;
4962           }
4963
4964           java.net.URI uri = new java.net.URI(s);
4965           // check to see if we can handle this kind of URI
4966           if (uri.getScheme().toLowerCase().startsWith("http"))
4967           {
4968             files.add(uri.toString());
4969           }
4970           else
4971           {
4972             // otherwise preserve old behaviour: catch all for file objects
4973             java.io.File file = new java.io.File(uri);
4974             files.add(file.toString());
4975           }
4976         }
4977       }
4978     } catch (Exception e)
4979     {
4980       e.printStackTrace();
4981     }
4982     if (files != null)
4983     {
4984       try
4985       {
4986         // check to see if any of these files have names matching sequences in
4987         // the alignment
4988         SequenceIdMatcher idm = new SequenceIdMatcher(viewport
4989                 .getAlignment().getSequencesArray());
4990         /**
4991          * Object[] { String,SequenceI}
4992          */
4993         ArrayList<Object[]> filesmatched = new ArrayList<Object[]>();
4994         ArrayList<String> filesnotmatched = new ArrayList<String>();
4995         for (int i = 0; i < files.size(); i++)
4996         {
4997           String file = files.get(i).toString();
4998           String pdbfn = "";
4999           String protocol = FormatAdapter.checkProtocol(file);
5000           if (protocol == jalview.io.FormatAdapter.FILE)
5001           {
5002             File fl = new File(file);
5003             pdbfn = fl.getName();
5004           }
5005           else if (protocol == jalview.io.FormatAdapter.URL)
5006           {
5007             URL url = new URL(file);
5008             pdbfn = url.getFile();
5009           }
5010           if (pdbfn.length() > 0)
5011           {
5012             // attempt to find a match in the alignment
5013             SequenceI[] mtch = idm.findAllIdMatches(pdbfn);
5014             int l = 0, c = pdbfn.indexOf(".");
5015             while (mtch == null && c != -1)
5016             {
5017               do
5018               {
5019                 l = c;
5020               } while ((c = pdbfn.indexOf(".", l)) > l);
5021               if (l > -1)
5022               {
5023                 pdbfn = pdbfn.substring(0, l);
5024               }
5025               mtch = idm.findAllIdMatches(pdbfn);
5026             }
5027             if (mtch != null)
5028             {
5029               String type = null;
5030               try
5031               {
5032                 type = new IdentifyFile().Identify(file, protocol);
5033               } catch (Exception ex)
5034               {
5035                 type = null;
5036               }
5037               if (type != null)
5038               {
5039                 if (type.equalsIgnoreCase("PDB"))
5040                 {
5041                   filesmatched.add(new Object[]
5042                   { file, protocol, mtch });
5043                   continue;
5044                 }
5045               }
5046             }
5047             // File wasn't named like one of the sequences or wasn't a PDB file.
5048             filesnotmatched.add(file);
5049           }
5050         }
5051         int assocfiles = 0;
5052         if (filesmatched.size() > 0)
5053         {
5054           if (Cache.getDefault("AUTOASSOCIATE_PDBANDSEQS", false)
5055                   || JOptionPane
5056                           .showConfirmDialog(
5057                                   this,
5058                                   MessageManager
5059                                           .formatMessage(
5060                                                   "label.automatically_associate_pdb_files_with_sequences_same_name",
5061                                                   new String[]
5062                                                   { Integer.valueOf(
5063                                                           filesmatched
5064                                                                   .size())
5065                                                           .toString() }),
5066                                   MessageManager
5067                                           .getString("label.automatically_associate_pdb_files_by_name"),
5068                                   JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION)
5069
5070           {
5071             for (Object[] fm : filesmatched)
5072             {
5073               // try and associate
5074               // TODO: may want to set a standard ID naming formalism for
5075               // associating PDB files which have no IDs.
5076               for (SequenceI toassoc : (SequenceI[]) fm[2])
5077               {
5078                 PDBEntry pe = new AssociatePdbFileWithSeq()
5079                         .associatePdbWithSeq((String) fm[0],
5080                                 (String) fm[1], toassoc, false,
5081                                 Desktop.instance);
5082                 if (pe != null)
5083                 {
5084                   System.err.println("Associated file : "
5085                           + ((String) fm[0]) + " with "
5086                           + toassoc.getDisplayId(true));
5087                   assocfiles++;
5088                 }
5089               }
5090               alignPanel.paintAlignment(true);
5091             }
5092           }
5093         }
5094         if (filesnotmatched.size() > 0)
5095         {
5096           if (assocfiles > 0
5097                   && (Cache.getDefault(
5098                           "AUTOASSOCIATE_PDBANDSEQS_IGNOREOTHERS", false) || JOptionPane
5099                           .showConfirmDialog(
5100                                   this,
5101                                   "<html>"+MessageManager
5102                                           .formatMessage(
5103                                                   "label.ignore_unmatched_dropped_files_info",
5104                                                   new String[]
5105                                                   { Integer.valueOf(
5106                                                           filesnotmatched
5107                                                                   .size())
5108                                                           .toString() })+"</html>",
5109                                   MessageManager
5110                                           .getString("label.ignore_unmatched_dropped_files"),
5111                                   JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION))
5112           {
5113             return;
5114           }
5115           for (String fn : filesnotmatched)
5116           {
5117             loadJalviewDataFile(fn, null, null, null);
5118           }
5119
5120         }
5121       } catch (Exception ex)
5122       {
5123         ex.printStackTrace();
5124       }
5125     }
5126   }
5127
5128   /**
5129    * Attempt to load a "dropped" file or URL string: First by testing whether
5130    * it's and Annotation file, then a JNet file, and finally a features file. If
5131    * all are false then the user may have dropped an alignment file onto this
5132    * AlignFrame.
5133    *
5134    * @param file
5135    *          either a filename or a URL string.
5136    */
5137   public void loadJalviewDataFile(String file, String protocol,
5138           String format, SequenceI assocSeq)
5139   {
5140     try
5141     {
5142       if (protocol == null)
5143       {
5144         protocol = jalview.io.FormatAdapter.checkProtocol(file);
5145       }
5146       // if the file isn't identified, or not positively identified as some
5147       // other filetype (PFAM is default unidentified alignment file type) then
5148       // try to parse as annotation.
5149       boolean isAnnotation = (format == null || format
5150               .equalsIgnoreCase("PFAM")) ? new AnnotationFile()
5151               .readAnnotationFile(viewport.getAlignment(), file, protocol)
5152               : false;
5153
5154       if (!isAnnotation)
5155       {
5156         // first see if its a T-COFFEE score file
5157         TCoffeeScoreFile tcf = null;
5158         try
5159         {
5160           tcf = new TCoffeeScoreFile(file, protocol);
5161           if (tcf.isValid())
5162           {
5163             if (tcf.annotateAlignment(viewport.getAlignment(), true))
5164             {
5165               tcoffeeColour.setEnabled(true);
5166               tcoffeeColour.setSelected(true);
5167               changeColour(new TCoffeeColourScheme(viewport.getAlignment()));
5168               isAnnotation = true;
5169               statusBar
5170                       .setText(MessageManager
5171                               .getString("label.successfully_pasted_tcoffee_scores_to_alignment"));
5172             }
5173             else
5174             {
5175               // some problem - if no warning its probable that the ID matching
5176               // process didn't work
5177               JOptionPane
5178                       .showMessageDialog(
5179                               Desktop.desktop,
5180                               tcf.getWarningMessage() == null ? MessageManager
5181                                       .getString("label.check_file_matches_sequence_ids_alignment")
5182                                       : tcf.getWarningMessage(),
5183                               MessageManager
5184                                       .getString("label.problem_reading_tcoffee_score_file"),
5185                               JOptionPane.WARNING_MESSAGE);
5186             }
5187           }
5188           else
5189           {
5190             tcf = null;
5191           }
5192         } catch (Exception x)
5193         {
5194           Cache.log
5195                   .debug("Exception when processing data source as T-COFFEE score file",
5196                           x);
5197           tcf = null;
5198         }
5199         if (tcf == null)
5200         {
5201           // try to see if its a JNet 'concise' style annotation file *before*
5202           // we
5203           // try to parse it as a features file
5204           if (format == null)
5205           {
5206             format = new IdentifyFile().Identify(file, protocol);
5207           }
5208           if (format.equalsIgnoreCase("JnetFile"))
5209           {
5210             jalview.io.JPredFile predictions = new jalview.io.JPredFile(
5211                     file, protocol);
5212             new JnetAnnotationMaker().add_annotation(predictions,
5213                     viewport.getAlignment(), 0, false);
5214             isAnnotation = true;
5215           }
5216           else
5217           {
5218             /*
5219              * if (format.equalsIgnoreCase("PDB")) {
5220              *
5221              * String pdbfn = ""; // try to match up filename with sequence id
5222              * try { if (protocol == jalview.io.FormatAdapter.FILE) { File fl =
5223              * new File(file); pdbfn = fl.getName(); } else if (protocol ==
5224              * jalview.io.FormatAdapter.URL) { URL url = new URL(file); pdbfn =
5225              * url.getFile(); } } catch (Exception e) { } ; if (assocSeq ==
5226              * null) { SequenceIdMatcher idm = new SequenceIdMatcher(viewport
5227              * .getAlignment().getSequencesArray()); if (pdbfn.length() > 0) {
5228              * // attempt to find a match in the alignment SequenceI mtch =
5229              * idm.findIdMatch(pdbfn); int l = 0, c = pdbfn.indexOf("."); while
5230              * (mtch == null && c != -1) { while ((c = pdbfn.indexOf(".", l)) >
5231              * l) { l = c; } if (l > -1) { pdbfn = pdbfn.substring(0, l); } mtch
5232              * = idm.findIdMatch(pdbfn); } if (mtch != null) { // try and
5233              * associate // prompt ? PDBEntry pe = new AssociatePdbFileWithSeq()
5234              * .associatePdbWithSeq(file, protocol, mtch, true); if (pe != null)
5235              * { System.err.println("Associated file : " + file + " with " +
5236              * mtch.getDisplayId(true)); alignPanel.paintAlignment(true); } } //
5237              * TODO: maybe need to load as normal otherwise return; } }
5238              */
5239             // try to parse it as a features file
5240             boolean isGroupsFile = parseFeaturesFile(file, protocol);
5241             // if it wasn't a features file then we just treat it as a general
5242             // alignment file to load into the current view.
5243             if (!isGroupsFile)
5244             {
5245               new FileLoader().LoadFile(viewport, file, protocol, format);
5246             }
5247             else
5248             {
5249               alignPanel.paintAlignment(true);
5250             }
5251           }
5252         }
5253       }
5254       if (isAnnotation)
5255       {
5256
5257         alignPanel.adjustAnnotationHeight();
5258         viewport.updateSequenceIdColours();
5259         buildSortByAnnotationScoresMenu();
5260         alignPanel.paintAlignment(true);
5261       }
5262     } catch (Exception ex)
5263     {
5264       ex.printStackTrace();
5265     } catch (OutOfMemoryError oom)
5266     {
5267       try
5268       {
5269         System.gc();
5270       } catch (Exception x)
5271       {
5272       }
5273       ;
5274       new OOMWarning(
5275               "loading data "
5276                       + (protocol != null ? (protocol.equals(FormatAdapter.PASTE) ? "from clipboard."
5277                               : "using " + protocol + " from " + file)
5278                               : ".")
5279                       + (format != null ? "(parsing as '" + format
5280                               + "' file)" : ""), oom, Desktop.desktop);
5281     }
5282   }
5283
5284   @Override
5285   public void tabSelectionChanged(int index)
5286   {
5287     if (index > -1)
5288     {
5289       alignPanel = (AlignmentPanel) alignPanels.elementAt(index);
5290       viewport = alignPanel.av;
5291       avc.setViewportAndAlignmentPanel(viewport, alignPanel);
5292       setMenusFromViewport(viewport);
5293     }
5294   }
5295
5296   @Override
5297   public void tabbedPane_mousePressed(MouseEvent e)
5298   {
5299     if (SwingUtilities.isRightMouseButton(e))
5300     {
5301       String reply = JOptionPane.showInternalInputDialog(this,
5302               MessageManager.getString("label.enter_view_name"),
5303               MessageManager.getString("label.enter_view_name"),
5304               JOptionPane.QUESTION_MESSAGE);
5305
5306       if (reply != null)
5307       {
5308         viewport.viewName = reply;
5309         tabbedPane.setTitleAt(tabbedPane.getSelectedIndex(), reply);
5310       }
5311     }
5312   }
5313
5314   public AlignViewport getCurrentView()
5315   {
5316     return viewport;
5317   }
5318
5319   /**
5320    * Open the dialog for regex description parsing.
5321    */
5322   @Override
5323   protected void extractScores_actionPerformed(ActionEvent e)
5324   {
5325     ParseProperties pp = new jalview.analysis.ParseProperties(
5326             viewport.getAlignment());
5327     // TODO: verify regex and introduce GUI dialog for version 2.5
5328     // if (pp.getScoresFromDescription("col", "score column ",
5329     // "\\W*([-+]?\\d*\\.?\\d*e?-?\\d*)\\W+([-+]?\\d*\\.?\\d*e?-?\\d*)",
5330     // true)>0)
5331     if (pp.getScoresFromDescription("description column",
5332             "score in description column ", "\\W*([-+eE0-9.]+)", true) > 0)
5333     {
5334       buildSortByAnnotationScoresMenu();
5335     }
5336   }
5337
5338   /*
5339    * (non-Javadoc)
5340    *
5341    * @see
5342    * jalview.jbgui.GAlignFrame#showDbRefs_actionPerformed(java.awt.event.ActionEvent
5343    * )
5344    */
5345   @Override
5346   protected void showDbRefs_actionPerformed(ActionEvent e)
5347   {
5348     viewport.setShowDbRefs(showDbRefsMenuitem.isSelected());
5349   }
5350
5351   /*
5352    * (non-Javadoc)
5353    *
5354    * @seejalview.jbgui.GAlignFrame#showNpFeats_actionPerformed(java.awt.event.
5355    * ActionEvent)
5356    */
5357   @Override
5358   protected void showNpFeats_actionPerformed(ActionEvent e)
5359   {
5360     viewport.setShowNpFeats(showNpFeatsMenuitem.isSelected());
5361   }
5362
5363   /**
5364    * find the viewport amongst the tabs in this alignment frame and close that
5365    * tab
5366    *
5367    * @param av
5368    */
5369   public boolean closeView(AlignViewport av)
5370   {
5371     if (viewport == av)
5372     {
5373       this.closeMenuItem_actionPerformed(false);
5374       return true;
5375     }
5376     Component[] comp = tabbedPane.getComponents();
5377     for (int i = 0; comp != null && i < comp.length; i++)
5378     {
5379       if (comp[i] instanceof AlignmentPanel)
5380       {
5381         if (((AlignmentPanel) comp[i]).av == av)
5382         {
5383           // close the view.
5384           closeView((AlignmentPanel) comp[i]);
5385           return true;
5386         }
5387       }
5388     }
5389     return false;
5390   }
5391
5392   protected void build_fetchdbmenu(JMenu webService)
5393   {
5394     // Temporary hack - DBRef Fetcher always top level ws entry.
5395     // TODO We probably want to store a sequence database checklist in
5396     // preferences and have checkboxes.. rather than individual sources selected
5397     // here
5398     final JMenu rfetch = new JMenu(
5399             MessageManager.getString("action.fetch_db_references"));
5400     rfetch.setToolTipText(MessageManager
5401             .getString("label.retrieve_parse_sequence_database_records_alignment_or_selected_sequences"));
5402     webService.add(rfetch);
5403
5404     final JCheckBoxMenuItem trimrs = new JCheckBoxMenuItem(
5405             MessageManager.getString("option.trim_retrieved_seqs"));
5406     trimrs.setToolTipText(MessageManager
5407             .getString("label.trim_retrieved_sequences"));
5408     trimrs.setSelected(Cache.getDefault("TRIM_FETCHED_DATASET_SEQS", true));
5409     trimrs.addActionListener(new ActionListener()
5410     {
5411       @Override
5412       public void actionPerformed(ActionEvent e)
5413       {
5414         trimrs.setSelected(trimrs.isSelected());
5415         Cache.setProperty("TRIM_FETCHED_DATASET_SEQS",
5416                 Boolean.valueOf(trimrs.isSelected()).toString());
5417       };
5418     });
5419     rfetch.add(trimrs);
5420     JMenuItem fetchr = new JMenuItem(
5421             MessageManager.getString("label.standard_databases"));
5422     fetchr.setToolTipText(MessageManager
5423             .getString("label.fetch_embl_uniprot"));
5424     fetchr.addActionListener(new ActionListener()
5425     {
5426
5427       @Override
5428       public void actionPerformed(ActionEvent e)
5429       {
5430         new Thread(new Runnable()
5431         {
5432
5433           @Override
5434           public void run()
5435           {
5436             new jalview.ws.DBRefFetcher(alignPanel.av
5437                     .getSequenceSelection(), alignPanel.alignFrame)
5438                     .fetchDBRefs(false);
5439           }
5440         }).start();
5441
5442       }
5443
5444     });
5445     rfetch.add(fetchr);
5446     final AlignFrame me = this;
5447     new Thread(new Runnable()
5448     {
5449       @Override
5450       public void run()
5451       {
5452         final jalview.ws.SequenceFetcher sf = SequenceFetcher
5453                 .getSequenceFetcherSingleton(me);
5454         javax.swing.SwingUtilities.invokeLater(new Runnable()
5455         {
5456           @Override
5457           public void run()
5458           {
5459             String[] dbclasses = sf.getOrderedSupportedSources();
5460             // sf.getDbInstances(jalview.ws.dbsources.DasSequenceSource.class);
5461             // jalview.util.QuickSort.sort(otherdb, otherdb);
5462             List<DbSourceProxy> otherdb;
5463             JMenu dfetch = new JMenu();
5464             JMenu ifetch = new JMenu();
5465             JMenuItem fetchr = null;
5466             int comp = 0, icomp = 0, mcomp = 15;
5467             String mname = null;
5468             int dbi = 0;
5469             for (String dbclass : dbclasses)
5470             {
5471               otherdb = sf.getSourceProxy(dbclass);
5472               // add a single entry for this class, or submenu allowing 'fetch
5473               // all' or pick one
5474               if (otherdb == null || otherdb.size() < 1)
5475               {
5476                 continue;
5477               }
5478               // List<DbSourceProxy> dbs=otherdb;
5479               // otherdb=new ArrayList<DbSourceProxy>();
5480               // for (DbSourceProxy db:dbs)
5481               // {
5482               // if (!db.isA(DBRefSource.ALIGNMENTDB)
5483               // }
5484               if (mname == null)
5485               {
5486                 mname = "From " + dbclass;
5487               }
5488               if (otherdb.size() == 1)
5489               {
5490                 final DbSourceProxy[] dassource = otherdb
5491                         .toArray(new DbSourceProxy[0]);
5492                 DbSourceProxy src = otherdb.get(0);
5493                 fetchr = new JMenuItem(src.getDbSource());
5494                 fetchr.addActionListener(new ActionListener()
5495                 {
5496
5497                   @Override
5498                   public void actionPerformed(ActionEvent e)
5499                   {
5500                     new Thread(new Runnable()
5501                     {
5502
5503                       @Override
5504                       public void run()
5505                       {
5506                         new jalview.ws.DBRefFetcher(alignPanel.av
5507                                 .getSequenceSelection(),
5508                                 alignPanel.alignFrame, dassource)
5509                                 .fetchDBRefs(false);
5510                       }
5511                     }).start();
5512                   }
5513
5514                 });
5515                 fetchr.setToolTipText(JvSwingUtils.wrapTooltip(true, MessageManager.formatMessage("label.fetch_retrieve_from", new String[]{src.getDbName()})));
5516                 dfetch.add(fetchr);
5517                 comp++;
5518               }
5519               else
5520               {
5521                 final DbSourceProxy[] dassource = otherdb
5522                         .toArray(new DbSourceProxy[0]);
5523                 // fetch all entry
5524                 DbSourceProxy src = otherdb.get(0);
5525                 fetchr = new JMenuItem(MessageManager.formatMessage(
5526                         "label.fetch_all_param", new String[]
5527                         { src.getDbSource() }));
5528                 fetchr.addActionListener(new ActionListener()
5529                 {
5530                   @Override
5531                   public void actionPerformed(ActionEvent e)
5532                   {
5533                     new Thread(new Runnable()
5534                     {
5535
5536                       @Override
5537                       public void run()
5538                       {
5539                         new jalview.ws.DBRefFetcher(alignPanel.av
5540                                 .getSequenceSelection(),
5541                                 alignPanel.alignFrame, dassource)
5542                                 .fetchDBRefs(false);
5543                       }
5544                     }).start();
5545                   }
5546                 });
5547
5548                 fetchr.setToolTipText(JvSwingUtils.wrapTooltip(true, MessageManager.formatMessage("label.fetch_retrieve_from_all_sources", new String[]{Integer.valueOf(otherdb.size()).toString(), src.getDbSource(), src.getDbName()})));
5549                 dfetch.add(fetchr);
5550                 comp++;
5551                 // and then build the rest of the individual menus
5552                 ifetch = new JMenu(MessageManager.formatMessage("label.source_from_db_source", new String[]{src.getDbSource()}));
5553                 icomp = 0;
5554                 String imname = null;
5555                 int i = 0;
5556                 for (DbSourceProxy sproxy : otherdb)
5557                 {
5558                   String dbname = sproxy.getDbName();
5559                   String sname = dbname.length() > 5 ? dbname.substring(0,
5560                           5) + "..." : dbname;
5561                   String msname = dbname.length() > 10 ? dbname.substring(
5562                           0, 10) + "..." : dbname;
5563                   if (imname == null)
5564                   {
5565                     imname = MessageManager.formatMessage("label.from_msname", new String[]{sname});
5566                   }
5567                   fetchr = new JMenuItem(msname);
5568                   final DbSourceProxy[] dassrc =
5569                   { sproxy };
5570                   fetchr.addActionListener(new ActionListener()
5571                   {
5572
5573                     @Override
5574                     public void actionPerformed(ActionEvent e)
5575                     {
5576                       new Thread(new Runnable()
5577                       {
5578
5579                         @Override
5580                         public void run()
5581                         {
5582                           new jalview.ws.DBRefFetcher(alignPanel.av
5583                                   .getSequenceSelection(),
5584                                   alignPanel.alignFrame, dassrc)
5585                                   .fetchDBRefs(false);
5586                         }
5587                       }).start();
5588                     }
5589
5590                   });
5591                   fetchr.setToolTipText("<html>"
5592                           + MessageManager.formatMessage("label.fetch_retrieve_from", new String[]{dbname}));
5593                   ifetch.add(fetchr);
5594                   ++i;
5595                   if (++icomp >= mcomp || i == (otherdb.size()))
5596                   {
5597                     ifetch.setText(MessageManager.formatMessage(
5598                             "label.source_to_target", imname, sname));
5599                     dfetch.add(ifetch);
5600                     ifetch = new JMenu();
5601                     imname = null;
5602                     icomp = 0;
5603                     comp++;
5604                   }
5605                 }
5606               }
5607               ++dbi;
5608               if (comp >= mcomp || dbi >= (dbclasses.length))
5609               {
5610                 dfetch.setText(MessageManager.formatMessage(
5611                         "label.source_to_target", mname, dbclass));
5612                 rfetch.add(dfetch);
5613                 dfetch = new JMenu();
5614                 mname = null;
5615                 comp = 0;
5616               }
5617             }
5618           }
5619         });
5620       }
5621     }).start();
5622
5623   }
5624
5625   /**
5626    * Left justify the whole alignment.
5627    */
5628   @Override
5629   protected void justifyLeftMenuItem_actionPerformed(ActionEvent e)
5630   {
5631     AlignmentI al = viewport.getAlignment();
5632     al.justify(false);
5633     viewport.firePropertyChange("alignment", null, al);
5634   }
5635
5636   /**
5637    * Right justify the whole alignment.
5638    */
5639   @Override
5640   protected void justifyRightMenuItem_actionPerformed(ActionEvent e)
5641   {
5642     AlignmentI al = viewport.getAlignment();
5643     al.justify(true);
5644     viewport.firePropertyChange("alignment", null, al);
5645   }
5646
5647   public void setShowSeqFeatures(boolean b)
5648   {
5649     showSeqFeatures.setSelected(true);
5650     viewport.setShowSequenceFeatures(true);
5651   }
5652
5653   /*
5654    * (non-Javadoc)
5655    *
5656    * @see
5657    * jalview.jbgui.GAlignFrame#showUnconservedMenuItem_actionPerformed(java.
5658    * awt.event.ActionEvent)
5659    */
5660   @Override
5661   protected void showUnconservedMenuItem_actionPerformed(ActionEvent e)
5662   {
5663     viewport.setShowUnconserved(showNonconservedMenuItem.getState());
5664     alignPanel.paintAlignment(true);
5665   }
5666
5667   /*
5668    * (non-Javadoc)
5669    *
5670    * @see
5671    * jalview.jbgui.GAlignFrame#showGroupConsensus_actionPerformed(java.awt.event
5672    * .ActionEvent)
5673    */
5674   @Override
5675   protected void showGroupConsensus_actionPerformed(ActionEvent e)
5676   {
5677     viewport.setShowGroupConsensus(showGroupConsensus.getState());
5678     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
5679
5680   }
5681
5682   /*
5683    * (non-Javadoc)
5684    *
5685    * @see
5686    * jalview.jbgui.GAlignFrame#showGroupConservation_actionPerformed(java.awt
5687    * .event.ActionEvent)
5688    */
5689   @Override
5690   protected void showGroupConservation_actionPerformed(ActionEvent e)
5691   {
5692     viewport.setShowGroupConservation(showGroupConservation.getState());
5693     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
5694   }
5695
5696   /*
5697    * (non-Javadoc)
5698    *
5699    * @see
5700    * jalview.jbgui.GAlignFrame#showConsensusHistogram_actionPerformed(java.awt
5701    * .event.ActionEvent)
5702    */
5703   @Override
5704   protected void showConsensusHistogram_actionPerformed(ActionEvent e)
5705   {
5706     viewport.setShowConsensusHistogram(showConsensusHistogram.getState());
5707     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
5708   }
5709
5710   /*
5711    * (non-Javadoc)
5712    *
5713    * @see
5714    * jalview.jbgui.GAlignFrame#showConsensusProfile_actionPerformed(java.awt
5715    * .event.ActionEvent)
5716    */
5717   @Override
5718   protected void showSequenceLogo_actionPerformed(ActionEvent e)
5719   {
5720     viewport.setShowSequenceLogo(showSequenceLogo.getState());
5721     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
5722   }
5723
5724   @Override
5725   protected void normaliseSequenceLogo_actionPerformed(ActionEvent e)
5726   {
5727     showSequenceLogo.setState(true);
5728     viewport.setShowSequenceLogo(true);
5729     viewport.setNormaliseSequenceLogo(normaliseSequenceLogo.getState());
5730     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
5731   }
5732
5733   @Override
5734   protected void applyAutoAnnotationSettings_actionPerformed(ActionEvent e)
5735   {
5736     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
5737   }
5738
5739   /*
5740    * (non-Javadoc)
5741    *
5742    * @see
5743    * jalview.jbgui.GAlignFrame#makeGrpsFromSelection_actionPerformed(java.awt
5744    * .event.ActionEvent)
5745    */
5746   @Override
5747   protected void makeGrpsFromSelection_actionPerformed(ActionEvent e)
5748   {
5749     if (avc.makeGroupsFromSelection())
5750     {
5751       PaintRefresher.Refresh(this, viewport.getSequenceSetId());
5752       alignPanel.updateAnnotation();
5753       alignPanel.paintAlignment(true);
5754     }
5755   }
5756
5757   @Override
5758   protected void createGroup_actionPerformed(ActionEvent e)
5759   {
5760     if (avc.createGroup())
5761     {
5762       alignPanel.alignmentChanged();
5763     }
5764   }
5765
5766   @Override
5767   protected void unGroup_actionPerformed(ActionEvent e)
5768   {
5769     if (avc.unGroup())
5770     {
5771       alignPanel.alignmentChanged();
5772     }
5773   }
5774
5775   /**
5776    * make the given alignmentPanel the currently selected tab
5777    *
5778    * @param alignmentPanel
5779    */
5780   public void setDisplayedView(AlignmentPanel alignmentPanel)
5781   {
5782     if (!viewport.getSequenceSetId().equals(
5783             alignmentPanel.av.getSequenceSetId()))
5784     {
5785       throw new Error(MessageManager.getString("error.implementation_error_cannot_show_view_alignment_frame"));
5786     }
5787     if (tabbedPane != null
5788             & alignPanels.indexOf(alignmentPanel) != tabbedPane
5789                     .getSelectedIndex())
5790     {
5791       tabbedPane.setSelectedIndex(alignPanels.indexOf(alignmentPanel));
5792     }
5793   }
5794
5795   /**
5796    * Action on selection of menu options to Show or Hide annotations.
5797    *
5798    * @param visible
5799    * @param forSequences
5800    *          update sequence-related annotations
5801    * @param forAlignment
5802    *          update non-sequence-related annotations
5803    */
5804   @Override
5805   protected void setAnnotationsVisibility(boolean visible,
5806           boolean forSequences, boolean forAlignment)
5807   {
5808     for (AlignmentAnnotation aa : alignPanel.getAlignment()
5809             .getAlignmentAnnotation())
5810     {
5811       boolean apply = (aa.sequenceRef == null && forAlignment)
5812               || (aa.sequenceRef != null && forSequences);
5813       if (apply)
5814       {
5815         aa.visible = visible;
5816       }
5817     }
5818     alignPanel.validateAnnotationDimensions(false);
5819     alignPanel.alignmentChanged();
5820   }
5821
5822   /**
5823    * Store selected annotation sort order for the view and repaint.
5824    */
5825   @Override
5826   protected void sortAnnotations_actionPerformed()
5827   {
5828     this.alignPanel.av.setSortAnnotationsBy(getAnnotationSortOrder());
5829     this.alignPanel.av
5830             .setShowAutocalculatedAbove(isShowAutoCalculatedAbove());
5831     alignPanel.paintAlignment(true);
5832   }
5833
5834   /**
5835    *
5836    * @return alignment panels in this alignemnt frame
5837    */
5838   public List<AlignmentViewPanel> getAlignPanels()
5839   {
5840     return alignPanels == null ? Arrays.asList(alignPanel) : alignPanels;
5841   }
5842 }
5843
5844 class PrintThread extends Thread
5845 {
5846   AlignmentPanel ap;
5847
5848   public PrintThread(AlignmentPanel ap)
5849   {
5850     this.ap = ap;
5851   }
5852
5853   static PageFormat pf;
5854
5855   @Override
5856   public void run()
5857   {
5858     PrinterJob printJob = PrinterJob.getPrinterJob();
5859
5860     if (pf != null)
5861     {
5862       printJob.setPrintable(ap, pf);
5863     }
5864     else
5865     {
5866       printJob.setPrintable(ap);
5867     }
5868
5869     if (printJob.printDialog())
5870     {
5871       try
5872       {
5873         printJob.print();
5874       } catch (Exception PrintException)
5875       {
5876         PrintException.printStackTrace();
5877       }
5878     }
5879   }
5880 }