src/jalview/gui/AlignFrame.java

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