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