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