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