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