src/jalview/gui/AlignFrame.java

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