src/jalview/gui/AlignFrame.java

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