src/jalview/gui/AlignFrame.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)
   3  * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19 package jalview.gui;
  20
  21 import java.beans.*;
  22 import java.io.*;
  23 import java.util.*;
  24
  25 import java.awt.*;
  26 import java.awt.datatransfer.*;
  27 import java.awt.dnd.*;
  28 import java.awt.event.*;
  29 import java.awt.print.*;
  30 import javax.swing.*;
  31 import javax.swing.event.MenuEvent;
  32
  33 import jalview.analysis.*;
  34 import jalview.commands.*;
  35 import jalview.datamodel.*;
  36 import jalview.io.*;
  37 import jalview.jbgui.*;
  38 import jalview.schemes.*;
  39 import jalview.ws.*;
  40
  41 /**
  42  * DOCUMENT ME!
  43  *
  44  * @author $author$
  45  * @version $Revision$
  46  */
  47 public class AlignFrame extends GAlignFrame implements DropTargetListener,
  48         IProgressIndicator
  49 {
  50
  51   /** DOCUMENT ME!! */
  52   public static final int DEFAULT_WIDTH = 700;
  53
  54   /** DOCUMENT ME!! */
  55   public static final int DEFAULT_HEIGHT = 500;
  56
  57   public AlignmentPanel alignPanel;
  58
  59   AlignViewport viewport;
  60
  61   Vector alignPanels = new Vector();
  62
  63   /**
  64    * Last format used to load or save alignments in this window
  65    */
  66   String currentFileFormat = null;
  67
  68   /**
  69    * Current filename for this alignment
  70    */
  71   String fileName = null;
  72
  73   /**
  74    * Creates a new AlignFrame object with specific width and height.
  75    *
  76    * @param al
  77    * @param width
  78    * @param height
  79    */
  80   public AlignFrame(AlignmentI al, int width, int height)
  81   {
  82     this(al, null, width, height);
  83   }
  84
  85   /**
  86    * Creates a new AlignFrame object with specific width, height and
  87    * sequenceSetId
  88    *
  89    * @param al
  90    * @param width
  91    * @param height
  92    * @param sequenceSetId
  93    */
  94   public AlignFrame(AlignmentI al, int width, int height,
  95           String sequenceSetId)
  96   {
  97     this(al, null, width, height, sequenceSetId);
  98   }
  99
 100   /**
 101    * Creates a new AlignFrame object with specific width, height and
 102    * sequenceSetId
 103    *
 104    * @param al
 105    * @param width
 106    * @param height
 107    * @param sequenceSetId
 108    * @param viewId
 109    */
 110   public AlignFrame(AlignmentI al, int width, int height,
 111           String sequenceSetId, String viewId)
 112   {
 113     this(al, null, width, height, sequenceSetId, viewId);
 114   }
 115
 116   /**
 117    * new alignment window with hidden columns
 118    *
 119    * @param al
 120    *          AlignmentI
 121    * @param hiddenColumns
 122    *          ColumnSelection or null
 123    * @param width
 124    *          Width of alignment frame
 125    * @param height
 126    *          height of frame.
 127    */
 128   public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
 129           int width, int height)
 130   {
 131     this(al, hiddenColumns, width, height, null);
 132   }
 133
 134   /**
 135    * Create alignment frame for al with hiddenColumns, a specific width and
 136    * height, and specific sequenceId
 137    *
 138    * @param al
 139    * @param hiddenColumns
 140    * @param width
 141    * @param height
 142    * @param sequenceSetId
 143    *          (may be null)
 144    */
 145   public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
 146           int width, int height, String sequenceSetId)
 147   {
 148     this(al, hiddenColumns, width, height, sequenceSetId, null);
 149   }
 150
 151   /**
 152    * Create alignment frame for al with hiddenColumns, a specific width and
 153    * height, and specific sequenceId
 154    *
 155    * @param al
 156    * @param hiddenColumns
 157    * @param width
 158    * @param height
 159    * @param sequenceSetId
 160    *          (may be null)
 161    * @param viewId
 162    *          (may be null)
 163    */
 164   public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
 165           int width, int height, String sequenceSetId, String viewId)
 166   {
 167     setSize(width, height);
 168     viewport = new AlignViewport(al, hiddenColumns, sequenceSetId, viewId);
 169
 170     alignPanel = new AlignmentPanel(this, viewport);
 171
 172     if (al.getDataset() == null)
 173     {
 174       al.setDataset(null);
 175     }
 176
 177     addAlignmentPanel(alignPanel, true);
 178     init();
 179   }
 180
 181   /**
 182    * Make a new AlignFrame from exisiting alignmentPanels
 183    *
 184    * @param ap
 185    *          AlignmentPanel
 186    * @param av
 187    *          AlignViewport
 188    */
 189   public AlignFrame(AlignmentPanel ap)
 190   {
 191     viewport = ap.av;
 192     alignPanel = ap;
 193     addAlignmentPanel(ap, false);
 194     init();
 195   }
 196
 197   /**
 198    * initalise the alignframe from the underlying viewport data and the
 199    * configurations
 200    */
 201   void init()
 202   {
 203     if (viewport.conservation == null)
 204     {
 205       BLOSUM62Colour.setEnabled(false);
 206       conservationMenuItem.setEnabled(false);
 207       modifyConservation.setEnabled(false);
 208       // PIDColour.setEnabled(false);
 209       // abovePIDThreshold.setEnabled(false);
 210       // modifyPID.setEnabled(false);
 211     }
 212
 213     String sortby = jalview.bin.Cache.getDefault("SORT_ALIGNMENT",
 214             "No sort");
 215
 216     if (sortby.equals("Id"))
 217     {
 218       sortIDMenuItem_actionPerformed(null);
 219     }
 220     else if (sortby.equals("Pairwise Identity"))
 221     {
 222       sortPairwiseMenuItem_actionPerformed(null);
 223     }
 224
 225     if (Desktop.desktop != null)
 226     {
 227       this.setDropTarget(new java.awt.dnd.DropTarget(this, this));
 228       addServiceListeners();
 229       setGUINucleotide(viewport.alignment.isNucleotide());
 230     }
 231
 232     setMenusFromViewport(viewport);
 233     buildSortByAnnotationScoresMenu();
 234     if (viewport.wrapAlignment)
 235     {
 236       wrapMenuItem_actionPerformed(null);
 237     }
 238
 239     if (jalview.bin.Cache.getDefault("SHOW_OVERVIEW", false))
 240     {
 241       this.overviewMenuItem_actionPerformed(null);
 242     }
 243
 244     addKeyListener();
 245
 246   }
 247
 248   /**
 249    * Change the filename and format for the alignment, and enable the 'reload'
 250    * button functionality.
 251    *
 252    * @param file
 253    *          valid filename
 254    * @param format
 255    *          format of file
 256    */
 257   public void setFileName(String file, String format)
 258   {
 259     fileName = file;
 260     currentFileFormat = format;
 261     reload.setEnabled(true);
 262   }
 263
 264   void addKeyListener()
 265   {
 266     addKeyListener(new KeyAdapter()
 267     {
 268       public void keyPressed(KeyEvent evt)
 269       {
 270         if (viewport.cursorMode
 271                 && ((evt.getKeyCode() >= KeyEvent.VK_0 && evt.getKeyCode() <= KeyEvent.VK_9) || (evt
 272                         .getKeyCode() >= KeyEvent.VK_NUMPAD0 && evt
 273                         .getKeyCode() <= KeyEvent.VK_NUMPAD9))
 274                 && Character.isDigit(evt.getKeyChar()))
 275           alignPanel.seqPanel.numberPressed(evt.getKeyChar());
 276
 277         switch (evt.getKeyCode())
 278         {
 279
 280         case 27: // escape key
 281           deselectAllSequenceMenuItem_actionPerformed(null);
 282
 283           break;
 284
 285         case KeyEvent.VK_DOWN:
 286           if (evt.isAltDown() || !viewport.cursorMode)
 287             moveSelectedSequences(false);
 288           if (viewport.cursorMode)
 289             alignPanel.seqPanel.moveCursor(0, 1);
 290           break;
 291
 292         case KeyEvent.VK_UP:
 293           if (evt.isAltDown() || !viewport.cursorMode)
 294             moveSelectedSequences(true);
 295           if (viewport.cursorMode)
 296             alignPanel.seqPanel.moveCursor(0, -1);
 297
 298           break;
 299
 300         case KeyEvent.VK_LEFT:
 301           if (evt.isAltDown() || !viewport.cursorMode)
 302             slideSequences(false, alignPanel.seqPanel.getKeyboardNo1());
 303           else
 304             alignPanel.seqPanel.moveCursor(-1, 0);
 305
 306           break;
 307
 308         case KeyEvent.VK_RIGHT:
 309           if (evt.isAltDown() || !viewport.cursorMode)
 310             slideSequences(true, alignPanel.seqPanel.getKeyboardNo1());
 311           else
 312             alignPanel.seqPanel.moveCursor(1, 0);
 313           break;
 314
 315         case KeyEvent.VK_SPACE:
 316           if (viewport.cursorMode)
 317           {
 318             alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown()
 319                     || evt.isShiftDown() || evt.isAltDown());
 320           }
 321           break;
 322
 323         case KeyEvent.VK_DELETE:
 324         case KeyEvent.VK_BACK_SPACE:
 325           if (!viewport.cursorMode)
 326           {
 327             cut_actionPerformed(null);
 328           }
 329           else
 330           {
 331             alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown()
 332                     || evt.isShiftDown() || evt.isAltDown());
 333           }
 334
 335           break;
 336
 337         case KeyEvent.VK_S:
 338           if (viewport.cursorMode)
 339           {
 340             alignPanel.seqPanel.setCursorRow();
 341           }
 342           break;
 343         case KeyEvent.VK_C:
 344           if (viewport.cursorMode && !evt.isControlDown())
 345           {
 346             alignPanel.seqPanel.setCursorColumn();
 347           }
 348           break;
 349         case KeyEvent.VK_P:
 350           if (viewport.cursorMode)
 351           {
 352             alignPanel.seqPanel.setCursorPosition();
 353           }
 354           break;
 355
 356         case KeyEvent.VK_ENTER:
 357         case KeyEvent.VK_COMMA:
 358           if (viewport.cursorMode)
 359           {
 360             alignPanel.seqPanel.setCursorRowAndColumn();
 361           }
 362           break;
 363
 364         case KeyEvent.VK_Q:
 365           if (viewport.cursorMode)
 366           {
 367             alignPanel.seqPanel.setSelectionAreaAtCursor(true);
 368           }
 369           break;
 370         case KeyEvent.VK_M:
 371           if (viewport.cursorMode)
 372           {
 373             alignPanel.seqPanel.setSelectionAreaAtCursor(false);
 374           }
 375           break;
 376
 377         case KeyEvent.VK_F2:
 378           viewport.cursorMode = !viewport.cursorMode;
 379           statusBar.setText("Keyboard editing mode is "
 380                   + (viewport.cursorMode ? "on" : "off"));
 381           if (viewport.cursorMode)
 382           {
 383             alignPanel.seqPanel.seqCanvas.cursorX = viewport.startRes;
 384             alignPanel.seqPanel.seqCanvas.cursorY = viewport.startSeq;
 385           }
 386           alignPanel.seqPanel.seqCanvas.repaint();
 387           break;
 388
 389         case KeyEvent.VK_F1:
 390           try
 391           {
 392             ClassLoader cl = jalview.gui.Desktop.class.getClassLoader();
 393             java.net.URL url = javax.help.HelpSet.findHelpSet(cl,
 394                     "help/help");
 395             javax.help.HelpSet hs = new javax.help.HelpSet(cl, url);
 396
 397             javax.help.HelpBroker hb = hs.createHelpBroker();
 398             hb.setCurrentID("home");
 399             hb.setDisplayed(true);
 400           } catch (Exception ex)
 401           {
 402             ex.printStackTrace();
 403           }
 404           break;
 405         case KeyEvent.VK_H:
 406         {
 407           boolean toggleSeqs = !evt.isControlDown();
 408           boolean toggleCols = !evt.isShiftDown();
 409           toggleHiddenRegions(toggleSeqs,toggleCols);
 410                     break;
 411         }
 412         case KeyEvent.VK_PAGE_UP:
 413           if (viewport.wrapAlignment)
 414           {
 415             alignPanel.scrollUp(true);
 416           }
 417           else
 418           {
 419             alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
 420                     - viewport.endSeq + viewport.startSeq);
 421           }
 422           break;
 423         case KeyEvent.VK_PAGE_DOWN:
 424           if (viewport.wrapAlignment)
 425           {
 426             alignPanel.scrollUp(false);
 427           }
 428           else
 429           {
 430             alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
 431                     + viewport.endSeq - viewport.startSeq);
 432           }
 433           break;
 434         }
 435       }
 436
 437       public void keyReleased(KeyEvent evt)
 438       {
 439         switch (evt.getKeyCode())
 440         {
 441         case KeyEvent.VK_LEFT:
 442           if (evt.isAltDown() || !viewport.cursorMode)
 443             viewport.firePropertyChange("alignment", null, viewport
 444                     .getAlignment().getSequences());
 445           break;
 446
 447         case KeyEvent.VK_RIGHT:
 448           if (evt.isAltDown() || !viewport.cursorMode)
 449             viewport.firePropertyChange("alignment", null, viewport
 450                     .getAlignment().getSequences());
 451           break;
 452         }
 453       }
 454     });
 455   }
 456
 457   public void addAlignmentPanel(final AlignmentPanel ap, boolean newPanel)
 458   {
 459     ap.alignFrame = this;
 460
 461     alignPanels.addElement(ap);
 462
 463     PaintRefresher.Register(ap, ap.av.getSequenceSetId());
 464
 465     int aSize = alignPanels.size();
 466
 467     tabbedPane.setVisible(aSize > 1 || ap.av.viewName != null);
 468
 469     if (aSize == 1 && ap.av.viewName == null)
 470     {
 471       this.getContentPane().add(ap, BorderLayout.CENTER);
 472     }
 473     else
 474     {
 475       if (aSize == 2)
 476       {
 477         setInitialTabVisible();
 478       }
 479
 480       expandViews.setEnabled(true);
 481       gatherViews.setEnabled(true);
 482       tabbedPane.addTab(ap.av.viewName, ap);
 483
 484       ap.setVisible(false);
 485     }
 486
 487     if (newPanel)
 488     {
 489       if (ap.av.padGaps)
 490       {
 491         ap.av.alignment.padGaps();
 492       }
 493       ap.av.updateConservation(ap);
 494       ap.av.updateConsensus(ap);
 495     }
 496   }
 497
 498   public void setInitialTabVisible()
 499   {
 500     expandViews.setEnabled(true);
 501     gatherViews.setEnabled(true);
 502     tabbedPane.setVisible(true);
 503     AlignmentPanel first = (AlignmentPanel) alignPanels.firstElement();
 504     tabbedPane.addTab(first.av.viewName, first);
 505     this.getContentPane().add(tabbedPane, BorderLayout.CENTER);
 506   }
 507
 508   public AlignViewport getViewport()
 509   {
 510     return viewport;
 511   }
 512
 513   /* Set up intrinsic listeners for dynamically generated GUI bits. */
 514   private void addServiceListeners()
 515   {
 516     final java.beans.PropertyChangeListener thisListener;
 517     // Do this once to get current state
 518     BuildWebServiceMenu();
 519     Desktop.discoverer
 520             .addPropertyChangeListener(thisListener = new java.beans.PropertyChangeListener()
 521             {
 522               public void propertyChange(PropertyChangeEvent evt)
 523               {
 524                 // System.out.println("Discoverer property change.");
 525                 if (evt.getPropertyName().equals("services"))
 526                 {
 527                   // System.out.println("Rebuilding web service menu");
 528                   BuildWebServiceMenu();
 529                 }
 530               }
 531             });
 532
 533     addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
 534     {
 535       public void internalFrameClosed(
 536               javax.swing.event.InternalFrameEvent evt)
 537       {
 538         // System.out.println("deregistering discoverer listener");
 539         Desktop.discoverer.removePropertyChangeListener(thisListener);
 540         closeMenuItem_actionPerformed(true);
 541       };
 542     });
 543   }
 544
 545   public void setGUINucleotide(boolean nucleotide)
 546   {
 547     showTranslation.setVisible(nucleotide);
 548     conservationMenuItem.setEnabled(!nucleotide);
 549     modifyConservation.setEnabled(!nucleotide);
 550     showGroupConservation.setEnabled(!nucleotide);
 551     // Remember AlignFrame always starts as protein
 552     if (!nucleotide)
 553     {
 554       calculateMenu.remove(calculateMenu.getItemCount() - 2);
 555     }
 556   }
 557
 558   /**
 559    * set up menus for the currently viewport. This may be called after any
 560    * operation that affects the data in the current view (selection changed,
 561    * etc) to update the menus to reflect the new state.
 562    */
 563   public void setMenusForViewport()
 564   {
 565     setMenusFromViewport(viewport);
 566   }
 567
 568   /**
 569    * Need to call this method when tabs are selected for multiple views, or when
 570    * loading from Jalview2XML.java
 571    *
 572    * @param av
 573    *          AlignViewport
 574    */
 575   void setMenusFromViewport(AlignViewport av)
 576   {
 577     padGapsMenuitem.setSelected(av.padGaps);
 578     colourTextMenuItem.setSelected(av.showColourText);
 579     abovePIDThreshold.setSelected(av.getAbovePIDThreshold());
 580     conservationMenuItem.setSelected(av.getConservationSelected());
 581     seqLimits.setSelected(av.getShowJVSuffix());
 582     idRightAlign.setSelected(av.rightAlignIds);
 583     centreColumnLabelsMenuItem.setState(av.centreColumnLabels);
 584     renderGapsMenuItem.setSelected(av.renderGaps);
 585     wrapMenuItem.setSelected(av.wrapAlignment);
 586     scaleAbove.setVisible(av.wrapAlignment);
 587     scaleLeft.setVisible(av.wrapAlignment);
 588     scaleRight.setVisible(av.wrapAlignment);
 589     annotationPanelMenuItem.setState(av.showAnnotation);
 590     viewBoxesMenuItem.setSelected(av.showBoxes);
 591     viewTextMenuItem.setSelected(av.showText);
 592     showUnconservedMenuItem.setSelected(av.showUnconserved);
 593     showGroupConsensus.setSelected(av.showGroupConsensus);
 594     showGroupConservation.setSelected(av.showGroupConservation);
 595     showConsensusHistogram.setSelected(av.showConsensusHistogram);
 596     showSequenceLogo.setSelected(av.showSequenceLogo);
 597     setColourSelected(ColourSchemeProperty.getColourName(av
 598             .getGlobalColourScheme()));
 599
 600     showSeqFeatures.setSelected(av.showSequenceFeatures);
 601     hiddenMarkers.setState(av.showHiddenMarkers);
 602     applyToAllGroups.setState(av.colourAppliesToAllGroups);
 603     showNpFeatsMenuitem.setSelected(av.isShowNpFeats());
 604     showDbRefsMenuitem.setSelected(av.isShowDbRefs());
 605
 606     setShowProductsEnabled();
 607
 608     updateEditMenuBar();
 609   }
 610
 611   Hashtable progressBars, progressBarHandlers;
 612
 613   /*
 614    * (non-Javadoc)
 615    *
 616    * @see jalview.gui.IProgressIndicator#setProgressBar(java.lang.String, long)
 617    */
 618   public void setProgressBar(String message, long id)
 619   {
 620     if (progressBars == null)
 621     {
 622       progressBars = new Hashtable();
 623       progressBarHandlers = new Hashtable();
 624     }
 625
 626     JPanel progressPanel;
 627     Long lId=new Long(id);
 628     GridLayout layout = (GridLayout) statusPanel.getLayout();
 629     if (progressBars.get(lId) != null)
 630     {
 631       progressPanel = (JPanel) progressBars.get(new Long(id));
 632       statusPanel.remove(progressPanel);
 633       progressBars.remove(lId);
 634       progressPanel = null;
 635       if (message != null)
 636       {
 637         statusBar.setText(message);
 638       }
 639       if (progressBarHandlers.contains(lId))
 640       {
 641         progressBarHandlers.remove(lId);
 642       }
 643       layout.setRows(layout.getRows() - 1);
 644     }
 645     else
 646     {
 647       progressPanel = new JPanel(new BorderLayout(10, 5));
 648
 649       JProgressBar progressBar = new JProgressBar();
 650       progressBar.setIndeterminate(true);
 651
 652       progressPanel.add(new JLabel(message), BorderLayout.WEST);
 653       progressPanel.add(progressBar, BorderLayout.CENTER);
 654
 655       layout.setRows(layout.getRows() + 1);
 656       statusPanel.add(progressPanel);
 657
 658       progressBars.put(lId, progressPanel);
 659     }
 660     // update GUI
 661     setMenusForViewport();
 662     validate();
 663   }
 664
 665   public void registerHandler(final long id,
 666           final IProgressIndicatorHandler handler)
 667   {
 668     if (progressBarHandlers == null || !progressBars.contains(new Long(id)))
 669     {
 670       throw new Error(
 671               "call setProgressBar before registering the progress bar's handler.");
 672     }
 673     progressBarHandlers.put(new Long(id), handler);
 674     final JPanel progressPanel = (JPanel) progressBars.get(new Long(id));
 675     if (handler.canCancel())
 676     {
 677       JButton cancel = new JButton("Cancel");
 678       final IProgressIndicator us = this;
 679       cancel.addActionListener(new ActionListener()
 680       {
 681
 682         public void actionPerformed(ActionEvent e)
 683         {
 684           handler.cancelActivity(id);
 685           us.setProgressBar("Cancelled "
 686                   + ((JLabel) progressPanel.getComponent(0)).getText(), id);
 687         }
 688       });
 689       progressPanel.add(cancel, BorderLayout.EAST);
 690     }
 691   }
 692
 693   /**
 694    *
 695    * @return true if any progress bars are still active
 696    */
 697   public boolean operationInProgress()
 698   {
 699     if (progressBars != null && progressBars.size() > 0)
 700     {
 701       return true;
 702     }
 703     return false;
 704   }
 705
 706   /*
 707    * Added so Castor Mapping file can obtain Jalview Version
 708    */
 709   public String getVersion()
 710   {
 711     return jalview.bin.Cache.getProperty("VERSION");
 712   }
 713
 714   public FeatureRenderer getFeatureRenderer()
 715   {
 716     return alignPanel.seqPanel.seqCanvas.getFeatureRenderer();
 717   }
 718
 719   public void fetchSequence_actionPerformed(ActionEvent e)
 720   {
 721     new SequenceFetcher(this);
 722   }
 723
 724   public void addFromFile_actionPerformed(ActionEvent e)
 725   {
 726     Desktop.instance.inputLocalFileMenuItem_actionPerformed(viewport);
 727   }
 728
 729   public void reload_actionPerformed(ActionEvent e)
 730   {
 731     if (fileName != null)
 732     {
 733       // TODO: work out how to recover feature settings for correct view(s) when file is reloaded.
 734       if (currentFileFormat.equals("Jalview"))
 735       {
 736         JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 737         for (int i = 0; i < frames.length; i++)
 738         {
 739           if (frames[i] instanceof AlignFrame && frames[i] != this
 740                   && ((AlignFrame) frames[i]).fileName.equals(fileName))
 741           {
 742             try
 743             {
 744               frames[i].setSelected(true);
 745               Desktop.instance.closeAssociatedWindows();
 746             } catch (java.beans.PropertyVetoException ex)
 747             {
 748             }
 749           }
 750
 751         }
 752         Desktop.instance.closeAssociatedWindows();
 753
 754         FileLoader loader = new FileLoader();
 755         String protocol = fileName.startsWith("http:") ? "URL" : "File";
 756         loader.LoadFile(viewport, fileName, protocol, currentFileFormat);
 757       }
 758       else
 759       {
 760         Rectangle bounds = this.getBounds();
 761
 762         FileLoader loader = new FileLoader();
 763         String protocol = fileName.startsWith("http:") ? "URL" : "File";
 764         AlignFrame newframe = loader.LoadFileWaitTillLoaded(fileName,
 765                 protocol, currentFileFormat);
 766
 767         newframe.setBounds(bounds);
 768         if (featureSettings!=null && featureSettings.isShowing()) {
 769           final Rectangle fspos = featureSettings.frame.getBounds();
 770           // TODO: need a 'show feature settings' function that takes bounds - need to refactor Desktop.addFrame
 771           newframe.featureSettings_actionPerformed(null);
 772           final FeatureSettings nfs = newframe.featureSettings;
 773           SwingUtilities.invokeLater(new Runnable() {
 774             public void run()
 775             {
 776               nfs.frame.setBounds(fspos);
 777             }
 778           });
 779           this.featureSettings.close();
 780           this.featureSettings=null;
 781         }
 782         this.closeMenuItem_actionPerformed(true);
 783       }
 784     }
 785   }
 786
 787   public void addFromText_actionPerformed(ActionEvent e)
 788   {
 789     Desktop.instance.inputTextboxMenuItem_actionPerformed(viewport);
 790   }
 791
 792   public void addFromURL_actionPerformed(ActionEvent e)
 793   {
 794     Desktop.instance.inputURLMenuItem_actionPerformed(viewport);
 795   }
 796
 797   public void save_actionPerformed(ActionEvent e)
 798   {
 799     if (fileName == null
 800             || (currentFileFormat == null || !jalview.io.FormatAdapter
 801                     .isValidIOFormat(currentFileFormat, true))
 802             || fileName.startsWith("http"))
 803     {
 804       saveAs_actionPerformed(null);
 805     }
 806     else
 807     {
 808       saveAlignment(fileName, currentFileFormat);
 809     }
 810   }
 811
 812   /**
 813    * DOCUMENT ME!
 814    *
 815    * @param e
 816    *          DOCUMENT ME!
 817    */
 818   public void saveAs_actionPerformed(ActionEvent e)
 819   {
 820     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache
 821             .getProperty("LAST_DIRECTORY"),
 822             jalview.io.AppletFormatAdapter.WRITABLE_EXTENSIONS,
 823             jalview.io.AppletFormatAdapter.WRITABLE_FNAMES,
 824             currentFileFormat, false);
 825
 826     chooser.setFileView(new JalviewFileView());
 827     chooser.setDialogTitle("Save Alignment to file");
 828     chooser.setToolTipText("Save");
 829
 830     int value = chooser.showSaveDialog(this);
 831
 832     if (value == JalviewFileChooser.APPROVE_OPTION)
 833     {
 834       currentFileFormat = chooser.getSelectedFormat();
 835       if (currentFileFormat == null)
 836       {
 837         JOptionPane.showInternalMessageDialog(Desktop.desktop,
 838                 "You must select a file format before saving!",
 839                 "File format not specified", JOptionPane.WARNING_MESSAGE);
 840         value = chooser.showSaveDialog(this);
 841         return;
 842       }
 843
 844       fileName = chooser.getSelectedFile().getPath();
 845
 846       jalview.bin.Cache.setProperty("DEFAULT_FILE_FORMAT",
 847               currentFileFormat);
 848
 849       jalview.bin.Cache.setProperty("LAST_DIRECTORY", fileName);
 850       if (currentFileFormat.indexOf(" ") > -1)
 851       {
 852         currentFileFormat = currentFileFormat.substring(0,
 853                 currentFileFormat.indexOf(" "));
 854       }
 855       saveAlignment(fileName, currentFileFormat);
 856     }
 857   }
 858
 859   public boolean saveAlignment(String file, String format)
 860   {
 861     boolean success = true;
 862
 863     if (format.equalsIgnoreCase("Jalview"))
 864     {
 865       String shortName = title;
 866
 867       if (shortName.indexOf(java.io.File.separatorChar) > -1)
 868       {
 869         shortName = shortName.substring(shortName
 870                 .lastIndexOf(java.io.File.separatorChar) + 1);
 871       }
 872
 873       success = new Jalview2XML().SaveAlignment(this, file, shortName);
 874
 875       statusBar.setText("Successfully saved to file: " + fileName + " in "
 876               + format + " format.");
 877
 878     }
 879     else
 880     {
 881       if (!jalview.io.AppletFormatAdapter.isValidFormat(format, true))
 882       {
 883         warningMessage("Cannot save file " + fileName + " using format "
 884                 + format, "Alignment output format not supported");
 885         saveAs_actionPerformed(null);
 886         // JBPNote need to have a raise_gui flag here
 887         return false;
 888       }
 889
 890       String[] omitHidden = null;
 891
 892       if (viewport.hasHiddenColumns)
 893       {
 894         int reply = JOptionPane
 895                 .showInternalConfirmDialog(
 896                         Desktop.desktop,
 897                         "The Alignment contains hidden columns."
 898                                 + "\nDo you want to save only the visible alignment?",
 899                         "Save / Omit Hidden Columns",
 900                         JOptionPane.YES_NO_OPTION,
 901                         JOptionPane.QUESTION_MESSAGE);
 902
 903         if (reply == JOptionPane.YES_OPTION)
 904         {
 905           omitHidden = viewport.getViewAsString(false);
 906         }
 907       }
 908       FormatAdapter f = new FormatAdapter();
 909       String output = f.formatSequences(format,
 910               (Alignment) viewport.alignment, // class cast exceptions will
 911               // occur in the distant future
 912               omitHidden, f.getCacheSuffixDefault(format), viewport.colSel);
 913
 914       if (output == null)
 915       {
 916         success = false;
 917       }
 918       else
 919       {
 920         try
 921         {
 922           java.io.PrintWriter out = new java.io.PrintWriter(
 923                   new java.io.FileWriter(file));
 924
 925           out.print(output);
 926           out.close();
 927           this.setTitle(file);
 928           statusBar.setText("Successfully saved to file: " + fileName
 929                   + " in " + format + " format.");
 930         } catch (Exception ex)
 931         {
 932           success = false;
 933           ex.printStackTrace();
 934         }
 935       }
 936     }
 937
 938     if (!success)
 939     {
 940       JOptionPane.showInternalMessageDialog(this, "Couldn't save file: "
 941               + fileName, "Error Saving File", JOptionPane.WARNING_MESSAGE);
 942     }
 943
 944     return success;
 945   }
 946
 947   private void warningMessage(String warning, String title)
 948   {
 949     if (new jalview.util.Platform().isHeadless())
 950     {
 951       System.err.println("Warning: " + title + "\nWarning: " + warning);
 952
 953     }
 954     else
 955     {
 956       JOptionPane.showInternalMessageDialog(this, warning, title,
 957               JOptionPane.WARNING_MESSAGE);
 958     }
 959     return;
 960   }
 961
 962   /**
 963    * DOCUMENT ME!
 964    *
 965    * @param e
 966    *          DOCUMENT ME!
 967    */
 968   protected void outputText_actionPerformed(ActionEvent e)
 969   {
 970     String[] omitHidden = null;
 971
 972     if (viewport.hasHiddenColumns)
 973     {
 974       int reply = JOptionPane
 975               .showInternalConfirmDialog(
 976                       Desktop.desktop,
 977                       "The Alignment contains hidden columns."
 978                               + "\nDo you want to output only the visible alignment?",
 979                       "Save / Omit Hidden Columns",
 980                       JOptionPane.YES_NO_OPTION,
 981                       JOptionPane.QUESTION_MESSAGE);
 982
 983       if (reply == JOptionPane.YES_OPTION)
 984       {
 985         omitHidden = viewport.getViewAsString(false);
 986       }
 987     }
 988
 989     CutAndPasteTransfer cap = new CutAndPasteTransfer();
 990     cap.setForInput(null);
 991     Desktop.addInternalFrame(cap, "Alignment output - "
 992             + e.getActionCommand(), 600, 500);
 993
 994     cap.setText(new FormatAdapter().formatSequences(e.getActionCommand(),
 995             viewport.alignment, omitHidden, viewport.colSel));
 996   }
 997
 998   /**
 999    * DOCUMENT ME!
1000    *
1001    * @param e
1002    *          DOCUMENT ME!
1003    */
1004   protected void htmlMenuItem_actionPerformed(ActionEvent e)
1005   {
1006     new HTMLOutput(alignPanel, alignPanel.seqPanel.seqCanvas
1007             .getSequenceRenderer(), alignPanel.seqPanel.seqCanvas
1008             .getFeatureRenderer());
1009   }
1010
1011   public void createImageMap(File file, String image)
1012   {
1013     alignPanel.makePNGImageMap(file, image);
1014   }
1015
1016   /**
1017    * DOCUMENT ME!
1018    *
1019    * @param e
1020    *          DOCUMENT ME!
1021    */
1022   public void createPNG(File f)
1023   {
1024     alignPanel.makePNG(f);
1025   }
1026
1027   /**
1028    * DOCUMENT ME!
1029    *
1030    * @param e
1031    *          DOCUMENT ME!
1032    */
1033   public void createEPS(File f)
1034   {
1035     alignPanel.makeEPS(f);
1036   }
1037
1038   public void pageSetup_actionPerformed(ActionEvent e)
1039   {
1040     PrinterJob printJob = PrinterJob.getPrinterJob();
1041     PrintThread.pf = printJob.pageDialog(printJob.defaultPage());
1042   }
1043
1044   /**
1045    * DOCUMENT ME!
1046    *
1047    * @param e
1048    *          DOCUMENT ME!
1049    */
1050   public void printMenuItem_actionPerformed(ActionEvent e)
1051   {
1052     // Putting in a thread avoids Swing painting problems
1053     PrintThread thread = new PrintThread(alignPanel);
1054     thread.start();
1055   }
1056
1057   public void exportFeatures_actionPerformed(ActionEvent e)
1058   {
1059     new AnnotationExporter().exportFeatures(alignPanel);
1060   }
1061
1062   public void exportAnnotations_actionPerformed(ActionEvent e)
1063   {
1064     new AnnotationExporter().exportAnnotations(alignPanel,
1065             viewport.showAnnotation ? viewport.alignment
1066                     .getAlignmentAnnotation() : null, viewport.alignment
1067                     .getGroups(),
1068             ((Alignment) viewport.alignment).alignmentProperties);
1069   }
1070
1071   public void associatedData_actionPerformed(ActionEvent e)
1072   {
1073     // Pick the tree file
1074     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache
1075             .getProperty("LAST_DIRECTORY"));
1076     chooser.setFileView(new JalviewFileView());
1077     chooser.setDialogTitle("Load Jalview Annotations or Features File");
1078     chooser.setToolTipText("Load Jalview Annotations / Features file");
1079
1080     int value = chooser.showOpenDialog(null);
1081
1082     if (value == JalviewFileChooser.APPROVE_OPTION)
1083     {
1084       String choice = chooser.getSelectedFile().getPath();
1085       jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);
1086       loadJalviewDataFile(choice);
1087     }
1088
1089   }
1090
1091   /**
1092    * Close the current view or all views in the alignment frame. If the frame
1093    * only contains one view then the alignment will be removed from memory.
1094    *
1095    * @param closeAllTabs
1096    */
1097   public void closeMenuItem_actionPerformed(boolean closeAllTabs)
1098   {
1099     if (alignPanels != null && alignPanels.size() < 2)
1100     {
1101       closeAllTabs = true;
1102     }
1103
1104     try
1105     {
1106       if (alignPanels != null)
1107       {
1108         if (closeAllTabs)
1109         {
1110           if (this.isClosed())
1111           {
1112             // really close all the windows - otherwise wait till
1113             // setClosed(true) is called
1114             for (int i = 0; i < alignPanels.size(); i++)
1115             {
1116               AlignmentPanel ap = (AlignmentPanel) alignPanels.elementAt(i);
1117               ap.closePanel();
1118             }
1119           }
1120         }
1121         else
1122         {
1123           closeView(alignPanel);
1124         }
1125       }
1126
1127       if (closeAllTabs)
1128       {
1129         this.setClosed(true);
1130       }
1131     } catch (Exception ex)
1132     {
1133       ex.printStackTrace();
1134     }
1135   }
1136
1137   /**
1138    * close alignPanel2 and shuffle tabs appropriately.
1139    *
1140    * @param alignPanel2
1141    */
1142   public void closeView(AlignmentPanel alignPanel2)
1143   {
1144     int index = tabbedPane.getSelectedIndex();
1145     int closedindex = tabbedPane.indexOfComponent(alignPanel2);
1146     alignPanels.removeElement(alignPanel2);
1147     // Unnecessary
1148     // if (viewport == alignPanel2.av)
1149     // {
1150     // viewport = null;
1151     // }
1152     alignPanel2.closePanel();
1153     alignPanel2 = null;
1154
1155     tabbedPane.removeTabAt(closedindex);
1156     tabbedPane.validate();
1157
1158     if (index > closedindex || index == tabbedPane.getTabCount())
1159     {
1160       // modify currently selected tab index if necessary.
1161       index--;
1162     }
1163
1164     this.tabSelectionChanged(index);
1165   }
1166
1167   /**
1168    * DOCUMENT ME!
1169    */
1170   void updateEditMenuBar()
1171   {
1172
1173     if (viewport.historyList.size() > 0)
1174     {
1175       undoMenuItem.setEnabled(true);
1176       CommandI command = (CommandI) viewport.historyList.peek();
1177       undoMenuItem.setText("Undo " + command.getDescription());
1178     }
1179     else
1180     {
1181       undoMenuItem.setEnabled(false);
1182       undoMenuItem.setText("Undo");
1183     }
1184
1185     if (viewport.redoList.size() > 0)
1186     {
1187       redoMenuItem.setEnabled(true);
1188
1189       CommandI command = (CommandI) viewport.redoList.peek();
1190       redoMenuItem.setText("Redo " + command.getDescription());
1191     }
1192     else
1193     {
1194       redoMenuItem.setEnabled(false);
1195       redoMenuItem.setText("Redo");
1196     }
1197   }
1198
1199   public void addHistoryItem(CommandI command)
1200   {
1201     if (command.getSize() > 0)
1202     {
1203       viewport.historyList.push(command);
1204       viewport.redoList.clear();
1205       updateEditMenuBar();
1206       viewport.hasHiddenColumns = (viewport.colSel!=null && viewport.colSel.getHiddenColumns() != null && viewport.colSel.getHiddenColumns().size()>0);
1207     }
1208   }
1209
1210   /**
1211    *
1212    * @return alignment objects for all views
1213    */
1214   AlignmentI[] getViewAlignments()
1215   {
1216     if (alignPanels != null)
1217     {
1218       Enumeration e = alignPanels.elements();
1219       AlignmentI[] als = new AlignmentI[alignPanels.size()];
1220       for (int i = 0; e.hasMoreElements(); i++)
1221       {
1222         als[i] = ((AlignmentPanel) e.nextElement()).av.getAlignment();
1223       }
1224       return als;
1225     }
1226     if (viewport != null)
1227     {
1228       return new AlignmentI[]
1229       { viewport.alignment };
1230     }
1231     return null;
1232   }
1233
1234   /**
1235    * DOCUMENT ME!
1236    *
1237    * @param e
1238    *          DOCUMENT ME!
1239    */
1240   protected void undoMenuItem_actionPerformed(ActionEvent e)
1241   {
1242     if (viewport.historyList.empty())
1243       return;
1244     CommandI command = (CommandI) viewport.historyList.pop();
1245     viewport.redoList.push(command);
1246     command.undoCommand(getViewAlignments());
1247
1248     AlignViewport originalSource = getOriginatingSource(command);
1249     updateEditMenuBar();
1250
1251     if (originalSource != null)
1252     {
1253       originalSource.hasHiddenColumns = (viewport.colSel!=null && viewport.colSel.getHiddenColumns() != null && viewport.colSel.getHiddenColumns().size()>0);
1254       originalSource.firePropertyChange("alignment", null,
1255               originalSource.alignment.getSequences());
1256     }
1257   }
1258
1259   /**
1260    * DOCUMENT ME!
1261    *
1262    * @param e
1263    *          DOCUMENT ME!
1264    */
1265   protected void redoMenuItem_actionPerformed(ActionEvent e)
1266   {
1267     if (viewport.redoList.size() < 1)
1268     {
1269       return;
1270     }
1271
1272     CommandI command = (CommandI) viewport.redoList.pop();
1273     viewport.historyList.push(command);
1274     command.doCommand(getViewAlignments());
1275
1276     AlignViewport originalSource = getOriginatingSource(command);
1277     updateEditMenuBar();
1278
1279     if (originalSource != null)
1280     {
1281       originalSource.hasHiddenColumns = (viewport.colSel!=null && viewport.colSel.getHiddenColumns() != null && viewport.colSel.getHiddenColumns().size()>0);
1282       originalSource.firePropertyChange("alignment", null,
1283               originalSource.alignment.getSequences());
1284     }
1285   }
1286
1287   AlignViewport getOriginatingSource(CommandI command)
1288   {
1289     AlignViewport originalSource = null;
1290     // For sequence removal and addition, we need to fire
1291     // the property change event FROM the viewport where the
1292     // original alignment was altered
1293     AlignmentI al = null;
1294     if (command instanceof EditCommand)
1295     {
1296       EditCommand editCommand = (EditCommand) command;
1297       al = editCommand.getAlignment();
1298       Vector comps = (Vector) PaintRefresher.components.get(viewport
1299               .getSequenceSetId());
1300
1301       for (int i = 0; i < comps.size(); i++)
1302       {
1303         if (comps.elementAt(i) instanceof AlignmentPanel)
1304         {
1305           if (al == ((AlignmentPanel) comps.elementAt(i)).av.alignment)
1306           {
1307             originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
1308             break;
1309           }
1310         }
1311       }
1312     }
1313
1314     if (originalSource == null)
1315     {
1316       // The original view is closed, we must validate
1317       // the current view against the closed view first
1318       if (al != null)
1319       {
1320         PaintRefresher.validateSequences(al, viewport.alignment);
1321       }
1322
1323       originalSource = viewport;
1324     }
1325
1326     return originalSource;
1327   }
1328
1329   /**
1330    * DOCUMENT ME!
1331    *
1332    * @param up
1333    *          DOCUMENT ME!
1334    */
1335   public void moveSelectedSequences(boolean up)
1336   {
1337     SequenceGroup sg = viewport.getSelectionGroup();
1338
1339     if (sg == null)
1340     {
1341       return;
1342     }
1343
1344     if (up)
1345     {
1346       for (int i = 1; i < viewport.alignment.getHeight(); i++)
1347       {
1348         SequenceI seq = viewport.alignment.getSequenceAt(i);
1349
1350         if (!sg.getSequences(null).contains(seq))
1351         {
1352           continue;
1353         }
1354
1355         SequenceI temp = viewport.alignment.getSequenceAt(i - 1);
1356
1357         if (sg.getSequences(null).contains(temp))
1358         {
1359           continue;
1360         }
1361
1362         viewport.alignment.getSequences().setElementAt(temp, i);
1363         viewport.alignment.getSequences().setElementAt(seq, i - 1);
1364       }
1365     }
1366     else
1367     {
1368       for (int i = viewport.alignment.getHeight() - 2; i > -1; i--)
1369       {
1370         SequenceI seq = viewport.alignment.getSequenceAt(i);
1371
1372         if (!sg.getSequences(null).contains(seq))
1373         {
1374           continue;
1375         }
1376
1377         SequenceI temp = viewport.alignment.getSequenceAt(i + 1);
1378
1379         if (sg.getSequences(null).contains(temp))
1380         {
1381           continue;
1382         }
1383
1384         viewport.alignment.getSequences().setElementAt(temp, i);
1385         viewport.alignment.getSequences().setElementAt(seq, i + 1);
1386       }
1387     }
1388
1389     alignPanel.paintAlignment(true);
1390   }
1391
1392   synchronized void slideSequences(boolean right, int size)
1393   {
1394     Vector sg = new Vector();
1395     if (viewport.cursorMode)
1396     {
1397       sg.addElement(viewport.alignment
1398               .getSequenceAt(alignPanel.seqPanel.seqCanvas.cursorY));
1399     }
1400     else if (viewport.getSelectionGroup() != null
1401             && viewport.getSelectionGroup().getSize() != viewport.alignment
1402                     .getHeight())
1403     {
1404       sg = viewport.getSelectionGroup().getSequences(
1405               viewport.hiddenRepSequences);
1406     }
1407
1408     if (sg.size() < 1)
1409     {
1410       return;
1411     }
1412
1413     Vector invertGroup = new Vector();
1414
1415     for (int i = 0; i < viewport.alignment.getHeight(); i++)
1416     {
1417       if (!sg.contains(viewport.alignment.getSequenceAt(i)))
1418         invertGroup.add(viewport.alignment.getSequenceAt(i));
1419     }
1420
1421     SequenceI[] seqs1 = new SequenceI[sg.size()];
1422     for (int i = 0; i < sg.size(); i++)
1423       seqs1[i] = (SequenceI) sg.elementAt(i);
1424
1425     SequenceI[] seqs2 = new SequenceI[invertGroup.size()];
1426     for (int i = 0; i < invertGroup.size(); i++)
1427       seqs2[i] = (SequenceI) invertGroup.elementAt(i);
1428
1429     SlideSequencesCommand ssc;
1430     if (right)
1431       ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1,
1432               size, viewport.getGapCharacter());
1433     else
1434       ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2,
1435               size, viewport.getGapCharacter());
1436
1437     int groupAdjustment = 0;
1438     if (ssc.getGapsInsertedBegin() && right)
1439     {
1440       if (viewport.cursorMode)
1441         alignPanel.seqPanel.moveCursor(size, 0);
1442       else
1443         groupAdjustment = size;
1444     }
1445     else if (!ssc.getGapsInsertedBegin() && !right)
1446     {
1447       if (viewport.cursorMode)
1448         alignPanel.seqPanel.moveCursor(-size, 0);
1449       else
1450         groupAdjustment = -size;
1451     }
1452
1453     if (groupAdjustment != 0)
1454     {
1455       viewport.getSelectionGroup().setStartRes(
1456               viewport.getSelectionGroup().getStartRes() + groupAdjustment);
1457       viewport.getSelectionGroup().setEndRes(
1458               viewport.getSelectionGroup().getEndRes() + groupAdjustment);
1459     }
1460
1461     boolean appendHistoryItem = false;
1462     if (viewport.historyList != null && viewport.historyList.size() > 0
1463             && viewport.historyList.peek() instanceof SlideSequencesCommand)
1464     {
1465       appendHistoryItem = ssc
1466               .appendSlideCommand((SlideSequencesCommand) viewport.historyList
1467                       .peek());
1468     }
1469
1470     if (!appendHistoryItem)
1471       addHistoryItem(ssc);
1472
1473     repaint();
1474   }
1475
1476   /**
1477    * DOCUMENT ME!
1478    *
1479    * @param e
1480    *          DOCUMENT ME!
1481    */
1482   protected void copy_actionPerformed(ActionEvent e)
1483   {
1484     System.gc();
1485     if (viewport.getSelectionGroup() == null)
1486     {
1487       return;
1488     }
1489     // TODO: preserve the ordering of displayed alignment annotation in any
1490     // internal paste (particularly sequence associated annotation)
1491     SequenceI[] seqs = viewport.getSelectionAsNewSequence();
1492     String[] omitHidden = null;
1493
1494     if (viewport.hasHiddenColumns)
1495     {
1496       omitHidden = viewport.getViewAsString(true);
1497     }
1498
1499     String output = new FormatAdapter().formatSequences("Fasta", seqs,
1500             omitHidden);
1501
1502     StringSelection ss = new StringSelection(output);
1503
1504     try
1505     {
1506       jalview.gui.Desktop.internalCopy = true;
1507       // Its really worth setting the clipboard contents
1508       // to empty before setting the large StringSelection!!
1509       Toolkit.getDefaultToolkit().getSystemClipboard().setContents(
1510               new StringSelection(""), null);
1511
1512       Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss,
1513               Desktop.instance);
1514     } catch (OutOfMemoryError er)
1515     {
1516       new OOMWarning("copying region", er);
1517       return;
1518     }
1519
1520     Vector hiddenColumns = null;
1521     if (viewport.hasHiddenColumns)
1522     {
1523       hiddenColumns = new Vector();
1524       int hiddenOffset = viewport.getSelectionGroup().getStartRes();
1525       for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns()
1526               .size(); i++)
1527       {
1528         int[] region = (int[]) viewport.getColumnSelection()
1529                 .getHiddenColumns().elementAt(i);
1530
1531         hiddenColumns.addElement(new int[]
1532         { region[0] - hiddenOffset, region[1] - hiddenOffset });
1533       }
1534     }
1535
1536     Desktop.jalviewClipboard = new Object[]
1537     { seqs, viewport.alignment.getDataset(), hiddenColumns };
1538     statusBar.setText("Copied " + seqs.length + " sequences to clipboard.");
1539   }
1540
1541   /**
1542    * DOCUMENT ME!
1543    *
1544    * @param e
1545    *          DOCUMENT ME!
1546    */
1547   protected void pasteNew_actionPerformed(ActionEvent e)
1548   {
1549     paste(true);
1550   }
1551
1552   /**
1553    * DOCUMENT ME!
1554    *
1555    * @param e
1556    *          DOCUMENT ME!
1557    */
1558   protected void pasteThis_actionPerformed(ActionEvent e)
1559   {
1560     paste(false);
1561   }
1562
1563   /**
1564    * Paste contents of Jalview clipboard
1565    *
1566    * @param newAlignment
1567    *          true to paste to a new alignment, otherwise add to this.
1568    */
1569   void paste(boolean newAlignment)
1570   {
1571     boolean externalPaste = true;
1572     try
1573     {
1574       Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();
1575       Transferable contents = c.getContents(this);
1576
1577       if (contents == null)
1578       {
1579         return;
1580       }
1581
1582       String str, format;
1583       try
1584       {
1585         str = (String) contents.getTransferData(DataFlavor.stringFlavor);
1586         if (str.length() < 1)
1587         {
1588           return;
1589         }
1590
1591         format = new IdentifyFile().Identify(str, "Paste");
1592
1593       } catch (OutOfMemoryError er)
1594       {
1595         new OOMWarning("Out of memory pasting sequences!!", er);
1596         return;
1597       }
1598
1599       SequenceI[] sequences;
1600       boolean annotationAdded = false;
1601       AlignmentI alignment = null;
1602
1603       if (Desktop.jalviewClipboard != null)
1604       {
1605         // The clipboard was filled from within Jalview, we must use the
1606         // sequences
1607         // And dataset from the copied alignment
1608         SequenceI[] newseq = (SequenceI[]) Desktop.jalviewClipboard[0];
1609         // be doubly sure that we create *new* sequence objects.
1610         sequences = new SequenceI[newseq.length];
1611         for (int i = 0; i < newseq.length; i++)
1612         {
1613           sequences[i] = new Sequence(newseq[i]);
1614         }
1615         alignment = new Alignment(sequences);
1616         externalPaste = false;
1617       }
1618       else
1619       {
1620         // parse the clipboard as an alignment.
1621         alignment = new FormatAdapter().readFile(str, "Paste", format);
1622         sequences = alignment.getSequencesArray();
1623       }
1624
1625       int alwidth = 0;
1626
1627       if (newAlignment)
1628       {
1629
1630         if (Desktop.jalviewClipboard != null)
1631         {
1632           // dataset is inherited
1633           alignment.setDataset((Alignment) Desktop.jalviewClipboard[1]);
1634         }
1635         else
1636         {
1637           // new dataset is constructed
1638           alignment.setDataset(null);
1639         }
1640         alwidth = alignment.getWidth() + 1;
1641       }
1642       else
1643       {
1644         AlignmentI pastedal = alignment; // preserve pasted alignment object
1645         // Add pasted sequences and dataset into existing alignment.
1646         alignment = viewport.getAlignment();
1647         alwidth = alignment.getWidth() + 1;
1648         // decide if we need to import sequences from an existing dataset
1649         boolean importDs = Desktop.jalviewClipboard != null
1650                 && Desktop.jalviewClipboard[1] != alignment.getDataset();
1651         // importDs==true instructs us to copy over new dataset sequences from
1652         // an existing alignment
1653         Vector newDs = (importDs) ? new Vector() : null; // used to create
1654         // minimum dataset set
1655
1656         for (int i = 0; i < sequences.length; i++)
1657         {
1658           if (importDs)
1659           {
1660             newDs.addElement(null);
1661           }
1662           SequenceI ds = sequences[i].getDatasetSequence(); // null for a simple
1663           // paste
1664           if (importDs && ds != null)
1665           {
1666             if (!newDs.contains(ds))
1667             {
1668               newDs.setElementAt(ds, i);
1669               ds = new Sequence(ds);
1670               // update with new dataset sequence
1671               sequences[i].setDatasetSequence(ds);
1672             }
1673             else
1674             {
1675               ds = sequences[newDs.indexOf(ds)].getDatasetSequence();
1676             }
1677           }
1678           else
1679           {
1680             // copy and derive new dataset sequence
1681             sequences[i] = sequences[i].deriveSequence();
1682             alignment.getDataset().addSequence(
1683                     sequences[i].getDatasetSequence());
1684             // TODO: avoid creation of duplicate dataset sequences with a
1685             // 'contains' method using SequenceI.equals()/SequenceI.contains()
1686           }
1687           alignment.addSequence(sequences[i]); // merges dataset
1688         }
1689         if (newDs != null)
1690         {
1691           newDs.clear(); // tidy up
1692         }
1693         if (pastedal.getAlignmentAnnotation() != null)
1694         {
1695           // Add any annotation attached to alignment.
1696           AlignmentAnnotation[] alann = pastedal.getAlignmentAnnotation();
1697           for (int i = 0; i < alann.length; i++)
1698           {
1699             annotationAdded = true;
1700             if (alann[i].sequenceRef == null && !alann[i].autoCalculated)
1701             {
1702               AlignmentAnnotation newann = new AlignmentAnnotation(alann[i]);
1703               newann.padAnnotation(alwidth);
1704               alignment.addAnnotation(newann);
1705             }
1706           }
1707         }
1708       }
1709       if (!newAlignment)
1710       {
1711         // /////
1712         // ADD HISTORY ITEM
1713         //
1714         addHistoryItem(new EditCommand("Add sequences", EditCommand.PASTE,
1715                 sequences, 0, alignment.getWidth(), alignment));
1716       }
1717       // Add any annotations attached to sequences
1718       for (int i = 0; i < sequences.length; i++)
1719       {
1720         if (sequences[i].getAnnotation() != null)
1721         {
1722           for (int a = 0; a < sequences[i].getAnnotation().length; a++)
1723           {
1724             annotationAdded = true;
1725             sequences[i].getAnnotation()[a].adjustForAlignment();
1726             sequences[i].getAnnotation()[a].padAnnotation(alwidth);
1727             alignment.addAnnotation(sequences[i].getAnnotation()[a]); // annotation
1728             // was
1729             // duplicated
1730             // earlier
1731             alignment
1732                     .setAnnotationIndex(sequences[i].getAnnotation()[a], a);
1733           }
1734         }
1735       }
1736       if (!newAlignment)
1737       {
1738
1739         // propagate alignment changed.
1740         viewport.setEndSeq(alignment.getHeight());
1741         if (annotationAdded)
1742         {
1743           // Duplicate sequence annotation in all views.
1744           AlignmentI[] alview = this.getViewAlignments();
1745           for (int i = 0; i < sequences.length; i++)
1746           {
1747             AlignmentAnnotation sann[] = sequences[i].getAnnotation();
1748             if (sann == null)
1749               continue;
1750             for (int avnum = 0; avnum < alview.length; avnum++)
1751             {
1752               if (alview[avnum] != alignment)
1753               {
1754                 // duplicate in a view other than the one with input focus
1755                 int avwidth = alview[avnum].getWidth() + 1;
1756                 // this relies on sann being preserved after we
1757                 // modify the sequence's annotation array for each duplication
1758                 for (int a = 0; a < sann.length; a++)
1759                 {
1760                   AlignmentAnnotation newann = new AlignmentAnnotation(
1761                           sann[a]);
1762                   sequences[i].addAlignmentAnnotation(newann);
1763                   newann.padAnnotation(avwidth);
1764                   alview[avnum].addAnnotation(newann); // annotation was
1765                   // duplicated earlier
1766                   alview[avnum].setAnnotationIndex(newann, a);
1767                 }
1768               }
1769             }
1770           }
1771           buildSortByAnnotationScoresMenu();
1772         }
1773         viewport.firePropertyChange("alignment", null, alignment
1774                 .getSequences());
1775
1776       }
1777       else
1778       {
1779         AlignFrame af = new AlignFrame(alignment, DEFAULT_WIDTH,
1780                 DEFAULT_HEIGHT);
1781         String newtitle = new String("Copied sequences");
1782
1783         if (Desktop.jalviewClipboard != null
1784                 && Desktop.jalviewClipboard[2] != null)
1785         {
1786           Vector hc = (Vector) Desktop.jalviewClipboard[2];
1787           for (int i = 0; i < hc.size(); i++)
1788           {
1789             int[] region = (int[]) hc.elementAt(i);
1790             af.viewport.hideColumns(region[0], region[1]);
1791           }
1792         }
1793
1794         // >>>This is a fix for the moment, until a better solution is
1795         // found!!<<<
1796         af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer()
1797                 .transferSettings(
1798                         alignPanel.seqPanel.seqCanvas.getFeatureRenderer());
1799
1800         // TODO: maintain provenance of an alignment, rather than just make the
1801         // title a concatenation of operations.
1802         if (!externalPaste)
1803         {
1804           if (title.startsWith("Copied sequences"))
1805           {
1806             newtitle = title;
1807           }
1808           else
1809           {
1810             newtitle = newtitle.concat("- from " + title);
1811           }
1812         }
1813         else
1814         {
1815           newtitle = new String("Pasted sequences");
1816         }
1817
1818         Desktop.addInternalFrame(af, newtitle, DEFAULT_WIDTH,
1819                 DEFAULT_HEIGHT);
1820
1821       }
1822
1823     } catch (Exception ex)
1824     {
1825       ex.printStackTrace();
1826       System.out.println("Exception whilst pasting: " + ex);
1827       // could be anything being pasted in here
1828     }
1829
1830   }
1831
1832   /**
1833    * DOCUMENT ME!
1834    *
1835    * @param e
1836    *          DOCUMENT ME!
1837    */
1838   protected void cut_actionPerformed(ActionEvent e)
1839   {
1840     copy_actionPerformed(null);
1841     delete_actionPerformed(null);
1842   }
1843
1844   /**
1845    * DOCUMENT ME!
1846    *
1847    * @param e
1848    *          DOCUMENT ME!
1849    */
1850   protected void delete_actionPerformed(ActionEvent evt)
1851   {
1852
1853     SequenceGroup sg = viewport.getSelectionGroup();
1854     if (sg == null)
1855     {
1856       return;
1857     }
1858
1859     Vector seqs = new Vector();
1860     SequenceI seq;
1861     for (int i = 0; i < sg.getSize(); i++)
1862     {
1863       seq = sg.getSequenceAt(i);
1864       seqs.addElement(seq);
1865     }
1866
1867     // If the cut affects all sequences, remove highlighted columns
1868     if (sg.getSize() == viewport.alignment.getHeight())
1869     {
1870       viewport.getColumnSelection().removeElements(sg.getStartRes(),
1871               sg.getEndRes() + 1);
1872     }
1873
1874     SequenceI[] cut = new SequenceI[seqs.size()];
1875     for (int i = 0; i < seqs.size(); i++)
1876     {
1877       cut[i] = (SequenceI) seqs.elementAt(i);
1878     }
1879
1880     /*
1881      * //ADD HISTORY ITEM
1882      */
1883     addHistoryItem(new EditCommand("Cut Sequences", EditCommand.CUT, cut,
1884             sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1,
1885             viewport.alignment));
1886
1887     viewport.setSelectionGroup(null);
1888     viewport.sendSelection();
1889     viewport.alignment.deleteGroup(sg);
1890
1891     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
1892             .getSequences());
1893     if (viewport.getAlignment().getHeight() < 1)
1894     {
1895       try
1896       {
1897         this.setClosed(true);
1898       } catch (Exception ex)
1899       {
1900       }
1901     }
1902   }
1903
1904   /**
1905    * DOCUMENT ME!
1906    *
1907    * @param e
1908    *          DOCUMENT ME!
1909    */
1910   protected void deleteGroups_actionPerformed(ActionEvent e)
1911   {
1912     viewport.alignment.deleteAllGroups();
1913     viewport.sequenceColours = null;
1914     viewport.setSelectionGroup(null);
1915     PaintRefresher.Refresh(this, viewport.getSequenceSetId());
1916     alignPanel.updateAnnotation();
1917     alignPanel.paintAlignment(true);
1918   }
1919
1920   /**
1921    * DOCUMENT ME!
1922    *
1923    * @param e
1924    *          DOCUMENT ME!
1925    */
1926   public void selectAllSequenceMenuItem_actionPerformed(ActionEvent e)
1927   {
1928     SequenceGroup sg = new SequenceGroup();
1929
1930     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
1931     {
1932       sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
1933     }
1934
1935     sg.setEndRes(viewport.alignment.getWidth() - 1);
1936     viewport.setSelectionGroup(sg);
1937     viewport.sendSelection();
1938     alignPanel.paintAlignment(true);
1939     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
1940   }
1941
1942   /**
1943    * DOCUMENT ME!
1944    *
1945    * @param e
1946    *          DOCUMENT ME!
1947    */
1948   public void deselectAllSequenceMenuItem_actionPerformed(ActionEvent e)
1949   {
1950     if (viewport.cursorMode)
1951     {
1952       alignPanel.seqPanel.keyboardNo1 = null;
1953       alignPanel.seqPanel.keyboardNo2 = null;
1954     }
1955     viewport.setSelectionGroup(null);
1956     viewport.getColumnSelection().clear();
1957     viewport.setSelectionGroup(null);
1958     alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
1959     alignPanel.idPanel.idCanvas.searchResults = null;
1960     alignPanel.paintAlignment(true);
1961     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
1962   }
1963
1964   /**
1965    * DOCUMENT ME!
1966    *
1967    * @param e
1968    *          DOCUMENT ME!
1969    */
1970   public void invertSequenceMenuItem_actionPerformed(ActionEvent e)
1971   {
1972     SequenceGroup sg = viewport.getSelectionGroup();
1973
1974     if (sg == null)
1975     {
1976       selectAllSequenceMenuItem_actionPerformed(null);
1977
1978       return;
1979     }
1980
1981     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
1982     {
1983       sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
1984     }
1985
1986     alignPanel.paintAlignment(true);
1987     viewport.sendSelection();
1988     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
1989   }
1990
1991   public void invertColSel_actionPerformed(ActionEvent e)
1992   {
1993     viewport.invertColumnSelection();
1994     alignPanel.paintAlignment(true);
1995   }
1996
1997   /**
1998    * DOCUMENT ME!
1999    *
2000    * @param e
2001    *          DOCUMENT ME!
2002    */
2003   public void remove2LeftMenuItem_actionPerformed(ActionEvent e)
2004   {
2005     trimAlignment(true);
2006   }
2007
2008   /**
2009    * DOCUMENT ME!
2010    *
2011    * @param e
2012    *          DOCUMENT ME!
2013    */
2014   public void remove2RightMenuItem_actionPerformed(ActionEvent e)
2015   {
2016     trimAlignment(false);
2017   }
2018
2019   void trimAlignment(boolean trimLeft)
2020   {
2021     ColumnSelection colSel = viewport.getColumnSelection();
2022     int column;
2023
2024     if (colSel.size() > 0)
2025     {
2026       if (trimLeft)
2027       {
2028         column = colSel.getMin();
2029       }
2030       else
2031       {
2032         column = colSel.getMax();
2033       }
2034
2035       SequenceI[] seqs;
2036       if (viewport.getSelectionGroup() != null)
2037       {
2038         seqs = viewport.getSelectionGroup().getSequencesAsArray(
2039                 viewport.hiddenRepSequences);
2040       }
2041       else
2042       {
2043         seqs = viewport.alignment.getSequencesArray();
2044       }
2045
2046       TrimRegionCommand trimRegion;
2047       if (trimLeft)
2048       {
2049         trimRegion = new TrimRegionCommand("Remove Left",
2050                 TrimRegionCommand.TRIM_LEFT, seqs, column,
2051                 viewport.alignment, viewport.colSel,
2052                 viewport.selectionGroup);
2053         viewport.setStartRes(0);
2054       }
2055       else
2056       {
2057         trimRegion = new TrimRegionCommand("Remove Right",
2058                 TrimRegionCommand.TRIM_RIGHT, seqs, column,
2059                 viewport.alignment, viewport.colSel,
2060                 viewport.selectionGroup);
2061       }
2062
2063       statusBar.setText("Removed " + trimRegion.getSize() + " columns.");
2064
2065       addHistoryItem(trimRegion);
2066
2067       Vector groups = viewport.alignment.getGroups();
2068
2069       for (int i = 0; i < groups.size(); i++)
2070       {
2071         SequenceGroup sg = (SequenceGroup) groups.get(i);
2072
2073         if ((trimLeft && !sg.adjustForRemoveLeft(column))
2074                 || (!trimLeft && !sg.adjustForRemoveRight(column)))
2075         {
2076           viewport.alignment.deleteGroup(sg);
2077         }
2078       }
2079
2080       viewport.firePropertyChange("alignment", null, viewport
2081               .getAlignment().getSequences());
2082     }
2083   }
2084
2085   /**
2086    * DOCUMENT ME!
2087    *
2088    * @param e
2089    *          DOCUMENT ME!
2090    */
2091   public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e)
2092   {
2093     int start = 0, end = viewport.alignment.getWidth() - 1;
2094
2095     SequenceI[] seqs;
2096     if (viewport.getSelectionGroup() != null)
2097     {
2098       seqs = viewport.getSelectionGroup().getSequencesAsArray(
2099               viewport.hiddenRepSequences);
2100       start = viewport.getSelectionGroup().getStartRes();
2101       end = viewport.getSelectionGroup().getEndRes();
2102     }
2103     else
2104     {
2105       seqs = viewport.alignment.getSequencesArray();
2106     }
2107
2108     RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
2109             "Remove Gapped Columns", seqs, start, end, viewport.alignment);
2110
2111     addHistoryItem(removeGapCols);
2112
2113     statusBar.setText("Removed " + removeGapCols.getSize()
2114             + " empty columns.");
2115
2116     // This is to maintain viewport position on first residue
2117     // of first sequence
2118     SequenceI seq = viewport.alignment.getSequenceAt(0);
2119     int startRes = seq.findPosition(viewport.startRes);
2120     // ShiftList shifts;
2121     // viewport.getAlignment().removeGaps(shifts=new ShiftList());
2122     // edit.alColumnChanges=shifts.getInverse();
2123     // if (viewport.hasHiddenColumns)
2124     // viewport.getColumnSelection().compensateForEdits(shifts);
2125     viewport.setStartRes(seq.findIndex(startRes) - 1);
2126     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2127             .getSequences());
2128
2129   }
2130
2131   /**
2132    * DOCUMENT ME!
2133    *
2134    * @param e
2135    *          DOCUMENT ME!
2136    */
2137   public void removeAllGapsMenuItem_actionPerformed(ActionEvent e)
2138   {
2139     int start = 0, end = viewport.alignment.getWidth() - 1;
2140
2141     SequenceI[] seqs;
2142     if (viewport.getSelectionGroup() != null)
2143     {
2144       seqs = viewport.getSelectionGroup().getSequencesAsArray(
2145               viewport.hiddenRepSequences);
2146       start = viewport.getSelectionGroup().getStartRes();
2147       end = viewport.getSelectionGroup().getEndRes();
2148     }
2149     else
2150     {
2151       seqs = viewport.alignment.getSequencesArray();
2152     }
2153
2154     // This is to maintain viewport position on first residue
2155     // of first sequence
2156     SequenceI seq = viewport.alignment.getSequenceAt(0);
2157     int startRes = seq.findPosition(viewport.startRes);
2158
2159     addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
2160             viewport.alignment));
2161
2162     viewport.setStartRes(seq.findIndex(startRes) - 1);
2163
2164     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2165             .getSequences());
2166
2167   }
2168
2169   /**
2170    * DOCUMENT ME!
2171    *
2172    * @param e
2173    *          DOCUMENT ME!
2174    */
2175   public void padGapsMenuitem_actionPerformed(ActionEvent e)
2176   {
2177     viewport.padGaps = padGapsMenuitem.isSelected();
2178     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2179             .getSequences());
2180   }
2181
2182   // else
2183   {
2184     // if (justifySeqs>0)
2185     {
2186       // alignment.justify(justifySeqs!=RIGHT_JUSTIFY);
2187     }
2188   }
2189
2190   // }
2191
2192   /**
2193    * DOCUMENT ME!
2194    *
2195    * @param e
2196    *          DOCUMENT ME!
2197    */
2198   public void findMenuItem_actionPerformed(ActionEvent e)
2199   {
2200     new Finder();
2201   }
2202
2203   public void newView_actionPerformed(ActionEvent e)
2204   {
2205     AlignmentPanel newap = new Jalview2XML().copyAlignPanel(alignPanel,
2206             true);
2207
2208     newap.av.gatherViewsHere = false;
2209
2210     if (viewport.viewName == null)
2211     {
2212       viewport.viewName = "Original";
2213     }
2214
2215     newap.av.historyList = viewport.historyList;
2216     newap.av.redoList = viewport.redoList;
2217
2218     int index = Desktop.getViewCount(viewport.getSequenceSetId());
2219     String newViewName = "View " + index;
2220
2221     Vector comps = (Vector) PaintRefresher.components.get(viewport
2222             .getSequenceSetId());
2223     Vector existingNames = new Vector();
2224     for (int i = 0; i < comps.size(); i++)
2225     {
2226       if (comps.elementAt(i) instanceof AlignmentPanel)
2227       {
2228         AlignmentPanel ap = (AlignmentPanel) comps.elementAt(i);
2229         if (!existingNames.contains(ap.av.viewName))
2230         {
2231           existingNames.addElement(ap.av.viewName);
2232         }
2233       }
2234     }
2235
2236     while (existingNames.contains(newViewName))
2237     {
2238       newViewName = "View " + (++index);
2239     }
2240
2241     newap.av.viewName = newViewName;
2242
2243     addAlignmentPanel(newap, true);
2244
2245     if (alignPanels.size() == 2)
2246     {
2247       viewport.gatherViewsHere = true;
2248     }
2249     tabbedPane.setSelectedIndex(tabbedPane.getTabCount() - 1);
2250   }
2251
2252   public void expandViews_actionPerformed(ActionEvent e)
2253   {
2254     Desktop.instance.explodeViews(this);
2255   }
2256
2257   public void gatherViews_actionPerformed(ActionEvent e)
2258   {
2259     Desktop.instance.gatherViews(this);
2260   }
2261
2262   /**
2263    * DOCUMENT ME!
2264    *
2265    * @param e
2266    *          DOCUMENT ME!
2267    */
2268   public void font_actionPerformed(ActionEvent e)
2269   {
2270     new FontChooser(alignPanel);
2271   }
2272
2273   /**
2274    * DOCUMENT ME!
2275    *
2276    * @param e
2277    *          DOCUMENT ME!
2278    */
2279   protected void seqLimit_actionPerformed(ActionEvent e)
2280   {
2281     viewport.setShowJVSuffix(seqLimits.isSelected());
2282
2283     alignPanel.idPanel.idCanvas.setPreferredSize(alignPanel
2284             .calculateIdWidth());
2285     alignPanel.paintAlignment(true);
2286   }
2287
2288   public void idRightAlign_actionPerformed(ActionEvent e)
2289   {
2290     viewport.rightAlignIds = idRightAlign.isSelected();
2291     alignPanel.paintAlignment(true);
2292   }
2293
2294   public void centreColumnLabels_actionPerformed(ActionEvent e)
2295   {
2296     viewport.centreColumnLabels = centreColumnLabelsMenuItem.getState();
2297     alignPanel.paintAlignment(true);
2298   }
2299
2300   /*
2301    * (non-Javadoc)
2302    *
2303    * @see jalview.jbgui.GAlignFrame#followHighlight_actionPerformed()
2304    */
2305   protected void followHighlight_actionPerformed()
2306   {
2307     if (viewport.followHighlight = this.followHighlightMenuItem.getState())
2308     {
2309       alignPanel.scrollToPosition(
2310               alignPanel.seqPanel.seqCanvas.searchResults, false);
2311     }
2312   }
2313
2314   /**
2315    * DOCUMENT ME!
2316    *
2317    * @param e
2318    *          DOCUMENT ME!
2319    */
2320   protected void colourTextMenuItem_actionPerformed(ActionEvent e)
2321   {
2322     viewport.setColourText(colourTextMenuItem.isSelected());
2323     alignPanel.paintAlignment(true);
2324   }
2325
2326   /**
2327    * DOCUMENT ME!
2328    *
2329    * @param e
2330    *          DOCUMENT ME!
2331    */
2332   public void wrapMenuItem_actionPerformed(ActionEvent e)
2333   {
2334     scaleAbove.setVisible(wrapMenuItem.isSelected());
2335     scaleLeft.setVisible(wrapMenuItem.isSelected());
2336     scaleRight.setVisible(wrapMenuItem.isSelected());
2337     viewport.setWrapAlignment(wrapMenuItem.isSelected());
2338     alignPanel.setWrapAlignment(wrapMenuItem.isSelected());
2339   }
2340
2341   public void showAllSeqs_actionPerformed(ActionEvent e)
2342   {
2343     viewport.showAllHiddenSeqs();
2344   }
2345
2346   public void showAllColumns_actionPerformed(ActionEvent e)
2347   {
2348     viewport.showAllHiddenColumns();
2349     repaint();
2350   }
2351
2352   public void hideSelSequences_actionPerformed(ActionEvent e)
2353   {
2354     viewport.hideAllSelectedSeqs();
2355     alignPanel.paintAlignment(true);
2356   }
2357   /**
2358    * called by key handler and the hide all/show all menu items
2359    * @param toggleSeqs
2360    * @param toggleCols
2361    */
2362   private void toggleHiddenRegions(boolean toggleSeqs,
2363           boolean toggleCols)
2364   {
2365
2366     boolean hide = false;
2367     SequenceGroup sg = viewport.getSelectionGroup();
2368     if (!toggleSeqs && !toggleCols)
2369     {
2370       // Hide everything by the current selection - this is a hack - we do the invert and then hide
2371       // first check that there will be visible columns after the invert.
2372       if ((viewport.colSel!=null && viewport.colSel.getSelected()!=null && viewport.colSel.getSelected().size()>0) || (sg!=null && sg.getSize()>0  && sg.getStartRes()<=sg.getEndRes()))
2373       {
2374       // now invert the sequence set, if required - empty selection implies that no hiding is required.
2375       if (sg!=null) {
2376         invertSequenceMenuItem_actionPerformed(null);
2377         sg = viewport.getSelectionGroup();
2378         toggleSeqs = true;
2379
2380       }
2381       viewport.expandColSelection(sg,true);
2382       // finally invert the column selection and get the new sequence selection.
2383       invertColSel_actionPerformed(null);
2384       toggleCols = true;
2385       }
2386     }
2387
2388     if (toggleSeqs)
2389     {
2390       if (sg != null
2391               && sg.getSize() != viewport.alignment.getHeight())
2392       {
2393         hideSelSequences_actionPerformed(null);
2394         hide = true;
2395       }
2396       else if (!(toggleCols && viewport.colSel.getSelected().size() > 0))
2397       {
2398         showAllSeqs_actionPerformed(null);
2399       }
2400     }
2401
2402     if (toggleCols)
2403     {
2404       if (viewport.colSel.getSelected().size() > 0)
2405       {
2406         hideSelColumns_actionPerformed(null);
2407         if (!toggleSeqs)
2408         {
2409           viewport.selectionGroup = sg;
2410         }
2411       }
2412       else if (!hide)
2413       {
2414         showAllColumns_actionPerformed(null);
2415       }
2416     }
2417   }
2418
2419   /* (non-Javadoc)
2420    * @see jalview.jbgui.GAlignFrame#hideAllButSelection_actionPerformed(java.awt.event.ActionEvent)
2421    */
2422   public void hideAllButSelection_actionPerformed(ActionEvent e)
2423   {
2424     toggleHiddenRegions(false, false);
2425   }
2426
2427   /* (non-Javadoc)
2428    * @see jalview.jbgui.GAlignFrame#hideAllSelection_actionPerformed(java.awt.event.ActionEvent)
2429    */
2430   public void hideAllSelection_actionPerformed(ActionEvent e)
2431   {
2432     SequenceGroup sg = viewport.getSelectionGroup();
2433     viewport.expandColSelection(sg,false);
2434     viewport.hideAllSelectedSeqs();
2435     viewport.hideSelectedColumns();
2436     alignPanel.paintAlignment(true);
2437   }
2438
2439   /* (non-Javadoc)
2440    * @see jalview.jbgui.GAlignFrame#showAllhidden_actionPerformed(java.awt.event.ActionEvent)
2441    */
2442   public void showAllhidden_actionPerformed(ActionEvent e)
2443   {
2444     viewport.showAllHiddenColumns();
2445     viewport.showAllHiddenSeqs();
2446     alignPanel.paintAlignment(true);
2447   }
2448
2449   public void hideSelColumns_actionPerformed(ActionEvent e)
2450   {
2451     viewport.hideSelectedColumns();
2452     alignPanel.paintAlignment(true);
2453   }
2454
2455   public void hiddenMarkers_actionPerformed(ActionEvent e)
2456   {
2457     viewport.setShowHiddenMarkers(hiddenMarkers.isSelected());
2458     repaint();
2459   }
2460
2461   /**
2462    * DOCUMENT ME!
2463    *
2464    * @param e
2465    *          DOCUMENT ME!
2466    */
2467   protected void scaleAbove_actionPerformed(ActionEvent e)
2468   {
2469     viewport.setScaleAboveWrapped(scaleAbove.isSelected());
2470     alignPanel.paintAlignment(true);
2471   }
2472
2473   /**
2474    * DOCUMENT ME!
2475    *
2476    * @param e
2477    *          DOCUMENT ME!
2478    */
2479   protected void scaleLeft_actionPerformed(ActionEvent e)
2480   {
2481     viewport.setScaleLeftWrapped(scaleLeft.isSelected());
2482     alignPanel.paintAlignment(true);
2483   }
2484
2485   /**
2486    * DOCUMENT ME!
2487    *
2488    * @param e
2489    *          DOCUMENT ME!
2490    */
2491   protected void scaleRight_actionPerformed(ActionEvent e)
2492   {
2493     viewport.setScaleRightWrapped(scaleRight.isSelected());
2494     alignPanel.paintAlignment(true);
2495   }
2496
2497   /**
2498    * DOCUMENT ME!
2499    *
2500    * @param e
2501    *          DOCUMENT ME!
2502    */
2503   public void viewBoxesMenuItem_actionPerformed(ActionEvent e)
2504   {
2505     viewport.setShowBoxes(viewBoxesMenuItem.isSelected());
2506     alignPanel.paintAlignment(true);
2507   }
2508
2509   /**
2510    * DOCUMENT ME!
2511    *
2512    * @param e
2513    *          DOCUMENT ME!
2514    */
2515   public void viewTextMenuItem_actionPerformed(ActionEvent e)
2516   {
2517     viewport.setShowText(viewTextMenuItem.isSelected());
2518     alignPanel.paintAlignment(true);
2519   }
2520
2521   /**
2522    * DOCUMENT ME!
2523    *
2524    * @param e
2525    *          DOCUMENT ME!
2526    */
2527   protected void renderGapsMenuItem_actionPerformed(ActionEvent e)
2528   {
2529     viewport.setRenderGaps(renderGapsMenuItem.isSelected());
2530     alignPanel.paintAlignment(true);
2531   }
2532
2533   public FeatureSettings featureSettings;
2534
2535   public void featureSettings_actionPerformed(ActionEvent e)
2536   {
2537     if (featureSettings != null)
2538     {
2539       featureSettings.close();
2540       featureSettings = null;
2541     }
2542     if (!showSeqFeatures.isSelected())
2543     {
2544       // make sure features are actually displayed
2545       showSeqFeatures.setSelected(true);
2546       showSeqFeatures_actionPerformed(null);
2547     }
2548     featureSettings = new FeatureSettings(this);
2549   }
2550
2551   /**
2552    * Set or clear 'Show Sequence Features'
2553    *
2554    * @param evt
2555    *          DOCUMENT ME!
2556    */
2557   public void showSeqFeatures_actionPerformed(ActionEvent evt)
2558   {
2559     viewport.setShowSequenceFeatures(showSeqFeatures.isSelected());
2560     alignPanel.paintAlignment(true);
2561     if (alignPanel.getOverviewPanel() != null)
2562     {
2563       alignPanel.getOverviewPanel().updateOverviewImage();
2564     }
2565   }
2566
2567   /**
2568    * Set or clear 'Show Sequence Features'
2569    *
2570    * @param evt
2571    *          DOCUMENT ME!
2572    */
2573   public void showSeqFeaturesHeight_actionPerformed(ActionEvent evt)
2574   {
2575     viewport.setShowSequenceFeaturesHeight(showSeqFeaturesHeight
2576             .isSelected());
2577     if (viewport.getShowSequenceFeaturesHeight())
2578     {
2579       // ensure we're actually displaying features
2580       viewport.setShowSequenceFeatures(true);
2581       showSeqFeatures.setSelected(true);
2582     }
2583     alignPanel.paintAlignment(true);
2584     if (alignPanel.getOverviewPanel() != null)
2585     {
2586       alignPanel.getOverviewPanel().updateOverviewImage();
2587     }
2588   }
2589
2590   /**
2591    * DOCUMENT ME!
2592    *
2593    * @param e
2594    *          DOCUMENT ME!
2595    */
2596   public void annotationPanelMenuItem_actionPerformed(ActionEvent e)
2597   {
2598     viewport.setShowAnnotation(annotationPanelMenuItem.isSelected());
2599     alignPanel.setAnnotationVisible(annotationPanelMenuItem.isSelected());
2600   }
2601
2602   public void alignmentProperties()
2603   {
2604     JEditorPane editPane = new JEditorPane("text/html", "");
2605     editPane.setEditable(false);
2606     StringBuffer contents = new StringBuffer("<html>");
2607
2608     float avg = 0;
2609     int min = Integer.MAX_VALUE, max = 0;
2610     for (int i = 0; i < viewport.alignment.getHeight(); i++)
2611     {
2612       int size = viewport.alignment.getSequenceAt(i).getEnd()
2613               - viewport.alignment.getSequenceAt(i).getStart();
2614       avg += size;
2615       if (size > max)
2616         max = size;
2617       if (size < min)
2618         min = size;
2619     }
2620     avg = avg / (float) viewport.alignment.getHeight();
2621
2622     contents.append("<br>Sequences: " + viewport.alignment.getHeight());
2623     contents.append("<br>Minimum Sequence Length: " + min);
2624     contents.append("<br>Maximum Sequence Length: " + max);
2625     contents.append("<br>Average Length: " + (int) avg);
2626
2627     if (((Alignment) viewport.alignment).getProperties() != null)
2628     {
2629       Hashtable props = ((Alignment) viewport.alignment).getProperties();
2630       Enumeration en = props.keys();
2631       contents.append("<br><br><table border=\"1\">");
2632       while (en.hasMoreElements())
2633       {
2634         String key = en.nextElement().toString();
2635         StringBuffer val = new StringBuffer();
2636         String vals = props.get(key).toString();
2637         int pos = 0, npos;
2638         do
2639         {
2640           npos = vals.indexOf("\n", pos);
2641           if (npos == -1)
2642           {
2643             val.append(vals.substring(pos));
2644           }
2645           else
2646           {
2647             val.append(vals.substring(pos, npos));
2648             val.append("<br>");
2649           }
2650           pos = npos + 1;
2651         } while (npos != -1);
2652         contents
2653                 .append("<tr><td>" + key + "</td><td>" + val + "</td></tr>");
2654       }
2655       contents.append("</table>");
2656     }
2657     editPane.setText(contents.toString() + "</html>");
2658     JInternalFrame frame = new JInternalFrame();
2659     frame.getContentPane().add(new JScrollPane(editPane));
2660
2661     Desktop.instance.addInternalFrame(frame, "Alignment Properties: "
2662             + getTitle(), 500, 400);
2663   }
2664
2665   /**
2666    * DOCUMENT ME!
2667    *
2668    * @param e
2669    *          DOCUMENT ME!
2670    */
2671   public void overviewMenuItem_actionPerformed(ActionEvent e)
2672   {
2673     if (alignPanel.overviewPanel != null)
2674     {
2675       return;
2676     }
2677
2678     JInternalFrame frame = new JInternalFrame();
2679     OverviewPanel overview = new OverviewPanel(alignPanel);
2680     frame.setContentPane(overview);
2681     Desktop.addInternalFrame(frame, "Overview " + this.getTitle(), frame
2682             .getWidth(), frame.getHeight());
2683     frame.pack();
2684     frame.setLayer(JLayeredPane.PALETTE_LAYER);
2685     frame
2686             .addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
2687             {
2688               public void internalFrameClosed(
2689                       javax.swing.event.InternalFrameEvent evt)
2690               {
2691                 alignPanel.setOverviewPanel(null);
2692               };
2693             });
2694
2695     alignPanel.setOverviewPanel(overview);
2696   }
2697
2698   public void textColour_actionPerformed(ActionEvent e)
2699   {
2700     new TextColourChooser().chooseColour(alignPanel, null);
2701   }
2702
2703   /**
2704    * DOCUMENT ME!
2705    *
2706    * @param e
2707    *          DOCUMENT ME!
2708    */
2709   protected void noColourmenuItem_actionPerformed(ActionEvent e)
2710   {
2711     changeColour(null);
2712   }
2713
2714   /**
2715    * DOCUMENT ME!
2716    *
2717    * @param e
2718    *          DOCUMENT ME!
2719    */
2720   public void clustalColour_actionPerformed(ActionEvent e)
2721   {
2722     changeColour(new ClustalxColourScheme(
2723             viewport.alignment.getSequences(), viewport.alignment
2724                     .getWidth()));
2725   }
2726
2727   /**
2728    * DOCUMENT ME!
2729    *
2730    * @param e
2731    *          DOCUMENT ME!
2732    */
2733   public void zappoColour_actionPerformed(ActionEvent e)
2734   {
2735     changeColour(new ZappoColourScheme());
2736   }
2737
2738   /**
2739    * DOCUMENT ME!
2740    *
2741    * @param e
2742    *          DOCUMENT ME!
2743    */
2744   public void taylorColour_actionPerformed(ActionEvent e)
2745   {
2746     changeColour(new TaylorColourScheme());
2747   }
2748
2749   /**
2750    * DOCUMENT ME!
2751    *
2752    * @param e
2753    *          DOCUMENT ME!
2754    */
2755   public void hydrophobicityColour_actionPerformed(ActionEvent e)
2756   {
2757     changeColour(new HydrophobicColourScheme());
2758   }
2759
2760   /**
2761    * DOCUMENT ME!
2762    *
2763    * @param e
2764    *          DOCUMENT ME!
2765    */
2766   public void helixColour_actionPerformed(ActionEvent e)
2767   {
2768     changeColour(new HelixColourScheme());
2769   }
2770
2771   /**
2772    * DOCUMENT ME!
2773    *
2774    * @param e
2775    *          DOCUMENT ME!
2776    */
2777   public void strandColour_actionPerformed(ActionEvent e)
2778   {
2779     changeColour(new StrandColourScheme());
2780   }
2781
2782   /**
2783    * DOCUMENT ME!
2784    *
2785    * @param e
2786    *          DOCUMENT ME!
2787    */
2788   public void turnColour_actionPerformed(ActionEvent e)
2789   {
2790     changeColour(new TurnColourScheme());
2791   }
2792
2793   /**
2794    * DOCUMENT ME!
2795    *
2796    * @param e
2797    *          DOCUMENT ME!
2798    */
2799   public void buriedColour_actionPerformed(ActionEvent e)
2800   {
2801     changeColour(new BuriedColourScheme());
2802   }
2803
2804   /**
2805    * DOCUMENT ME!
2806    *
2807    * @param e
2808    *          DOCUMENT ME!
2809    */
2810   public void nucleotideColour_actionPerformed(ActionEvent e)
2811   {
2812     changeColour(new NucleotideColourScheme());
2813   }
2814
2815   public void annotationColour_actionPerformed(ActionEvent e)
2816   {
2817     new AnnotationColourChooser(viewport, alignPanel);
2818   }
2819
2820   /**
2821    * DOCUMENT ME!
2822    *
2823    * @param e
2824    *          DOCUMENT ME!
2825    */
2826   protected void applyToAllGroups_actionPerformed(ActionEvent e)
2827   {
2828     viewport.setColourAppliesToAllGroups(applyToAllGroups.isSelected());
2829   }
2830
2831   /**
2832    * DOCUMENT ME!
2833    *
2834    * @param cs
2835    *          DOCUMENT ME!
2836    */
2837   public void changeColour(ColourSchemeI cs)
2838   {
2839     int threshold = 0;
2840
2841     if (cs != null)
2842     {
2843       if (viewport.getAbovePIDThreshold())
2844       {
2845         threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,
2846                 "Background");
2847
2848         cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
2849
2850         viewport.setGlobalColourScheme(cs);
2851       }
2852       else
2853       {
2854         cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
2855       }
2856
2857       if (viewport.getConservationSelected())
2858       {
2859
2860         Alignment al = (Alignment) viewport.alignment;
2861         Conservation c = new Conservation("All",
2862                 ResidueProperties.propHash, 3, al.getSequences(), 0, al
2863                         .getWidth() - 1);
2864
2865         c.calculate();
2866         c.verdict(false, viewport.ConsPercGaps);
2867
2868         cs.setConservation(c);
2869
2870         cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel,
2871                 cs, "Background"));
2872       }
2873       else
2874       {
2875         cs.setConservation(null);
2876       }
2877
2878       cs.setConsensus(viewport.hconsensus);
2879     }
2880
2881     viewport.setGlobalColourScheme(cs);
2882
2883     if (viewport.getColourAppliesToAllGroups())
2884     {
2885       Vector groups = viewport.alignment.getGroups();
2886
2887       for (int i = 0; i < groups.size(); i++)
2888       {
2889         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
2890
2891         if (cs == null)
2892         {
2893           sg.cs = null;
2894           continue;
2895         }
2896
2897         if (cs instanceof ClustalxColourScheme)
2898         {
2899           sg.cs = new ClustalxColourScheme(sg
2900                   .getSequences(viewport.hiddenRepSequences), sg.getWidth());
2901         }
2902         else if (cs instanceof UserColourScheme)
2903         {
2904           sg.cs = new UserColourScheme(((UserColourScheme) cs).getColours());
2905         }
2906         else
2907         {
2908           try
2909           {
2910             sg.cs = (ColourSchemeI) cs.getClass().newInstance();
2911           } catch (Exception ex)
2912           {
2913           }
2914         }
2915
2916         if (viewport.getAbovePIDThreshold()
2917                 || cs instanceof PIDColourScheme
2918                 || cs instanceof Blosum62ColourScheme)
2919         {
2920           sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
2921
2922           sg.cs.setConsensus(AAFrequency.calculate(sg
2923                   .getSequences(viewport.hiddenRepSequences), sg
2924                   .getStartRes(), sg.getEndRes() + 1));
2925         }
2926         else
2927         {
2928           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
2929         }
2930
2931         if (viewport.getConservationSelected())
2932         {
2933           Conservation c = new Conservation("Group",
2934                   ResidueProperties.propHash, 3, sg
2935                           .getSequences(viewport.hiddenRepSequences), sg
2936                           .getStartRes(), sg.getEndRes() + 1);
2937           c.calculate();
2938           c.verdict(false, viewport.ConsPercGaps);
2939           sg.cs.setConservation(c);
2940         }
2941         else
2942         {
2943           sg.cs.setConservation(null);
2944         }
2945       }
2946     }
2947
2948     if (alignPanel.getOverviewPanel() != null)
2949     {
2950       alignPanel.getOverviewPanel().updateOverviewImage();
2951     }
2952
2953     alignPanel.paintAlignment(true);
2954   }
2955
2956   /**
2957    * DOCUMENT ME!
2958    *
2959    * @param e
2960    *          DOCUMENT ME!
2961    */
2962   protected void modifyPID_actionPerformed(ActionEvent e)
2963   {
2964     if (viewport.getAbovePIDThreshold()
2965             && viewport.globalColourScheme != null)
2966     {
2967       SliderPanel.setPIDSliderSource(alignPanel, viewport
2968               .getGlobalColourScheme(), "Background");
2969       SliderPanel.showPIDSlider();
2970     }
2971   }
2972
2973   /**
2974    * DOCUMENT ME!
2975    *
2976    * @param e
2977    *          DOCUMENT ME!
2978    */
2979   protected void modifyConservation_actionPerformed(ActionEvent e)
2980   {
2981     if (viewport.getConservationSelected()
2982             && viewport.globalColourScheme != null)
2983     {
2984       SliderPanel.setConservationSlider(alignPanel,
2985               viewport.globalColourScheme, "Background");
2986       SliderPanel.showConservationSlider();
2987     }
2988   }
2989
2990   /**
2991    * DOCUMENT ME!
2992    *
2993    * @param e
2994    *          DOCUMENT ME!
2995    */
2996   protected void conservationMenuItem_actionPerformed(ActionEvent e)
2997   {
2998     viewport.setConservationSelected(conservationMenuItem.isSelected());
2999
3000     viewport.setAbovePIDThreshold(false);
3001     abovePIDThreshold.setSelected(false);
3002
3003     changeColour(viewport.getGlobalColourScheme());
3004
3005     modifyConservation_actionPerformed(null);
3006   }
3007
3008   /**
3009    * DOCUMENT ME!
3010    *
3011    * @param e
3012    *          DOCUMENT ME!
3013    */
3014   public void abovePIDThreshold_actionPerformed(ActionEvent e)
3015   {
3016     viewport.setAbovePIDThreshold(abovePIDThreshold.isSelected());
3017
3018     conservationMenuItem.setSelected(false);
3019     viewport.setConservationSelected(false);
3020
3021     changeColour(viewport.getGlobalColourScheme());
3022
3023     modifyPID_actionPerformed(null);
3024   }
3025
3026   /**
3027    * DOCUMENT ME!
3028    *
3029    * @param e
3030    *          DOCUMENT ME!
3031    */
3032   public void userDefinedColour_actionPerformed(ActionEvent e)
3033   {
3034     if (e.getActionCommand().equals("User Defined..."))
3035     {
3036       new UserDefinedColours(alignPanel, null);
3037     }
3038     else
3039     {
3040       UserColourScheme udc = (UserColourScheme) UserDefinedColours
3041               .getUserColourSchemes().get(e.getActionCommand());
3042
3043       changeColour(udc);
3044     }
3045   }
3046
3047   public void updateUserColourMenu()
3048   {
3049
3050     Component[] menuItems = colourMenu.getMenuComponents();
3051     int i, iSize = menuItems.length;
3052     for (i = 0; i < iSize; i++)
3053     {
3054       if (menuItems[i].getName() != null
3055               && menuItems[i].getName().equals("USER_DEFINED"))
3056       {
3057         colourMenu.remove(menuItems[i]);
3058         iSize--;
3059       }
3060     }
3061     if (jalview.gui.UserDefinedColours.getUserColourSchemes() != null)
3062     {
3063       java.util.Enumeration userColours = jalview.gui.UserDefinedColours
3064               .getUserColourSchemes().keys();
3065
3066       while (userColours.hasMoreElements())
3067       {
3068         final JRadioButtonMenuItem radioItem = new JRadioButtonMenuItem(
3069                 userColours.nextElement().toString());
3070         radioItem.setName("USER_DEFINED");
3071         radioItem.addMouseListener(new MouseAdapter()
3072         {
3073           public void mousePressed(MouseEvent evt)
3074           {
3075             if (evt.isControlDown()
3076                     || SwingUtilities.isRightMouseButton(evt))
3077             {
3078               radioItem
3079                       .removeActionListener(radioItem.getActionListeners()[0]);
3080
3081               int option = JOptionPane.showInternalConfirmDialog(
3082                       jalview.gui.Desktop.desktop,
3083                       "Remove from default list?",
3084                       "Remove user defined colour",
3085                       JOptionPane.YES_NO_OPTION);
3086               if (option == JOptionPane.YES_OPTION)
3087               {
3088                 jalview.gui.UserDefinedColours
3089                         .removeColourFromDefaults(radioItem.getText());
3090                 colourMenu.remove(radioItem);
3091               }
3092               else
3093               {
3094                 radioItem.addActionListener(new ActionListener()
3095                 {
3096                   public void actionPerformed(ActionEvent evt)
3097                   {
3098                     userDefinedColour_actionPerformed(evt);
3099                   }
3100                 });
3101               }
3102             }
3103           }
3104         });
3105         radioItem.addActionListener(new ActionListener()
3106         {
3107           public void actionPerformed(ActionEvent evt)
3108           {
3109             userDefinedColour_actionPerformed(evt);
3110           }
3111         });
3112
3113         colourMenu.insert(radioItem, 15);
3114         colours.add(radioItem);
3115       }
3116     }
3117   }
3118
3119   /**
3120    * DOCUMENT ME!
3121    *
3122    * @param e
3123    *          DOCUMENT ME!
3124    */
3125   public void PIDColour_actionPerformed(ActionEvent e)
3126   {
3127     changeColour(new PIDColourScheme());
3128   }
3129
3130   /**
3131    * DOCUMENT ME!
3132    *
3133    * @param e
3134    *          DOCUMENT ME!
3135    */
3136   public void BLOSUM62Colour_actionPerformed(ActionEvent e)
3137   {
3138     changeColour(new Blosum62ColourScheme());
3139   }
3140
3141   /**
3142    * DOCUMENT ME!
3143    *
3144    * @param e
3145    *          DOCUMENT ME!
3146    */
3147   public void sortPairwiseMenuItem_actionPerformed(ActionEvent e)
3148   {
3149     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3150     AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
3151             .getAlignment().getSequenceAt(0), null);
3152     addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
3153             viewport.alignment));
3154     alignPanel.paintAlignment(true);
3155   }
3156
3157   /**
3158    * DOCUMENT ME!
3159    *
3160    * @param e
3161    *          DOCUMENT ME!
3162    */
3163   public void sortIDMenuItem_actionPerformed(ActionEvent e)
3164   {
3165     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3166     AlignmentSorter.sortByID(viewport.getAlignment());
3167     addHistoryItem(new OrderCommand("ID Sort", oldOrder, viewport.alignment));
3168     alignPanel.paintAlignment(true);
3169   }
3170
3171   /**
3172    * DOCUMENT ME!
3173    *
3174    * @param e
3175    *          DOCUMENT ME!
3176    */
3177   public void sortLengthMenuItem_actionPerformed(ActionEvent e)
3178   {
3179     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3180     AlignmentSorter.sortByLength(viewport.getAlignment());
3181     addHistoryItem(new OrderCommand("Length Sort", oldOrder,
3182             viewport.alignment));
3183     alignPanel.paintAlignment(true);
3184   }
3185
3186   /**
3187    * DOCUMENT ME!
3188    *
3189    * @param e
3190    *          DOCUMENT ME!
3191    */
3192   public void sortGroupMenuItem_actionPerformed(ActionEvent e)
3193   {
3194     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3195     AlignmentSorter.sortByGroup(viewport.getAlignment());
3196     addHistoryItem(new OrderCommand("Group Sort", oldOrder,
3197             viewport.alignment));
3198
3199     alignPanel.paintAlignment(true);
3200   }
3201
3202   /**
3203    * DOCUMENT ME!
3204    *
3205    * @param e
3206    *          DOCUMENT ME!
3207    */
3208   public void removeRedundancyMenuItem_actionPerformed(ActionEvent e)
3209   {
3210     new RedundancyPanel(alignPanel, this);
3211   }
3212
3213   /**
3214    * DOCUMENT ME!
3215    *
3216    * @param e
3217    *          DOCUMENT ME!
3218    */
3219   public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e)
3220   {
3221     if ((viewport.getSelectionGroup() == null)
3222             || (viewport.getSelectionGroup().getSize() < 2))
3223     {
3224       JOptionPane.showInternalMessageDialog(this,
3225               "You must select at least 2 sequences.", "Invalid Selection",
3226               JOptionPane.WARNING_MESSAGE);
3227     }
3228     else
3229     {
3230       JInternalFrame frame = new JInternalFrame();
3231       frame.setContentPane(new PairwiseAlignPanel(viewport));
3232       Desktop.addInternalFrame(frame, "Pairwise Alignment", 600, 500);
3233     }
3234   }
3235
3236   /**
3237    * DOCUMENT ME!
3238    *
3239    * @param e
3240    *          DOCUMENT ME!
3241    */
3242   public void PCAMenuItem_actionPerformed(ActionEvent e)
3243   {
3244     if (((viewport.getSelectionGroup() != null)
3245             && (viewport.getSelectionGroup().getSize() < 4) && (viewport
3246             .getSelectionGroup().getSize() > 0))
3247             || (viewport.getAlignment().getHeight() < 4))
3248     {
3249       JOptionPane.showInternalMessageDialog(this,
3250               "Principal component analysis must take\n"
3251                       + "at least 4 input sequences.",
3252               "Sequence selection insufficient",
3253               JOptionPane.WARNING_MESSAGE);
3254
3255       return;
3256     }
3257
3258     new PCAPanel(alignPanel);
3259   }
3260
3261   public void autoCalculate_actionPerformed(ActionEvent e)
3262   {
3263     viewport.autoCalculateConsensus = autoCalculate.isSelected();
3264     if (viewport.autoCalculateConsensus)
3265     {
3266       viewport.firePropertyChange("alignment", null, viewport
3267               .getAlignment().getSequences());
3268     }
3269   }
3270
3271   /**
3272    * DOCUMENT ME!
3273    *
3274    * @param e
3275    *          DOCUMENT ME!
3276    */
3277   public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e)
3278   {
3279     NewTreePanel("AV", "PID", "Average distance tree using PID");
3280   }
3281
3282   /**
3283    * DOCUMENT ME!
3284    *
3285    * @param e
3286    *          DOCUMENT ME!
3287    */
3288   public void neighbourTreeMenuItem_actionPerformed(ActionEvent e)
3289   {
3290     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
3291   }
3292
3293   /**
3294    * DOCUMENT ME!
3295    *
3296    * @param e
3297    *          DOCUMENT ME!
3298    */
3299   protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e)
3300   {
3301     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
3302   }
3303
3304   /**
3305    * DOCUMENT ME!
3306    *
3307    * @param e
3308    *          DOCUMENT ME!
3309    */
3310   protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e)
3311   {
3312     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");
3313   }
3314
3315   /**
3316    * DOCUMENT ME!
3317    *
3318    * @param type
3319    *          DOCUMENT ME!
3320    * @param pwType
3321    *          DOCUMENT ME!
3322    * @param title
3323    *          DOCUMENT ME!
3324    */
3325   void NewTreePanel(String type, String pwType, String title)
3326   {
3327     TreePanel tp;
3328
3329     if (viewport.getSelectionGroup() != null)
3330     {
3331       if (viewport.getSelectionGroup().getSize() < 3)
3332       {
3333         JOptionPane
3334                 .showMessageDialog(
3335                         Desktop.desktop,
3336                         "You need to have more than two sequences selected to build a tree!",
3337                         "Not enough sequences", JOptionPane.WARNING_MESSAGE);
3338         return;
3339       }
3340
3341       int s = 0;
3342       SequenceGroup sg = viewport.getSelectionGroup();
3343
3344       /* Decide if the selection is a column region */
3345       while (s < sg.getSize())
3346       {
3347         if (((SequenceI) sg.getSequences(null).elementAt(s++)).getLength() < sg
3348                 .getEndRes())
3349         {
3350           JOptionPane
3351                   .showMessageDialog(
3352                           Desktop.desktop,
3353                           "The selected region to create a tree may\nonly contain residues or gaps.\n"
3354                                   + "Try using the Pad function in the edit menu,\n"
3355                                   + "or one of the multiple sequence alignment web services.",
3356                           "Sequences in selection are not aligned",
3357                           JOptionPane.WARNING_MESSAGE);
3358
3359           return;
3360         }
3361       }
3362
3363       title = title + " on region";
3364       tp = new TreePanel(alignPanel, type, pwType);
3365     }
3366     else
3367     {
3368       // are the sequences aligned?
3369       if (!viewport.alignment.isAligned())
3370       {
3371         JOptionPane
3372                 .showMessageDialog(
3373                         Desktop.desktop,
3374                         "The sequences must be aligned before creating a tree.\n"
3375                                 + "Try using the Pad function in the edit menu,\n"
3376                                 + "or one of the multiple sequence alignment web services.",
3377                         "Sequences not aligned",
3378                         JOptionPane.WARNING_MESSAGE);
3379
3380         return;
3381       }
3382
3383       if (viewport.alignment.getHeight() < 2)
3384       {
3385         return;
3386       }
3387
3388       tp = new TreePanel(alignPanel, type, pwType);
3389     }
3390
3391     title += " from ";
3392
3393     if (viewport.viewName != null)
3394     {
3395       title += viewport.viewName + " of ";
3396     }
3397
3398     title += this.title;
3399
3400     Desktop.addInternalFrame(tp, title, 600, 500);
3401   }
3402
3403   /**
3404    * DOCUMENT ME!
3405    *
3406    * @param title
3407    *          DOCUMENT ME!
3408    * @param order
3409    *          DOCUMENT ME!
3410    */
3411   public void addSortByOrderMenuItem(String title,
3412           final AlignmentOrder order)
3413   {
3414     final JMenuItem item = new JMenuItem("by " + title);
3415     sort.add(item);
3416     item.addActionListener(new java.awt.event.ActionListener()
3417     {
3418       public void actionPerformed(ActionEvent e)
3419       {
3420         SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3421
3422         // TODO: JBPNote - have to map order entries to curent SequenceI
3423         // pointers
3424         AlignmentSorter.sortBy(viewport.getAlignment(), order);
3425
3426         addHistoryItem(new OrderCommand(order.getName(), oldOrder,
3427                 viewport.alignment));
3428
3429         alignPanel.paintAlignment(true);
3430       }
3431     });
3432   }
3433
3434   /**
3435    * Add a new sort by annotation score menu item
3436    *
3437    * @param sort
3438    *          the menu to add the option to
3439    * @param scoreLabel
3440    *          the label used to retrieve scores for each sequence on the
3441    *          alignment
3442    */
3443   public void addSortByAnnotScoreMenuItem(JMenu sort,
3444           final String scoreLabel)
3445   {
3446     final JMenuItem item = new JMenuItem(scoreLabel);
3447     sort.add(item);
3448     item.addActionListener(new java.awt.event.ActionListener()
3449     {
3450       public void actionPerformed(ActionEvent e)
3451       {
3452         SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3453         AlignmentSorter.sortByAnnotationScore(scoreLabel, viewport
3454                 .getAlignment());// ,viewport.getSelectionGroup());
3455         addHistoryItem(new OrderCommand("Sort by " + scoreLabel, oldOrder,
3456                 viewport.alignment));
3457         alignPanel.paintAlignment(true);
3458       }
3459     });
3460   }
3461
3462   /**
3463    * last hash for alignment's annotation array - used to minimise cost of
3464    * rebuild.
3465    */
3466   protected int _annotationScoreVectorHash;
3467
3468   /**
3469    * search the alignment and rebuild the sort by annotation score submenu the
3470    * last alignment annotation vector hash is stored to minimize cost of
3471    * rebuilding in subsequence calls.
3472    *
3473    */
3474   public void buildSortByAnnotationScoresMenu()
3475   {
3476     if (viewport.alignment.getAlignmentAnnotation() == null)
3477     {
3478       return;
3479     }
3480
3481     if (viewport.alignment.getAlignmentAnnotation().hashCode() != _annotationScoreVectorHash)
3482     {
3483       sortByAnnotScore.removeAll();
3484       // almost certainly a quicker way to do this - but we keep it simple
3485       Hashtable scoreSorts = new Hashtable();
3486       AlignmentAnnotation aann[];
3487       Enumeration sq = viewport.alignment.getSequences().elements();
3488       while (sq.hasMoreElements())
3489       {
3490         aann = ((SequenceI) sq.nextElement()).getAnnotation();
3491         for (int i = 0; aann != null && i < aann.length; i++)
3492         {
3493           if (aann[i].hasScore() && aann[i].sequenceRef != null)
3494           {
3495             scoreSorts.put(aann[i].label, aann[i].label);
3496           }
3497         }
3498       }
3499       Enumeration labels = scoreSorts.keys();
3500       while (labels.hasMoreElements())
3501       {
3502         addSortByAnnotScoreMenuItem(sortByAnnotScore, (String) labels
3503                 .nextElement());
3504       }
3505       sortByAnnotScore.setVisible(scoreSorts.size() > 0);
3506       scoreSorts.clear();
3507
3508       _annotationScoreVectorHash = viewport.alignment
3509               .getAlignmentAnnotation().hashCode();
3510     }
3511   }
3512
3513   /**
3514    * Maintain the Order by->Displayed Tree menu. Creates a new menu item for a
3515    * TreePanel with an appropriate <code>jalview.analysis.AlignmentSorter</code>
3516    * call. Listeners are added to remove the menu item when the treePanel is
3517    * closed, and adjust the tree leaf to sequence mapping when the alignment is
3518    * modified.
3519    *
3520    * @param treePanel
3521    *          Displayed tree window.
3522    * @param title
3523    *          SortBy menu item title.
3524    */
3525   public void buildTreeMenu()
3526   {
3527     sortByTreeMenu.removeAll();
3528
3529     Vector comps = (Vector) PaintRefresher.components.get(viewport
3530             .getSequenceSetId());
3531     Vector treePanels = new Vector();
3532     int i, iSize = comps.size();
3533     for (i = 0; i < iSize; i++)
3534     {
3535       if (comps.elementAt(i) instanceof TreePanel)
3536       {
3537         treePanels.add(comps.elementAt(i));
3538       }
3539     }
3540
3541     iSize = treePanels.size();
3542
3543     if (iSize < 1)
3544     {
3545       sortByTreeMenu.setVisible(false);
3546       return;
3547     }
3548
3549     sortByTreeMenu.setVisible(true);
3550
3551     for (i = 0; i < treePanels.size(); i++)
3552     {
3553       TreePanel tp = (TreePanel) treePanels.elementAt(i);
3554       final JMenuItem item = new JMenuItem(tp.getTitle());
3555       final NJTree tree = ((TreePanel) treePanels.elementAt(i)).getTree();
3556       item.addActionListener(new java.awt.event.ActionListener()
3557       {
3558         public void actionPerformed(ActionEvent e)
3559         {
3560           SequenceI[] oldOrder = viewport.getAlignment()
3561                   .getSequencesArray();
3562           AlignmentSorter.sortByTree(viewport.getAlignment(), tree);
3563
3564           addHistoryItem(new OrderCommand("Tree Sort", oldOrder,
3565                   viewport.alignment));
3566
3567           alignPanel.paintAlignment(true);
3568         }
3569       });
3570
3571       sortByTreeMenu.add(item);
3572     }
3573   }
3574
3575   /**
3576    * Work out whether the whole set of sequences or just the selected set will
3577    * be submitted for multiple alignment.
3578    *
3579    */
3580   public jalview.datamodel.AlignmentView gatherSequencesForAlignment()
3581   {
3582     // Now, check we have enough sequences
3583     AlignmentView msa = null;
3584
3585     if ((viewport.getSelectionGroup() != null)
3586             && (viewport.getSelectionGroup().getSize() > 1))
3587     {
3588       // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to
3589       // some common interface!
3590       /*
3591        * SequenceGroup seqs = viewport.getSelectionGroup(); int sz; msa = new
3592        * SequenceI[sz = seqs.getSize(false)];
3593        *
3594        * for (int i = 0; i < sz; i++) { msa[i] = (SequenceI)
3595        * seqs.getSequenceAt(i); }
3596        */
3597       msa = viewport.getAlignmentView(true);
3598     }
3599     else
3600     {
3601       /*
3602        * Vector seqs = viewport.getAlignment().getSequences();
3603        *
3604        * if (seqs.size() > 1) { msa = new SequenceI[seqs.size()];
3605        *
3606        * for (int i = 0; i < seqs.size(); i++) { msa[i] = (SequenceI)
3607        * seqs.elementAt(i); } }
3608        */
3609       msa = viewport.getAlignmentView(false);
3610     }
3611     return msa;
3612   }
3613
3614   /**
3615    * Decides what is submitted to a secondary structure prediction service: the
3616    * first sequence in the alignment, or in the current selection, or, if the
3617    * alignment is 'aligned' (ie padded with gaps), then the currently selected
3618    * region or the whole alignment. (where the first sequence in the set is the
3619    * one that the prediction will be for).
3620    */
3621   public AlignmentView gatherSeqOrMsaForSecStrPrediction()
3622   {
3623     AlignmentView seqs = null;
3624
3625     if ((viewport.getSelectionGroup() != null)
3626             && (viewport.getSelectionGroup().getSize() > 0))
3627     {
3628       seqs = viewport.getAlignmentView(true);
3629     }
3630     else
3631     {
3632       seqs = viewport.getAlignmentView(false);
3633     }
3634     // limit sequences - JBPNote in future - could spawn multiple prediction
3635     // jobs
3636     // TODO: viewport.alignment.isAligned is a global state - the local
3637     // selection may well be aligned - we preserve 2.0.8 behaviour for moment.
3638     if (!viewport.alignment.isAligned())
3639     {
3640       seqs.setSequences(new SeqCigar[]
3641       { seqs.getSequences()[0] });
3642       // TODO: if seqs.getSequences().length>1 then should really have warned user!
3643
3644     }
3645     return seqs;
3646   }
3647
3648   /**
3649    * DOCUMENT ME!
3650    *
3651    * @param e
3652    *          DOCUMENT ME!
3653    */
3654   protected void LoadtreeMenuItem_actionPerformed(ActionEvent e)
3655   {
3656     // Pick the tree file
3657     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache
3658             .getProperty("LAST_DIRECTORY"));
3659     chooser.setFileView(new JalviewFileView());
3660     chooser.setDialogTitle("Select a newick-like tree file");
3661     chooser.setToolTipText("Load a tree file");
3662
3663     int value = chooser.showOpenDialog(null);
3664
3665     if (value == JalviewFileChooser.APPROVE_OPTION)
3666     {
3667       String choice = chooser.getSelectedFile().getPath();
3668       jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);
3669       jalview.io.NewickFile fin = null;
3670       try
3671       {
3672         fin = new jalview.io.NewickFile(choice, "File");
3673         viewport.setCurrentTree(ShowNewickTree(fin, choice).getTree());
3674       } catch (Exception ex)
3675       {
3676         JOptionPane.showMessageDialog(Desktop.desktop, ex.getMessage(),
3677                 "Problem reading tree file", JOptionPane.WARNING_MESSAGE);
3678         ex.printStackTrace();
3679       }
3680       if (fin != null && fin.hasWarningMessage())
3681       {
3682         JOptionPane.showMessageDialog(Desktop.desktop, fin
3683                 .getWarningMessage(), "Possible problem with tree file",
3684                 JOptionPane.WARNING_MESSAGE);
3685       }
3686     }
3687   }
3688
3689   public TreePanel ShowNewickTree(NewickFile nf, String title)
3690   {
3691     return ShowNewickTree(nf, title, 600, 500, 4, 5);
3692   }
3693
3694   public TreePanel ShowNewickTree(NewickFile nf, String title,
3695           AlignmentView input)
3696   {
3697     return ShowNewickTree(nf, title, input, 600, 500, 4, 5);
3698   }
3699
3700   public TreePanel ShowNewickTree(NewickFile nf, String title, int w,
3701           int h, int x, int y)
3702   {
3703     return ShowNewickTree(nf, title, null, w, h, x, y);
3704   }
3705
3706   /**
3707    * Add a treeviewer for the tree extracted from a newick file object to the
3708    * current alignment view
3709    *
3710    * @param nf
3711    *          the tree
3712    * @param title
3713    *          tree viewer title
3714    * @param input
3715    *          Associated alignment input data (or null)
3716    * @param w
3717    *          width
3718    * @param h
3719    *          height
3720    * @param x
3721    *          position
3722    * @param y
3723    *          position
3724    * @return TreePanel handle
3725    */
3726   public TreePanel ShowNewickTree(NewickFile nf, String title,
3727           AlignmentView input, int w, int h, int x, int y)
3728   {
3729     TreePanel tp = null;
3730
3731     try
3732     {
3733       nf.parse();
3734
3735       if (nf.getTree() != null)
3736       {
3737         tp = new TreePanel(alignPanel, "FromFile", title, nf, input);
3738
3739         tp.setSize(w, h);
3740
3741         if (x > 0 && y > 0)
3742         {
3743           tp.setLocation(x, y);
3744         }
3745
3746         Desktop.addInternalFrame(tp, title, w, h);
3747       }
3748     } catch (Exception ex)
3749     {
3750       ex.printStackTrace();
3751     }
3752
3753     return tp;
3754   }
3755
3756   /**
3757    * Generates menu items and listener event actions for web service clients
3758    *
3759    */
3760   public void BuildWebServiceMenu()
3761   {
3762     // TODO: add support for context dependent disabling of services based on
3763     // alignment and current selection
3764     // TODO: add additional serviceHandle parameter to specify abstract handler
3765     // class independently of AbstractName
3766     // TODO: add in rediscovery GUI function to restart discoverer
3767     // TODO: group services by location as well as function and/or introduce
3768     // object broker mechanism.
3769     if ((Discoverer.services != null) && (Discoverer.services.size() > 0))
3770     {
3771       // TODO: refactor to allow list of AbstractName/Handler bindings to be
3772       // stored or retrieved from elsewhere
3773       Vector msaws = (Vector) Discoverer.services.get("MsaWS");
3774       Vector secstrpr = (Vector) Discoverer.services.get("SecStrPred");
3775       Vector seqsrch = (Vector) Discoverer.services.get("SeqSearch");
3776       // TODO: move GUI generation code onto service implementation - so a
3777       // client instance attaches itself to the GUI with method call like
3778       // jalview.ws.MsaWSClient.bind(servicehandle, Desktop.instance,
3779       // alignframe)
3780       Vector wsmenu = new Vector();
3781       final IProgressIndicator af = this;
3782       if (msaws != null)
3783       {
3784         // Add any Multiple Sequence Alignment Services
3785         final JMenu msawsmenu = new JMenu("Alignment");
3786         for (int i = 0, j = msaws.size(); i < j; i++)
3787         {
3788           final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) msaws
3789                   .get(i);
3790           jalview.ws.WSClient impl = jalview.ws.Discoverer
3791                   .getServiceClient(sh);
3792           impl.attachWSMenuEntry(msawsmenu, this);
3793
3794         }
3795         wsmenu.add(msawsmenu);
3796       }
3797       if (secstrpr != null)
3798       {
3799         // Add any secondary structure prediction services
3800         final JMenu secstrmenu = new JMenu("Secondary Structure Prediction");
3801         for (int i = 0, j = secstrpr.size(); i < j; i++)
3802         {
3803           final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) secstrpr
3804                   .get(i);
3805           jalview.ws.WSClient impl = jalview.ws.Discoverer
3806                   .getServiceClient(sh);
3807           impl.attachWSMenuEntry(secstrmenu, this);
3808         }
3809         wsmenu.add(secstrmenu);
3810       }
3811       if (seqsrch != null)
3812       {
3813         // Add any sequence search services
3814         final JMenu seqsrchmenu = new JMenu("Sequence Database Search");
3815         for (int i = 0, j = seqsrch.size(); i < j; i++)
3816         {
3817           final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) seqsrch
3818                   .elementAt(i);
3819           jalview.ws.WSClient impl = jalview.ws.Discoverer
3820                   .getServiceClient(sh);
3821           impl.attachWSMenuEntry(seqsrchmenu, this);
3822         }
3823         wsmenu.add(seqsrchmenu);
3824       }
3825       // finally, add the whole shebang onto the webservices menu
3826       resetWebServiceMenu();
3827       for (int i = 0, j = wsmenu.size(); i < j; i++)
3828       {
3829         webService.add((JMenu) wsmenu.get(i));
3830       }
3831     }
3832     else
3833     {
3834       resetWebServiceMenu();
3835       this.webService.add(this.webServiceNoServices);
3836     }
3837   }
3838
3839   /**
3840    * empty the web service menu and add any ad-hoc functions not dynamically
3841    * discovered.
3842    *
3843    */
3844   private void resetWebServiceMenu()
3845   {
3846     webService.removeAll();
3847     build_fetchdbmenu(webService);
3848     build_urlServiceMenu(webService);
3849   }
3850
3851   /**
3852    * construct any groupURL type service menu entries.
3853    * @param webService
3854    */
3855   private void build_urlServiceMenu(JMenu webService)
3856   {
3857     jalview.ws.EnfinEnvision2OneWay.getInstance().attachWSMenuEntry(webService, this);
3858   }
3859
3860   /*
3861    * public void vamsasStore_actionPerformed(ActionEvent e) { JalviewFileChooser
3862    * chooser = new JalviewFileChooser(jalview.bin.Cache.
3863    * getProperty("LAST_DIRECTORY"));
3864    *
3865    * chooser.setFileView(new JalviewFileView()); chooser.setDialogTitle("Export
3866    * to Vamsas file"); chooser.setToolTipText("Export");
3867    *
3868    * int value = chooser.showSaveDialog(this);
3869    *
3870    * if (value == JalviewFileChooser.APPROVE_OPTION) {
3871    * jalview.io.VamsasDatastore vs = new jalview.io.VamsasDatastore(viewport);
3872    * //vs.store(chooser.getSelectedFile().getAbsolutePath() ); vs.storeJalview(
3873    * chooser.getSelectedFile().getAbsolutePath(), this); } }
3874    */
3875   /**
3876    * prototype of an automatically enabled/disabled analysis function
3877    *
3878    */
3879   protected void setShowProductsEnabled()
3880   {
3881     SequenceI[] selection = viewport.getSequenceSelection();
3882     if (canShowProducts(selection, viewport.getSelectionGroup() != null,
3883             viewport.getAlignment().getDataset()))
3884     {
3885       showProducts.setEnabled(true);
3886
3887     }
3888     else
3889     {
3890       showProducts.setEnabled(false);
3891     }
3892   }
3893
3894   /**
3895    * search selection for sequence xRef products and build the show products
3896    * menu.
3897    *
3898    * @param selection
3899    * @param dataset
3900    * @return true if showProducts menu should be enabled.
3901    */
3902   public boolean canShowProducts(SequenceI[] selection,
3903           boolean isRegionSelection, Alignment dataset)
3904   {
3905     boolean showp = false;
3906     try
3907     {
3908       showProducts.removeAll();
3909       final boolean dna = viewport.getAlignment().isNucleotide();
3910       final Alignment ds = dataset;
3911       String[] ptypes = (selection == null || selection.length == 0) ? null
3912               : CrossRef.findSequenceXrefTypes(dna, selection, dataset);
3913       // Object[] prods =
3914       // CrossRef.buildXProductsList(viewport.getAlignment().isNucleotide(),
3915       // selection, dataset, true);
3916       final SequenceI[] sel = selection;
3917       for (int t = 0; ptypes != null && t < ptypes.length; t++)
3918       {
3919         showp = true;
3920         final boolean isRegSel = isRegionSelection;
3921         final AlignFrame af = this;
3922         final String source = ptypes[t];
3923         JMenuItem xtype = new JMenuItem(ptypes[t]);
3924         xtype.addActionListener(new ActionListener()
3925         {
3926
3927           public void actionPerformed(ActionEvent e)
3928           {
3929             // TODO: new thread for this call with vis-delay
3930             af.showProductsFor(af.viewport.getSequenceSelection(), ds,
3931                     isRegSel, dna, source);
3932           }
3933
3934         });
3935         showProducts.add(xtype);
3936       }
3937       showProducts.setVisible(showp);
3938       showProducts.setEnabled(showp);
3939     } catch (Exception e)
3940     {
3941       jalview.bin.Cache.log
3942               .warn(
3943                       "canTranslate threw an exception - please report to help@jalview.org",
3944                       e);
3945       return false;
3946     }
3947     return showp;
3948   }
3949
3950   protected void showProductsFor(SequenceI[] sel, Alignment ds,
3951           boolean isRegSel, boolean dna, String source)
3952   {
3953     final boolean fisRegSel = isRegSel;
3954     final boolean fdna = dna;
3955     final String fsrc = source;
3956     final AlignFrame ths = this;
3957     final SequenceI[] fsel = sel;
3958     Runnable foo = new Runnable()
3959     {
3960
3961       public void run()
3962       {
3963         final long sttime = System.currentTimeMillis();
3964         ths.setProgressBar("Searching for sequences from " + fsrc, sttime);
3965         try
3966         {
3967           Alignment ds = ths.getViewport().alignment.getDataset(); // update
3968           // our local
3969           // dataset
3970           // reference
3971           Alignment prods = CrossRef
3972                   .findXrefSequences(fsel, fdna, fsrc, ds);
3973           if (prods != null)
3974           {
3975             SequenceI[] sprods = new SequenceI[prods.getHeight()];
3976             for (int s = 0; s < sprods.length; s++)
3977             {
3978               sprods[s] = (prods.getSequenceAt(s)).deriveSequence();
3979               if (ds.getSequences() == null
3980                       || !ds.getSequences().contains(
3981                               sprods[s].getDatasetSequence()))
3982                 ds.addSequence(sprods[s].getDatasetSequence());
3983               sprods[s].updatePDBIds();
3984             }
3985             Alignment al = new Alignment(sprods);
3986             AlignedCodonFrame[] cf = prods.getCodonFrames();
3987             al.setDataset(ds);
3988             for (int s = 0; cf != null && s < cf.length; s++)
3989             {
3990               al.addCodonFrame(cf[s]);
3991               cf[s] = null;
3992             }
3993             AlignFrame naf = new AlignFrame(al, DEFAULT_WIDTH,
3994                     DEFAULT_HEIGHT);
3995             String newtitle = "" + ((fdna) ? "Proteins " : "Nucleotides ")
3996                     + " for " + ((fisRegSel) ? "selected region of " : "")
3997                     + getTitle();
3998             Desktop.addInternalFrame(naf, newtitle, DEFAULT_WIDTH,
3999                     DEFAULT_HEIGHT);
4000           }
4001           else
4002           {
4003             System.err.println("No Sequences generated for xRef type "
4004                     + fsrc);
4005           }
4006         } catch (Exception e)
4007         {
4008           jalview.bin.Cache.log.error(
4009                   "Exception when finding crossreferences", e);
4010         } catch (OutOfMemoryError e)
4011         {
4012           new OOMWarning("whilst fetching crossreferences", e);
4013         } catch (Error e)
4014         {
4015           jalview.bin.Cache.log.error("Error when finding crossreferences",
4016                   e);
4017         }
4018         ths.setProgressBar("Finished searching for sequences from " + fsrc,
4019                 sttime);
4020       }
4021
4022     };
4023     Thread frunner = new Thread(foo);
4024     frunner.start();
4025   }
4026
4027   public boolean canShowTranslationProducts(SequenceI[] selection,
4028           AlignmentI alignment)
4029   {
4030     // old way
4031     try
4032     {
4033       return (jalview.analysis.Dna.canTranslate(selection, viewport
4034               .getViewAsVisibleContigs(true)));
4035     } catch (Exception e)
4036     {
4037       jalview.bin.Cache.log
4038               .warn(
4039                       "canTranslate threw an exception - please report to help@jalview.org",
4040                       e);
4041       return false;
4042     }
4043   }
4044
4045   public void showProducts_actionPerformed(ActionEvent e)
4046   {
4047     // /////////////////////////////
4048     // Collect Data to be translated/transferred
4049
4050     SequenceI[] selection = viewport.getSequenceSelection();
4051     AlignmentI al = null;
4052     try
4053     {
4054       al = jalview.analysis.Dna.CdnaTranslate(selection, viewport
4055               .getViewAsVisibleContigs(true), viewport.getGapCharacter(),
4056               viewport.getAlignment().getDataset());
4057     } catch (Exception ex)
4058     {
4059       al = null;
4060       jalview.bin.Cache.log.debug("Exception during translation.", ex);
4061     }
4062     if (al == null)
4063     {
4064       JOptionPane
4065               .showMessageDialog(
4066                       Desktop.desktop,
4067                       "Please select at least three bases in at least one sequence in order to perform a cDNA translation.",
4068                       "Translation Failed", JOptionPane.WARNING_MESSAGE);
4069     }
4070     else
4071     {
4072       AlignFrame af = new AlignFrame(al, DEFAULT_WIDTH, DEFAULT_HEIGHT);
4073       Desktop.addInternalFrame(af, "Translation of " + this.getTitle(),
4074               DEFAULT_WIDTH, DEFAULT_HEIGHT);
4075     }
4076   }
4077
4078   public void showTranslation_actionPerformed(ActionEvent e)
4079   {
4080     // /////////////////////////////
4081     // Collect Data to be translated/transferred
4082
4083     SequenceI[] selection = viewport.getSequenceSelection();
4084     String[] seqstring = viewport.getViewAsString(true);
4085     AlignmentI al = null;
4086     try
4087     {
4088       al = jalview.analysis.Dna.CdnaTranslate(selection, seqstring,
4089               viewport.getViewAsVisibleContigs(true), viewport
4090                       .getGapCharacter(), viewport.alignment
4091                       .getAlignmentAnnotation(), viewport.alignment
4092                       .getWidth(), viewport.getAlignment().getDataset());
4093     } catch (Exception ex)
4094     {
4095       al = null;
4096       jalview.bin.Cache.log.debug("Exception during translation.", ex);
4097     }
4098     if (al == null)
4099     {
4100       JOptionPane
4101               .showMessageDialog(
4102                       Desktop.desktop,
4103                       "Please select at least three bases in at least one sequence in order to perform a cDNA translation.",
4104                       "Translation Failed", JOptionPane.WARNING_MESSAGE);
4105     }
4106     else
4107     {
4108       AlignFrame af = new AlignFrame(al, DEFAULT_WIDTH, DEFAULT_HEIGHT);
4109       Desktop.addInternalFrame(af, "Translation of " + this.getTitle(),
4110               DEFAULT_WIDTH, DEFAULT_HEIGHT);
4111     }
4112   }
4113
4114   /**
4115    * Try to load a features file onto the alignment.
4116    *
4117    * @param file
4118    *          contents or path to retrieve file
4119    * @param type
4120    *          access mode of file (see jalview.io.AlignFile)
4121    * @return true if features file was parsed corectly.
4122    */
4123   public boolean parseFeaturesFile(String file, String type)
4124   {
4125     boolean featuresFile = false;
4126     try
4127     {
4128       featuresFile = new FeaturesFile(file, type).parse(viewport.alignment
4129               .getDataset(), alignPanel.seqPanel.seqCanvas
4130               .getFeatureRenderer().featureColours, false);
4131     } catch (Exception ex)
4132     {
4133       ex.printStackTrace();
4134     }
4135
4136     if (featuresFile)
4137     {
4138       viewport.showSequenceFeatures = true;
4139       showSeqFeatures.setSelected(true);
4140       if (alignPanel.seqPanel.seqCanvas.fr != null)
4141       {
4142         // update the min/max ranges where necessary
4143         alignPanel.seqPanel.seqCanvas.fr.findAllFeatures(true);
4144       }
4145       if (featureSettings!=null)
4146       {
4147         featureSettings.setTableData();
4148       }
4149       alignPanel.paintAlignment(true);
4150     }
4151
4152     return featuresFile;
4153   }
4154
4155   public void dragEnter(DropTargetDragEvent evt)
4156   {
4157   }
4158
4159   public void dragExit(DropTargetEvent evt)
4160   {
4161   }
4162
4163   public void dragOver(DropTargetDragEvent evt)
4164   {
4165   }
4166
4167   public void dropActionChanged(DropTargetDragEvent evt)
4168   {
4169   }
4170
4171   public void drop(DropTargetDropEvent evt)
4172   {
4173     Transferable t = evt.getTransferable();
4174     java.util.List files = null;
4175
4176     try
4177     {
4178       DataFlavor uriListFlavor = new DataFlavor(
4179               "text/uri-list;class=java.lang.String");
4180       if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor))
4181       {
4182         // Works on Windows and MacOSX
4183         evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
4184         files = (java.util.List) t
4185                 .getTransferData(DataFlavor.javaFileListFlavor);
4186       }
4187       else if (t.isDataFlavorSupported(uriListFlavor))
4188       {
4189         // This is used by Unix drag system
4190         evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
4191         String data = (String) t.getTransferData(uriListFlavor);
4192         files = new java.util.ArrayList(1);
4193         for (java.util.StringTokenizer st = new java.util.StringTokenizer(
4194                 data, "\r\n"); st.hasMoreTokens();)
4195         {
4196           String s = st.nextToken();
4197           if (s.startsWith("#"))
4198           {
4199             // the line is a comment (as per the RFC 2483)
4200             continue;
4201           }
4202
4203           java.net.URI uri = new java.net.URI(s);
4204           // check to see if we can handle this kind of URI
4205           if (uri.getScheme().toLowerCase().startsWith("http"))
4206           {
4207             files.add(uri.toString());
4208           }
4209           else
4210           {
4211             // otherwise preserve old behaviour: catch all for file objects
4212             java.io.File file = new java.io.File(uri);
4213             files.add(file.toString());
4214           }
4215         }
4216       }
4217     } catch (Exception e)
4218     {
4219       e.printStackTrace();
4220     }
4221     if (files != null)
4222     {
4223       try
4224       {
4225
4226         for (int i = 0; i < files.size(); i++)
4227         {
4228           loadJalviewDataFile(files.get(i).toString());
4229         }
4230       } catch (Exception ex)
4231       {
4232         ex.printStackTrace();
4233       }
4234     }
4235   }
4236
4237   /**
4238    * Attempt to load a "dropped" file or URL string: First by testing whether
4239    * it's and Annotation file, then a JNet file, and finally a features file. If
4240    * all are false then the user may have dropped an alignment file onto this
4241    * AlignFrame.
4242    *
4243    * @param file
4244    *          either a filename or a URL string.
4245    */
4246   public void loadJalviewDataFile(String file)
4247   {
4248     try
4249     {
4250       String protocol = jalview.io.FormatAdapter.FILE;
4251       String f = file.toLowerCase();
4252       if (f.indexOf("http:") == 0 || f.indexOf("https:") == 0
4253               || f.indexOf("file:") == 0)
4254       {
4255         protocol = jalview.io.FormatAdapter.URL;
4256       }
4257
4258       boolean isAnnotation = new AnnotationFile().readAnnotationFile(
4259               viewport.alignment, file, protocol);
4260
4261       if (!isAnnotation)
4262       {
4263         // try to see if its a JNet 'concise' style annotation file *before* we
4264         // try to parse it as a features file
4265         String format = new IdentifyFile().Identify(file, protocol);
4266         if (format.equalsIgnoreCase("JnetFile"))
4267         {
4268           jalview.io.JPredFile predictions = new jalview.io.JPredFile(file,
4269                   protocol);
4270           new JnetAnnotationMaker().add_annotation(predictions, viewport
4271                   .getAlignment(), 0, false);
4272           isAnnotation = true;
4273         }
4274         else
4275         {
4276           // try to parse it as a features file
4277           boolean isGroupsFile = parseFeaturesFile(file, protocol);
4278           // if it wasn't a features file then we just treat it as a general
4279           // alignment file to load into the current view.
4280           if (!isGroupsFile)
4281           {
4282             new FileLoader().LoadFile(viewport, file, protocol, format);
4283           }
4284           else
4285           {
4286             alignPanel.paintAlignment(true);
4287           }
4288         }
4289       }
4290       if (isAnnotation)
4291       {
4292
4293         alignPanel.adjustAnnotationHeight();
4294         viewport.updateSequenceIdColours();
4295         buildSortByAnnotationScoresMenu();
4296         alignPanel.paintAlignment(true);
4297       }
4298     } catch (Exception ex)
4299     {
4300       ex.printStackTrace();
4301     }
4302   }
4303
4304   public void tabSelectionChanged(int index)
4305   {
4306     if (index > -1)
4307     {
4308       alignPanel = (AlignmentPanel) alignPanels.elementAt(index);
4309       viewport = alignPanel.av;
4310       setMenusFromViewport(viewport);
4311     }
4312   }
4313
4314   public void tabbedPane_mousePressed(MouseEvent e)
4315   {
4316     if (SwingUtilities.isRightMouseButton(e))
4317     {
4318       String reply = JOptionPane.showInternalInputDialog(this,
4319               "Enter View Name", "Edit View Name",
4320               JOptionPane.QUESTION_MESSAGE);
4321
4322       if (reply != null)
4323       {
4324         viewport.viewName = reply;
4325         tabbedPane.setTitleAt(tabbedPane.getSelectedIndex(), reply);
4326       }
4327     }
4328   }
4329
4330   public AlignViewport getCurrentView()
4331   {
4332     return viewport;
4333   }
4334
4335   /**
4336    * Open the dialog for regex description parsing.
4337    */
4338   protected void extractScores_actionPerformed(ActionEvent e)
4339   {
4340     ParseProperties pp = new jalview.analysis.ParseProperties(
4341             viewport.alignment);
4342     // TODO: verify regex and introduce GUI dialog for version 2.5
4343     // if (pp.getScoresFromDescription("col", "score column ",
4344     // "\\W*([-+]?\\d*\\.?\\d*e?-?\\d*)\\W+([-+]?\\d*\\.?\\d*e?-?\\d*)",
4345     // true)>0)
4346     if (pp.getScoresFromDescription("description column",
4347             "score in description column ", "\\W*([-+eE0-9.]+)", true) > 0)
4348     {
4349       buildSortByAnnotationScoresMenu();
4350     }
4351   }
4352
4353   /*
4354    * (non-Javadoc)
4355    *
4356    * @see
4357    * jalview.jbgui.GAlignFrame#showDbRefs_actionPerformed(java.awt.event.ActionEvent
4358    * )
4359    */
4360   protected void showDbRefs_actionPerformed(ActionEvent e)
4361   {
4362     viewport.setShowDbRefs(showDbRefsMenuitem.isSelected());
4363   }
4364
4365   /*
4366    * (non-Javadoc)
4367    *
4368    * @seejalview.jbgui.GAlignFrame#showNpFeats_actionPerformed(java.awt.event.
4369    * ActionEvent)
4370    */
4371   protected void showNpFeats_actionPerformed(ActionEvent e)
4372   {
4373     viewport.setShowNpFeats(showNpFeatsMenuitem.isSelected());
4374   }
4375
4376   /**
4377    * find the viewport amongst the tabs in this alignment frame and close that
4378    * tab
4379    *
4380    * @param av
4381    */
4382   public boolean closeView(AlignViewport av)
4383   {
4384     if (viewport == av)
4385     {
4386       this.closeMenuItem_actionPerformed(false);
4387       return true;
4388     }
4389     Component[] comp = tabbedPane.getComponents();
4390     for (int i = 0; comp != null && i < comp.length; i++)
4391     {
4392       if (comp[i] instanceof AlignmentPanel)
4393       {
4394         if (((AlignmentPanel) comp[i]).av == av)
4395         {
4396           // close the view.
4397           closeView((AlignmentPanel) comp[i]);
4398           return true;
4399         }
4400       }
4401     }
4402     return false;
4403   }
4404
4405   protected void build_fetchdbmenu(JMenu webService)
4406   {
4407     // Temporary hack - DBRef Fetcher always top level ws entry.
4408     // TODO We probably want to store a sequence database checklist in
4409     // preferences and have checkboxes.. rather than individual sources selected
4410     // here
4411     JMenu rfetch = new JMenu("Fetch DB References");
4412     rfetch
4413             .setToolTipText("Retrieve and parse sequence database records for the alignment or the currently selected sequences");
4414     webService.add(rfetch);
4415
4416     JMenuItem fetchr = new JMenuItem("Standard Databases");
4417     fetchr
4418             .setToolTipText("Fetch from EMBL/EMBLCDS or Uniprot/PDB and any selected DAS sources");
4419     fetchr.addActionListener(new ActionListener()
4420     {
4421
4422       public void actionPerformed(ActionEvent e)
4423       {
4424         new Thread(new Runnable()
4425         {
4426
4427           public void run()
4428           {
4429             new jalview.ws.DBRefFetcher(alignPanel.av
4430                     .getSequenceSelection(), alignPanel.alignFrame)
4431                     .fetchDBRefs(false);
4432           }
4433         }).start();
4434
4435       }
4436
4437     });
4438     rfetch.add(fetchr);
4439     JMenu dfetch = new JMenu();
4440     rfetch.add(dfetch);
4441     jalview.ws.SequenceFetcher sf = SequenceFetcher
4442             .getSequenceFetcherSingleton(this);
4443     String[] otherdb = sf.getOrderedSupportedSources();
4444     // sf.getDbInstances(jalview.ws.dbsources.DasSequenceSource.class);
4445     // jalview.util.QuickSort.sort(otherdb, otherdb);
4446     int comp = 0, mcomp = 15;
4447     String mname = null;
4448     if (otherdb != null && otherdb.length > 0)
4449     {
4450       for (int i = 0; i < otherdb.length; i++)
4451       {
4452         String dbname = sf.getSourceProxy(otherdb[i]).getDbName();
4453         if (mname == null)
4454         {
4455           mname = "from '" + dbname + "'";
4456         }
4457         fetchr = new JMenuItem(otherdb[i]);
4458         final String[] dassource = new String[]
4459         { otherdb[i] };
4460         fetchr.addActionListener(new ActionListener()
4461         {
4462
4463           public void actionPerformed(ActionEvent e)
4464           {
4465             new Thread(new Runnable()
4466             {
4467
4468               public void run()
4469               {
4470                 new jalview.ws.DBRefFetcher(alignPanel.av
4471                         .getSequenceSelection(), alignPanel.alignFrame,
4472                         dassource).fetchDBRefs(false);
4473               }
4474             }).start();
4475           }
4476
4477         });
4478         fetchr.setToolTipText("Retrieve from " + dbname);
4479         dfetch.add(fetchr);
4480         if (comp++ == mcomp || i == (otherdb.length - 1))
4481         {
4482           dfetch.setText(mname + " to '" + dbname + "'");
4483           rfetch.add(dfetch);
4484           dfetch = new JMenu();
4485           mname = null;
4486           comp = 0;
4487         }
4488       }
4489     }
4490   }
4491
4492   /**
4493    * Left justify the whole alignment.
4494    */
4495   protected void justifyLeftMenuItem_actionPerformed(ActionEvent e)
4496   {
4497     AlignmentI al = viewport.getAlignment();
4498     al.justify(false);
4499     viewport.firePropertyChange("alignment", null, al);
4500   }
4501
4502   /**
4503    * Right justify the whole alignment.
4504    */
4505   protected void justifyRightMenuItem_actionPerformed(ActionEvent e)
4506   {
4507     AlignmentI al = viewport.getAlignment();
4508     al.justify(true);
4509     viewport.firePropertyChange("alignment", null, al);
4510   }
4511
4512   public void setShowSeqFeatures(boolean b)
4513   {
4514     showSeqFeatures.setSelected(true);
4515     viewport.setShowSequenceFeatures(true);
4516   }
4517
4518   /*
4519    * (non-Javadoc)
4520    *
4521    * @see
4522    * jalview.jbgui.GAlignFrame#showUnconservedMenuItem_actionPerformed(java.
4523    * awt.event.ActionEvent)
4524    */
4525   protected void showUnconservedMenuItem_actionPerformed(ActionEvent e)
4526   {
4527     viewport.setShowUnconserved(showUnconservedMenuItem.getState());
4528     alignPanel.paintAlignment(true);
4529   }
4530
4531   /*
4532    * (non-Javadoc)
4533    *
4534    * @see
4535    * jalview.jbgui.GAlignFrame#showGroupConsensus_actionPerformed(java.awt.event
4536    * .ActionEvent)
4537    */
4538   protected void showGroupConsensus_actionPerformed(ActionEvent e)
4539   {
4540     viewport.setShowGroupConsensus(showGroupConsensus.getState());
4541     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
4542
4543   }
4544
4545   /*
4546    * (non-Javadoc)
4547    *
4548    * @see
4549    * jalview.jbgui.GAlignFrame#showGroupConservation_actionPerformed(java.awt
4550    * .event.ActionEvent)
4551    */
4552   protected void showGroupConservation_actionPerformed(ActionEvent e)
4553   {
4554     viewport.setShowGroupConservation(showGroupConservation.getState());
4555     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
4556   }
4557
4558   /* (non-Javadoc)
4559    * @see jalview.jbgui.GAlignFrame#showConsensusHistogram_actionPerformed(java.awt.event.ActionEvent)
4560    */
4561   protected void showConsensusHistogram_actionPerformed(ActionEvent e)
4562   {
4563     viewport.setShowConsensusHistogram(showConsensusHistogram.getState());
4564     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
4565   }
4566
4567   /* (non-Javadoc)
4568    * @see jalview.jbgui.GAlignFrame#showConsensusProfile_actionPerformed(java.awt.event.ActionEvent)
4569    */
4570   protected void showSequenceLogo_actionPerformed(ActionEvent e)
4571   {
4572     viewport.setShowSequenceLogo(showSequenceLogo.getState());
4573     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
4574   }
4575   protected void applyAutoAnnotationSettings_actionPerformed(ActionEvent e)
4576   {
4577     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
4578   }
4579
4580   /*
4581    * (non-Javadoc)
4582    *
4583    * @see
4584    * jalview.jbgui.GAlignFrame#makeGrpsFromSelection_actionPerformed(java.awt
4585    * .event.ActionEvent)
4586    */
4587   protected void makeGrpsFromSelection_actionPerformed(ActionEvent e)
4588   {
4589     if (viewport.getSelectionGroup() != null)
4590     {
4591       SequenceGroup[] gps = jalview.analysis.Grouping.makeGroupsFrom(
4592               viewport.getSequenceSelection(), viewport.getAlignmentView(
4593                       true).getSequenceStrings(viewport.getGapCharacter()),
4594               viewport.alignment.getGroups());
4595       viewport.alignment.deleteAllGroups();
4596       viewport.sequenceColours = null;
4597       viewport.setSelectionGroup(null);
4598       // set view properties for each group
4599       for (int g = 0; g < gps.length; g++)
4600       {
4601         gps[g].setShowunconserved(viewport.getShowUnconserved());
4602         gps[g].setIncludeAllConsSymbols(viewport.isIncludeAllConsensusSymbols());
4603         viewport.alignment.addGroup(gps[g]);
4604         Color col = new Color((int) (Math.random() * 255), (int) (Math
4605                 .random() * 255), (int) (Math.random() * 255));
4606         col = col.brighter();
4607         for (Enumeration sq = gps[g].getSequences(null).elements(); sq
4608                 .hasMoreElements(); viewport.setSequenceColour(
4609                 (SequenceI) sq.nextElement(), col))
4610           ;
4611       }
4612       PaintRefresher.Refresh(this, viewport.getSequenceSetId());
4613       alignPanel.updateAnnotation();
4614       alignPanel.paintAlignment(true);
4615     }
4616   }
4617 }
4618
4619 class PrintThread extends Thread
4620 {
4621   AlignmentPanel ap;
4622
4623   public PrintThread(AlignmentPanel ap)
4624   {
4625     this.ap = ap;
4626   }
4627
4628   static PageFormat pf;
4629
4630   public void run()
4631   {
4632     PrinterJob printJob = PrinterJob.getPrinterJob();
4633
4634     if (pf != null)
4635     {
4636       printJob.setPrintable(ap, pf);
4637     }
4638     else
4639     {
4640       printJob.setPrintable(ap);
4641     }
4642
4643     if (printJob.printDialog())
4644     {
4645       try
4646       {
4647         printJob.print();
4648       } catch (Exception PrintException)
4649       {
4650         PrintException.printStackTrace();
4651       }
4652     }
4653   }
4654 }