src/jalview/gui/AlignFrame.java

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